added conversational memory

app.py

@@ -27,6 +27,7 @@ app.add_middleware(
 class QuestionRequest(BaseModel):
     question: str
     provider: str = "groq"       # "groq" | "openai"
+    conversation_id: str | None = None
 
 
 class GenerateSQLResponse(BaseModel):
@@ -54,9 +55,29 @@ def generate_sql_endpoint(req: QuestionRequest):
 @app.post("/chat", response_model=ChatResponse)
 def chat_endpoint(req: QuestionRequest):
     from ai.pipeline import SQLAnalystPipeline
+    from db.memory import get_recent_history, add_turn
+
+    conversation_id = req.conversation_id or "default"
+
+    history = get_recent_history(conversation_id, limit=5)
+
+    # Augment the question with recent conversation context
+    if history:
+        history_lines: list[str] = ["You are in a multi-turn conversation. Here are the recent exchanges:"]
+        for turn in history:
+            history_lines.append(f"User: {turn['question']}")
+            history_lines.append(f"Assistant: {turn['answer']}")
+        history_lines.append(f"Now the user asks: {req.question}")
+        question_with_context = "\n".join(history_lines)
+    else:
+        question_with_context = req.question
 
     pipeline = SQLAnalystPipeline(provider=req.provider)
-    result = pipeline.run(req.question)
+    result = pipeline.run(question_with_context)
+
+    # Persist this turn for future context
+    add_turn(conversation_id, req.question, result["answer"], result["sql"])
+
     return ChatResponse(**result)
 
 

db/memory.py

@@ -0,0 +1,86 @@
+"""Conversation memory stored in PostgreSQL (Neon).
+
+Keeps the last N turns per conversation so the AI can
+use recent context for follow‑up questions.
+"""
+
+from __future__ import annotations
+
+from typing import Any, List, Dict
+
+from sqlalchemy import text
+
+from db.connection import get_engine
+
+
+_TABLE_CREATED = False
+
+
+def _ensure_table() -> None:
+    """Create the chat_history table if it doesn't exist."""
+    global _TABLE_CREATED
+    if _TABLE_CREATED:
+        return
+
+    ddl = text(
+        """
+        CREATE TABLE IF NOT EXISTS chat_history (
+            id BIGSERIAL PRIMARY KEY,
+            conversation_id TEXT NOT NULL,
+            question TEXT NOT NULL,
+            answer TEXT NOT NULL,
+            sql_query TEXT,
+            created_at TIMESTAMPTZ NOT NULL DEFAULT NOW()
+        );
+        """
+    )
+    engine = get_engine()
+    with engine.begin() as conn:
+        conn.execute(ddl)
+
+    _TABLE_CREATED = True
+
+
+def add_turn(conversation_id: str, question: str, answer: str, sql_query: str | None) -> None:
+    """Append a single Q/A turn to the history."""
+    _ensure_table()
+    engine = get_engine()
+    insert_stmt = text(
+        """
+        INSERT INTO chat_history (conversation_id, question, answer, sql_query)
+        VALUES (:conversation_id, :question, :answer, :sql_query)
+        """
+    )
+    with engine.begin() as conn:
+        conn.execute(
+            insert_stmt,
+            {
+                "conversation_id": conversation_id,
+                "question": question,
+                "answer": answer,
+                "sql_query": sql_query,
+            },
+        )
+
+
+def get_recent_history(conversation_id: str, limit: int = 5) -> List[Dict[str, Any]]:
+    """Return the most recent `limit` turns for a conversation (oldest first)."""
+    _ensure_table()
+    engine = get_engine()
+    query = text(
+        """
+        SELECT question, answer, sql_query, created_at
+        FROM chat_history
+        WHERE conversation_id = :conversation_id
+        ORDER BY created_at DESC
+        LIMIT :limit
+        """
+    )
+    with engine.connect() as conn:
+        rows = conn.execute(
+            query, {"conversation_id": conversation_id, "limit": limit}
+        ).mappings().all()
+
+    # Reverse so caller sees oldest → newest
+    return list(reversed([dict(r) for r in rows]))
+

frontend/script.js

@@ -25,6 +25,17 @@
     let selectedProvider  = "groq";
     let loadingStepTimer  = null;
 
+    // Persistent conversation id per browser (for multi-turn memory)
+    let conversationId = window.localStorage.getItem("sqlbot_conversation_id");
+    if (!conversationId) {
+        if (window.crypto && window.crypto.randomUUID) {
+            conversationId = window.crypto.randomUUID();
+        } else {
+            conversationId = "conv-" + Date.now().toString(36);
+        }
+        window.localStorage.setItem("sqlbot_conversation_id", conversationId);
+    }
+
     // ── Model Switcher ───────────────────────────────────────────────────
     modelSwitcher.addEventListener("click", (e) => {
         const btn = e.target.closest(".switcher-btn");
@@ -55,7 +66,11 @@
             const res = await fetch("/chat", {
                 method: "POST",
                 headers: { "Content-Type": "application/json" },
-                body: JSON.stringify({ question, provider: selectedProvider }),
+                body: JSON.stringify({
+                    question,
+                    provider: selectedProvider,
+                    conversation_id: conversationId,
+                }),
             });
 
             if (!res.ok) {