Phase 2: state schema, SQLite session memory, data dir

.gitignore

@@ -205,3 +205,6 @@ cython_debug/
 marimo/_static/
 marimo/_lsp/
 __marimo__/
+
+data/sessions.db
+*.db

requirements.txt

@@ -0,0 +1,19 @@
+langgraph>=0.2.0
+langchain>=0.3.0
+langchain-groq
+langchain-huggingface
+sentence-transformers
+semanticscholar
+duckduckgo-search
+tavily-python
+ragas
+datasets
+gradio>=4.0.0
+python-dotenv
+pandas
+tqdm
+networkx
+matplotlib
+fastapi
+uvicorn
+

src/memory.py

@@ -0,0 +1,191 @@
+import sqlite3
+import json
+import os
+from datetime import datetime
+from src.state import SessionContext, SessionUpdate, Claim
+
+
+_DEFAULT_DB = os.path.join(os.path.dirname(os.path.dirname(__file__)), "data", "sessions.db")
+DB_PATH = os.environ.get("SESSION_DB_PATH", _DEFAULT_DB)
+
+
+def _get_conn() -> sqlite3.Connection:
+    conn = sqlite3.connect(DB_PATH)
+    conn.row_factory = sqlite3.Row
+    return conn
+
+
+def init_db() -> None:
+    """Create tables if they don't exist. Call once at app startup."""
+    with _get_conn() as conn:
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS sessions (
+                session_id   TEXT PRIMARY KEY,
+                created_at   TEXT NOT NULL,
+                updated_at   TEXT NOT NULL
+            )
+        """)
+        conn.execute("""
+            CREATE TABLE IF NOT EXISTS session_turns (
+                id                INTEGER PRIMARY KEY AUTOINCREMENT,
+                session_id        TEXT NOT NULL,
+                query             TEXT NOT NULL,
+                position          TEXT NOT NULL,
+                claim_json        TEXT NOT NULL,   -- JSON list of Claim dicts
+                contradictions    TEXT NOT NULL,   -- JSON list of strings
+                created_at        TEXT NOT NULL,
+                FOREIGN KEY (session_id) REFERENCES sessions(session_id)
+            )
+        """)
+        conn.commit()
+
+
+def load_session(session_id: str) -> SessionContext:
+    """
+    Load prior positions and contradictions for this session.
+    Returns an empty SessionContext if the session doesn't exist yet.
+    """
+    with _get_conn() as conn:
+        rows = conn.execute(
+            """
+            SELECT query, position, contradictions
+            FROM session_turns
+            WHERE session_id = ?
+            ORDER BY created_at ASC
+            """,
+            (session_id,)
+        ).fetchall()
+
+    if not rows:
+        return SessionContext()
+
+    prior_positions = [r["position"] for r in rows]
+    prior_queries = [r["query"] for r in rows]
+    flagged_contradictions = []
+    for r in rows:
+        flagged_contradictions.extend(json.loads(r["contradictions"]))
+
+    return SessionContext(
+        prior_positions=prior_positions,
+        prior_queries=prior_queries,
+        flagged_contradictions=flagged_contradictions,
+    )
+
+
+def save_turn(session_id: str, update: SessionUpdate) -> None:
+    """
+    Persist one completed turn (query + synthesized position + claims).
+    Creates the session row if it doesn't exist.
+    """
+    now = datetime.utcnow().isoformat()
+
+    claim_json = json.dumps([
+        {
+            "text": c.text,
+            "source_title": c.source_title,
+            "source_year": c.source_year,
+            "confidence": c.confidence,
+            "flagged": c.flagged,
+        }
+        for c in update.claim_confidences
+    ])
+
+    contradictions_json = json.dumps(update.contradictions_found)
+
+    with _get_conn() as conn:
+        # Upsert the session header row
+        conn.execute(
+            """
+            INSERT INTO sessions (session_id, created_at, updated_at)
+            VALUES (?, ?, ?)
+            ON CONFLICT(session_id) DO UPDATE SET updated_at = excluded.updated_at
+            """,
+            (session_id, now, now),
+        )
+        # Insert the turn
+        conn.execute(
+            """
+            INSERT INTO session_turns
+                (session_id, query, position, claim_json, contradictions, created_at)
+            VALUES (?, ?, ?, ?, ?, ?)
+            """,
+            (session_id, update.query, update.position,
+             claim_json, contradictions_json, now),
+        )
+        conn.commit()
+
+
+def export_session_md(session_id: str) -> str:
+    """
+    Export the full session as a markdown research note.
+    Returns the markdown string (not saved to disk here — caller decides).
+    """
+    with _get_conn() as conn:
+        session_row = conn.execute(
+            "SELECT created_at FROM sessions WHERE session_id = ?",
+            (session_id,)
+        ).fetchone()
+
+        turns = conn.execute(
+            """
+            SELECT query, position, claim_json, contradictions, created_at
+            FROM session_turns
+            WHERE session_id = ?
+            ORDER BY created_at ASC
+            """,
+            (session_id,)
+        ).fetchall()
+
+    if not session_row:
+        return "# Session not found\n"
+
+    lines = [
+        f"# RECON Research Session",
+        f"**Session ID:** `{session_id}`  ",
+        f"**Started:** {session_row['created_at']}  ",
+        f"**Turns:** {len(turns)}",
+        "",
+        "---",
+        "",
+    ]
+
+    for i, turn in enumerate(turns, 1):
+        claims = json.loads(turn["claim_json"])
+        contradictions = json.loads(turn["contradictions"])
+
+        lines += [
+            f"## Turn {i}: {turn['query']}",
+            "",
+            "### Position",
+            turn["position"],
+            "",
+        ]
+
+        if claims:
+            lines += ["### Claims", ""]
+            for c in claims:
+                flag = " ⚠️" if c["flagged"] else ""
+                lines.append(
+                    f"- **[{c['confidence'].upper()}]** {c['text']} "
+                    f"— *{c['source_title']} ({c['source_year']})*{flag}"
+                )
+            lines.append("")
+
+        if contradictions:
+            lines += ["### Contradictions flagged", ""]
+            for contradiction in contradictions:
+                lines.append(f"- {contradiction}")
+            lines.append("")
+
+        lines.append("---")
+        lines.append("")
+
+    return "\n".join(lines)
+
+
+def delete_session(session_id: str) -> None:
+    """Hard delete a session and all its turns."""
+    with _get_conn() as conn:
+        conn.execute("DELETE FROM session_turns WHERE session_id = ?", (session_id,))
+        conn.execute("DELETE FROM sessions WHERE session_id = ?", (session_id,))
+        conn.commit()

src/state.py

@@ -0,0 +1,101 @@
+from typing import TypedDict, Optional
+from dataclasses import dataclass, field
+
+
+# ---------------------------------------------------------------------------
+# Dataclasses — typed objects passed through the graph
+# ---------------------------------------------------------------------------
+
+@dataclass
+class Paper:
+    title: str
+    abstract: str
+    year: int
+    citation_count: int
+    paper_id: str
+    authors: list[str] = field(default_factory=list)
+    references: list[str] = field(default_factory=list)  # list of paper_ids
+    hybrid_score: float = 0.0
+    source: str = "semantic_scholar"  # or "web"
+
+
+@dataclass
+class WebResult:
+    url: str
+    snippet: str
+    title: str
+    inferred_year: Optional[int] = None
+    hybrid_score: float = 0.0
+    source: str = "web"
+
+
+@dataclass
+class Claim:
+    text: str
+    source_title: str
+    source_year: int
+    confidence: str          # "high" | "medium" | "low"
+    flagged: bool = False    # True if contested or contradicted
+
+
+@dataclass
+class SessionContext:
+    prior_positions: list[str] = field(default_factory=list)
+    flagged_contradictions: list[str] = field(default_factory=list)
+    prior_queries: list[str] = field(default_factory=list)
+
+
+@dataclass
+class SessionUpdate:
+    position: str
+    query: str
+    claim_confidences: list[Claim] = field(default_factory=list)
+    contradictions_found: list[str] = field(default_factory=list)
+
+
+# ---------------------------------------------------------------------------
+# Verdict constants — used by Critic agent
+# ---------------------------------------------------------------------------
+
+class Verdict:
+    PASS = "PASS"
+    STALE = "STALE"
+    CONTRADICTED = "CONTRADICTED"
+    INSUFFICIENT = "INSUFFICIENT"
+    FORCED_PASS = "FORCED_PASS"
+
+
+# ---------------------------------------------------------------------------
+# LangGraph state — the single TypedDict shared across all agents
+# ---------------------------------------------------------------------------
+
+class ResearchState(TypedDict):
+    # --- Input ---
+    original_query: str
+    session_id: str
+
+    # --- Planner output ---
+    session_context: Optional[SessionContext]
+    sub_questions: list[str]
+
+    # --- Retriever output ---
+    retrieved_papers: list[Paper]
+    citation_graph: dict                  # {paper_id: [cited_paper_ids]}
+    web_results: list[WebResult]
+
+    # --- Critic output ---
+    critic_verdict: str                   # one of Verdict constants
+    critic_notes: str
+    rewritten_questions: list[str]
+    retry_count: int
+
+    # --- Synthesizer output ---
+    synthesized_position: str
+    claim_confidences: list[Claim]
+    session_update: Optional[SessionUpdate]
+    export_md: str                        # NEW v2 — full session as markdown
+
+    # --- Eval / config ---
+    decay_config: str                     # "none" | "linear" | "log"
+    calibration_bin: str                  # filled by critic for eval aggregation
+    latency_ms: float

test_phase2.py

@@ -0,0 +1,63 @@
+import sys
+sys.path.insert(0, ".")
+
+from src.state import ResearchState, Paper, Claim, Verdict, SessionContext
+from src.memory import init_db, load_session, save_turn, export_session_md, delete_session
+from src.state import SessionUpdate
+import uuid
+
+print("=== Phase 2: State + Memory ===")
+
+# Test 1: State dataclasses
+p = Paper(
+    title="Test Paper",
+    abstract="This is a test abstract.",
+    year=2024,
+    citation_count=100,
+    paper_id="abc123"
+)
+print(f"✓ Paper dataclass: {p.title} ({p.year})")
+
+c = Claim(text="Test claim", source_title="Test Paper", source_year=2024, confidence="high")
+print(f"✓ Claim dataclass: [{c.confidence}] {c.text}")
+
+print(f"✓ Verdict constants: {Verdict.PASS} / {Verdict.STALE} / {Verdict.CONTRADICTED}")
+
+# Test 2: SQLite memory
+init_db()
+print("✓ Database initialized")
+
+session_id = str(uuid.uuid4())
+
+# Load empty session
+ctx = load_session(session_id)
+print(f"✓ Empty session loaded: {len(ctx.prior_positions)} prior positions")
+
+# Save a turn
+update = SessionUpdate(
+    query="What is the state of KV cache compression?",
+    position="KV cache compression has advanced significantly with methods like H2O and StreamingLLM.",
+    claim_confidences=[
+        Claim("H2O reduces KV cache size by 20x", "H2O Paper", 2023, "high"),
+        Claim("StreamingLLM enables infinite context", "StreamingLLM", 2023, "medium"),
+    ],
+    contradictions_found=["StreamingLLM contradicted by later infinite attention work (2024)"]
+)
+save_turn(session_id, update)
+print("✓ Turn saved to database")
+
+# Reload and verify
+ctx2 = load_session(session_id)
+print(f"✓ Session reloaded: {len(ctx2.prior_positions)} prior position(s)")
+print(f"  Prior query: {ctx2.prior_queries[0][:60]}...")
+
+# Export markdown
+md = export_session_md(session_id)
+print(f"✓ Markdown export: {len(md)} characters")
+print(f"  Preview: {md[:120].strip()}")
+
+# Cleanup
+delete_session(session_id)
+print("✓ Session deleted")
+
+print("\n✅ Phase 2 complete")

test_setup.py

@@ -0,0 +1,28 @@
+from dotenv import load_dotenv
+import os
+
+load_dotenv()
+
+print("=== Testing imports ===")
+import langgraph; print("✓ langgraph")
+import langchain; print(f"✓ langchain {langchain.__version__}")
+import gradio; print(f"✓ gradio {gradio.__version__}")
+import semanticscholar; print("✓ semanticscholar")
+from sentence_transformers import SentenceTransformer; print("✓ sentence-transformers")
+import networkx; print(f"✓ networkx {networkx.__version__}")
+
+print("\n=== Testing API keys ===")
+groq_key = os.getenv("GROQ_API_KEY")
+s2_key = os.getenv("S2_API_KEY")
+tavily_key = os.getenv("TAVILY_API_KEY")
+print(f"✓ GROQ_API_KEY: {'set' if groq_key else 'MISSING'}")
+print(f"✓ S2_API_KEY: {'set — will activate in 1-3 days' if s2_key else 'not set yet (pending)' }")
+print(f"✓ TAVILY_API_KEY: {'set' if tavily_key else 'MISSING'}")
+
+print("\n=== Testing Groq connection ===")
+from langchain_groq import ChatGroq
+llm = ChatGroq(model="llama-3.3-70b-versatile", api_key=groq_key)
+response = llm.invoke("Say exactly: setup confirmed")
+print(f"✓ Groq response: {response.content}")
+
+print("\n✅ Phase 1 complete — all systems go")