Automating Ad-Hoc Analytics: Building a Self-Correcting Data Agent with Amazon Nova

#Initialization
from langchain_aws import ChatBedrock
#Nova Lite specifically chosen for its cheap, fast and well reasoning
nova_agent = ChatBedrock(
model_id="amazon.nova-lite-v1:0",
model_kwargs={
"max_tokens": 4096,
"temperature": 0.0  # Zero creativity, purely deterministic logic
}
)

#Generating a secure direct-upload pass
presigned_url = s3.generate_presigned_url(
ClientMethod='put_object',
Params={
'Bucket': S3_BUCKET_NAME,
'Key': file_key,
'ContentType': 'text/csv'
},
ExpiresIn=300
)

# Autonomous profiling: Inferring strict boundaries for the AI
for col in df.columns:
    col_meta = {}
    
    # Isolate and sanitize numeric data 
    if pd.api.types.is_numeric_dtype(df[col]):
        df[col] = df[col].fillna(df[col].median())
        col_meta['type'] = 'numeric'
        col_meta['min'] = round(float(df[col].min()), 2)
        col_meta['max'] = round(float(df[col].max()), 2)
        
    # Detect categorical boundaries to prevent LLM hallucination
    else:
        unique_count = df[col].nunique()
        if unique_count <= 20:
            col_meta['type'] = 'categorical'
            col_meta['allowed_values'] = df[col].unique().tolist()

# The Critic Loop: Forcing the AI to read its own traceback errors
try:
    cursor.execute(current_sql)
    return cursor.fetchall(), current_sql
    
except Exception as error_encountered:
    # We don't crash the app. We run the Critic.
    update_status(table, task_id, "executing", f"SQL Failed. Triggering Critic..")
    critic_sys = f"""You are an expert SQLite Critic. 
    ERROR: {error_encountered}
    FAILED SQL: {current_sql}
    ONTOLOGY: {json.dumps(ontology_map)}

    FIX THE SQL. 
    Use 'FROM dataset' and NO complex math functions. Respond with ONLY the raw SELECT statement."""
    
    raw = call_nova("Rewrite the broken SQL perfectly.", critic_sys)
    current_sql = clean_sql(raw)

# The Plotly Engine: Forcing the Lambda to serialize breathing graphs
if hasattr(px, c_type):
    plot_func = getattr(px, c_type)
    fig = plot_func(df_chart, x=x_col, y=y_col, color=actual_color)
else:
    # Fallback to bar chart if the AI hallucinates a weird chart type
    fig = px.bar(df_chart, x=x_col, y=y_col, color=actual_color, barmode='group')

# Stripping the background and injecting the dark mode UI state
fig.update_layout(
    template='plotly_dark', 
    paper_bgcolor='rgba(0,0,0,0)', 
    plot_bgcolor='rgba(0,0,0,0)'
)

# We don't send dead images. We send interactive JSON states.
c_json = json.loads(fig.to_json())
c_json["meta"] = {"scenario_id": p_id}

# Routing the massive Nova Sonic audio payload to S3
try:
    audio_bytes = base64.b64decode(audio_b64)
    file_key = f"audio_artifacts/{task_id}.wav"
    
    s3.put_object(
        Bucket=S3_BUCKET_NAME,
        Key=file_key,
        Body=audio_bytes,
        ContentType="audio/wav"
    )
    return s3.generate_presigned_url('get_object', Params={'Bucket': S3_BUCKET_NAME, 'Key': file_key}, ExpiresIn=86400)

// the frontend's magic: Bypassing the React DOM for zero-latency
useEffect(() => {
    if (!audioUrl) return;
    
    // We don't wait for React to render an <audio> tag. We hijack the native API.
    const edgeStream = new Audio(audioUrl);
    edgeStream.preload = "auto"; 
    
    edgeStream.oncanplaythrough = () => {
        setIsBuffering(false);
        // The buffer is hot. Play it instantly before the user even blinks.
        edgeStream.play().catch(e => console.warn("Autoplay blocked, but buffer is hot."));
    };
}, [audioUrl]);