Update backend.py

backend.py

@@ -3,9 +3,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
 from langchain_ollama import OllamaLLM
-from langchain.agents import AgentExecutor, create_react_agent
-from langchain.tools import tool
-from langchain import hub
+from langchain.prompts import PromptTemplate
+from langchain.chains import LLMChain
 import time, uuid
 
 app = FastAPI()
@@ -19,92 +18,90 @@ app.add_middleware(
 
 llm = OllamaLLM(model="qwen3", temperature=0.2)
 
-# ── Tools ──────────────────────────────────────────────────────────
+QWEN_PERSONA = (
+    "You are Qwen, the AutoPulse Bot — an expert AI safety analyst for autonomous vehicle fleets, "
+    "powered by Qwen3 running on AMD Instinct GPU."
+)
+
+def run_chain(system: str, input_text: str) -> str:
+    prompt = PromptTemplate.from_template("{system}\n\n{input}")
+    chain = LLMChain(llm=llm, prompt=prompt)
+    return chain.invoke({"system": system, "input": input_text})["text"]
 
-@tool
-def intake_incident(description: str) -> str:
-    """Step 1: Intake and classify an AV incident. Extract vehicle ID, timestamp, location, and incident type."""
-    return llm.invoke(
-        f"You are an AV intake agent. Extract and classify this incident. "
-        f"Return: vehicle_id, timestamp, location, incident_type, initial_severity (P1/P2/P3).\n\nIncident: {description}"
+def step1_intake(description: str) -> str:
+    return run_chain(
+        f"{QWEN_PERSONA} You are the Intake Agent. Extract and classify this AV incident. "
+        f"Return: vehicle_id, timestamp, location, incident_type, initial_severity (P1/P2/P3).",
+        f"Incident: {description}"
     )
 
-@tool
-def enrich_incident(intake_summary: str) -> str:
-    """Step 2: Enrich the incident with AV domain knowledge. Identify affected subsystems (GNSS, LiDAR, perception, planning, control)."""
-    return llm.invoke(
-        f"You are an AV enrichment agent. Given this intake summary, identify which AV subsystems are affected "
-        f"and what sensor or software failures may be involved.\n\nIntake: {intake_summary}"
+def step2_enrich(intake: str) -> str:
+    return run_chain(
+        f"{QWEN_PERSONA} You are the Enrichment Agent. Identify which AV subsystems are affected "
+        f"(GNSS, LiDAR, perception, planning, control) and what sensor or software failures may be involved.",
+        f"Intake summary: {intake}"
     )
 
-@tool
-def analyze_root_cause(enriched_summary: str) -> str:
-    """Step 3: Perform root cause analysis on an enriched AV incident summary."""
-    return llm.invoke(
-        f"You are an AV root cause analysis agent. Analyze the enriched incident and identify "
-        f"the most probable root causes ranked by confidence. Reference ISO 26262, SAE J3016, or NHTSA AV Policy where relevant.\n\nEnriched summary: {enriched_summary}"
+def step3_root_cause(enriched: str) -> str:
+    return run_chain(
+        f"{QWEN_PERSONA} You are the Risk Agent. Identify the most probable root causes ranked by confidence. "
+        f"Reference ISO 26262, SAE J3016, or NHTSA AV Policy where relevant.",
+        f"Enriched incident: {enriched}"
     )
 
-@tool
-def generate_response_plan(root_cause_analysis: str) -> str:
-    """Step 4: Generate a recommended response and remediation plan based on root cause analysis."""
-    return llm.invoke(
-        f"You are an AV safety response agent. Based on this root cause analysis, generate: "
-        f"(1) immediate response actions, (2) short-term fixes, (3) long-term prevention measures.\n\nAnalysis: {root_cause_analysis}"
+def step4_response_plan(root_cause: str) -> str:
+    return run_chain(
+        f"{QWEN_PERSONA} You are the Safety Response Agent. Generate: "
+        f"(1) immediate response actions, (2) short-term fixes, (3) long-term prevention measures.",
+        f"Root cause analysis: {root_cause}"
     )
 
-@tool
-def write_incident_report(full_analysis: str) -> str:
-    """Writes a formal AV incident report in Markdown format with Qwen personality."""
-    return llm.invoke(
-        f"You are Qwen, the AutoPulse Bot. Start your report EXACTLY with this greeting:\n"
-        f"'Hi, I'm Qwen the AutoPulse Bot. I am now looking through your submissions on issues and I will diagnose.'\n\n"
-        f"Then write a formal incident report in Markdown with sections: "
+def step5_report(intake: str, enriched: str, root_cause: str, plan: str) -> str:
+    return run_chain(
+        f"{QWEN_PERSONA} You are the Documentation Agent. "
+        f"Start EXACTLY with: 'Hi, I'm Qwen the AutoPulse Bot. I am now looking through your submissions on issues and I will diagnose.'\n\n"
+        f"Write a formal incident report in Markdown with sections: "
         f"Executive Summary, Timeline, Affected Subsystems, Root Causes, Compliance Flags, Response Plan, Recommendations.\n\n"
-        f"At the very end, add a section called '## Qwen's Personal Recommendation' where you give your own "
-        f"expert suggestion based on your knowledge of AV systems, drawing from your own reasoning — "
-        f"not just repeating the analysis above. Be specific, technical, and insightful.\n\n"
-        f"Analysis to report on: {full_analysis}"
+        f"End with '## Qwen's Personal Recommendation' — give your own expert insight based on your Qwen3 knowledge, "
+        f"be specific and technical.",
+        f"INTAKE:\n{intake}\n\nENRICHED:\n{enriched}\n\nROOT CAUSE:\n{root_cause}\n\nRESPONSE PLAN:\n{plan}"
     )
 
-@tool
-def analyze_branch_diff(diff_and_failure: str) -> str:
-    """Analyzes a git diff and failure description to rank root cause suspects by file, line, and confidence."""
-    return llm.invoke(
-        f"You are a code forensics agent. Analyze this git diff and failure description. "
-        f"Rank root cause suspects by file path, line range, mechanism, and confidence (high/medium/low).\n\n{diff_and_failure}"
+def full_triage_pipeline(incident: str) -> str:
+    print(f"\n[Qwen] Step 1: Intake...")
+    intake = step1_intake(incident)
+    print(f"[Qwen] Step 2: Enrichment...")
+    enriched = step2_enrich(intake)
+    print(f"[Qwen] Step 3: Root Cause Analysis...")
+    root_cause = step3_root_cause(enriched)
+    print(f"[Qwen] Step 4: Response Plan...")
+    plan = step4_response_plan(root_cause)
+    print(f"[Qwen] Step 5: Writing Report...")
+    report = step5_report(intake, enriched, root_cause, plan)
+    print(f"[Qwen] Pipeline complete.")
+    return report
+
+def branch_debug_pipeline(diff_input: str) -> str:
+    print(f"\n[Qwen] Running Branch Debug...")
+    return run_chain(
+        f"{QWEN_PERSONA} You are the Code Forensics Agent. "
+        f"Start with: 'Hi, I'm Qwen the AutoPulse Bot. Analyzing your branch diff now.'\n\n"
+        f"Analyze this git diff and failure description. Rank root cause suspects by file path, "
+        f"line range, mechanism, and confidence (high/medium/low). "
+        f"End with '## Qwen's Personal Recommendation'.",
+        diff_input
     )
 
-@tool
-def forensic_url_analysis(url_or_content: str) -> str:
-    """Performs forensic analysis on a URL or file content for security and safety issues."""
-    return llm.invoke(
-        f"You are a forensic analysis agent. Analyze this content for suspicious patterns, "
-        f"security vulnerabilities, or safety issues. Flag anomalies with severity.\n\nContent: {url_or_content}"
+def forensic_pipeline(content: str) -> str:
+    print(f"\n[Qwen] Running Forensic Analysis...")
+    return run_chain(
+        f"{QWEN_PERSONA} You are the Forensic Analysis Agent. "
+        f"Start with: 'Hi, I'm Qwen the AutoPulse Bot. Running forensic analysis now.'\n\n"
+        f"Analyze this content for suspicious patterns, security vulnerabilities, or safety issues. "
+        f"Flag anomalies with severity. End with '## Qwen's Personal Recommendation'.",
+        content
     )
 
-# ── Agent setup ────────────────────────────────────────────────────
-
-tools = [
-    intake_incident,
-    enrich_incident,
-    analyze_root_cause,
-    generate_response_plan,
-    write_incident_report,
-    analyze_branch_diff,
-    forensic_url_analysis,
-]
-
-prompt = hub.pull("hwchase17/react")
-agent = create_react_agent(llm, tools, prompt)
-agent_executor = AgentExecutor(
-    agent=agent,
-    tools=tools,
-    verbose=True,
-    handle_parsing_errors=True,
-    max_iterations=8,
-)
-
 # ── Request models ─────────────────────────────────────────────────
 
 class Query(BaseModel):
@@ -124,66 +121,41 @@ class ChatRequest(BaseModel):
 
 @app.get("/health")
 def health():
-    return {"status": "ok", "model": "qwen3", "agent": "multi-step"}
+    return {"status": "ok", "model": "qwen3", "agent": "Qwen the AutoPulse Bot", "gpu": "AMD Instinct"}
 
 @app.post("/triage")
 def triage(query: Query):
-    """Full 5-step agentic triage pipeline."""
-    result = agent_executor.invoke({
-        "input": (
-            f"Run the full AV incident triage pipeline for this incident: {query.input}\n\n"
-            f"Steps: (1) intake_incident, (2) enrich_incident, (3) analyze_root_cause, "
-            f"(4) generate_response_plan, (5) write_incident_report. "
-            f"Pass the output of each step into the next."
-        )
-    })
-    return {"output": result["output"]}
+    result = full_triage_pipeline(query.input)
+    return {"output": result}
 
 @app.post("/branch-debug")
 def branch_debug(query: Query):
-    """Agentic branch diff root cause analysis."""
-    result = agent_executor.invoke({
-        "input": f"Use analyze_branch_diff to find root causes in this diff and failure: {query.input}"
-    })
-    return {"output": result["output"]}
+    result = branch_debug_pipeline(query.input)
+    return {"output": result}
 
 @app.post("/forensic")
 def forensic(query: Query):
-    """Agentic forensic analysis."""
-    result = agent_executor.invoke({
-        "input": f"Use forensic_url_analysis to analyze this content for issues: {query.input}"
-    })
-    return {"output": result["output"]}
+    result = forensic_pipeline(query.input)
+    return {"output": result}
 
 @app.post("/analyze")
 def analyze(query: Query):
-    """General agentic analysis endpoint."""
-    result = agent_executor.invoke({"input": query.input})
-    return {"output": result["output"]}
+    result = full_triage_pipeline(query.input)
+    return {"output": result}
 
 @app.post("/v1/chat/completions")
 def chat_completions(req: ChatRequest):
-    """OpenAI-compatible endpoint — routes through full agent pipeline."""
     user_messages = [m.content for m in req.messages if m.role == "user"]
     user_input = user_messages[-1] if user_messages else ""
-
-    result = agent_executor.invoke({
-        "input": (
-            f"Run the full AV incident triage pipeline: "
-            f"(1) intake_incident, (2) enrich_incident, (3) analyze_root_cause, "
-            f"(4) generate_response_plan, (5) write_incident_report. "
-            f"Input: {user_input}"
-        )
-    })
-
+    result = full_triage_pipeline(user_input)
     return JSONResponse({
         "id": f"chatcmpl-{uuid.uuid4().hex}",
         "object": "chat.completion",
         "created": int(time.time()),
-        "model": req.model,
+        "model": "qwen3-autopulse-bot",
         "choices": [{
             "index": 0,
-            "message": {"role": "assistant", "content": result["output"]},
+            "message": {"role": "assistant", "content": result},
             "finish_reason": "stop"
         }]
     })