feat(SPEC-08): Integrate shared memory layer + CodeRabbit fixes (#74)

## Summary
- SPEC-08: Shared memory layer integration
- CodeRabbit critical fix: async add_evidence() with proper deduplication
- Security: Fixed CVEs in langgraph-checkpoint and urllib3
- CI: Hardened to fail on security vulnerabilities
- Docstrings: 80%+ coverage

All 178 tests pass. No known vulnerabilities.

.github/workflows/ci.yml

@@ -40,11 +40,9 @@ jobs:
 
       - name: Security scan with bandit
         run: uv run bandit -r src -ll -q
-        continue-on-error: true  # Don't fail CI, just report
 
       - name: Dependency vulnerability audit
         run: uv run pip-audit
-        continue-on-error: true  # Informational - deps may have known issues
 
       - name: Run tests with coverage
         run: uv run pytest tests/unit/ -v --cov=src --cov-report=xml --cov-report=term-missing

docs/bugs/P3_ARCHITECTURAL_GAP_STRUCTURED_MEMORY.md

@@ -69,11 +69,13 @@ Based on [comprehensive analysis](https://latenode.com/blog/langgraph-multi-agen
 ### Target Architecture
 
 ```python
-# src/agents/graph/state.py (PROPOSED)
+# src/agents/graph/state.py (IMPLEMENTED)
 from typing import Annotated, TypedDict, Literal
 import operator
+from pydantic import BaseModel, Field
+from langchain_core.messages import BaseMessage
 
-class Hypothesis(TypedDict):
+class Hypothesis(BaseModel):
     id: str
     statement: str
     status: Literal["proposed", "validating", "confirmed", "refuted"]
@@ -81,7 +83,7 @@ class Hypothesis(TypedDict):
     supporting_evidence_ids: list[str]
     contradicting_evidence_ids: list[str]
 
-class Conflict(TypedDict):
+class Conflict(BaseModel):
     id: str
     description: str
     source_a_id: str

docs/specs/SPEC_07_LANGGRAPH_MEMORY_ARCH.md

@@ -120,26 +120,30 @@ Based on [comprehensive framework comparison](https://kanerika.com/blogs/langcha
 from typing import Annotated, TypedDict, Literal
 import operator
 from langchain_core.messages import BaseMessage
+from pydantic import BaseModel, Field
 
 
-class Hypothesis(TypedDict):
+class Hypothesis(BaseModel):
     """A research hypothesis with evidence tracking."""
-    id: str
-    statement: str
-    status: Literal["proposed", "validating", "confirmed", "refuted"]
-    confidence: float  # 0.0 - 1.0
-    supporting_evidence_ids: list[str]
-    contradicting_evidence_ids: list[str]
+    id: str = Field(description="Unique identifier for the hypothesis")
+    statement: str = Field(description="The hypothesis statement")
+    status: Literal["proposed", "validating", "confirmed", "refuted"] = Field(
+        default="proposed", description="Current validation status"
+    )
+    confidence: float = Field(default=0.0, ge=0.0, le=1.0, description="Confidence score (0.0-1.0)")
+    supporting_evidence_ids: list[str] = Field(default_factory=list)
+    contradicting_evidence_ids: list[str] = Field(default_factory=list)
+    reasoning: str | None = Field(default=None, description="Reasoning for current status")
 
 
-class Conflict(TypedDict):
+class Conflict(BaseModel):
     """A detected contradiction between sources."""
-    id: str
-    description: str
-    source_a_id: str
-    source_b_id: str
-    status: Literal["open", "resolved"]
-    resolution: str | None
+    id: str = Field(description="Unique identifier for the conflict")
+    description: str = Field(description="Description of the contradiction")
+    source_a_id: str = Field(description="ID of the first conflicting source")
+    source_b_id: str = Field(description="ID of the second conflicting source")
+    status: Literal["open", "resolved"] = Field(default="open")
+    resolution: str | None = Field(default=None, description="Resolution explanation if resolved")
 
 
 class ResearchState(TypedDict):
@@ -151,11 +155,12 @@ class ResearchState(TypedDict):
     # Immutable context
     query: str
 
-    # Cognitive state (the "blackboard")
+    # Cognitive state (The "Blackboard")
+    # Note: We store these as lists of Pydantic models.
     hypotheses: Annotated[list[Hypothesis], operator.add]
     conflicts: Annotated[list[Conflict], operator.add]
 
-    # Evidence links (actual content in ChromaDB)
+    # Evidence links (actual content stored in ChromaDB)
     evidence_ids: Annotated[list[str], operator.add]
 
     # Chat history (for LLM context)
@@ -169,90 +174,78 @@ class ResearchState(TypedDict):
 
 ### 4.2 Graph Nodes
 
-Each node is a pure function: `(state: ResearchState) -> dict`
+Each node is an async function that receives the state and injected dependencies.
 
 **File:** `src/agents/graph/nodes.py`
 
 ```python
 """Graph node implementations."""
-from langchain_core.messages import HumanMessage, AIMessage
-from src.tools.pubmed import search_pubmed
-from src.tools.clinicaltrials import search_clinicaltrials
-from src.tools.europepmc import search_europepmc
+from typing import Any
+from langchain_core.messages import AIMessage
+from src.services.embeddings import EmbeddingService
+from src.tools.search_handler import SearchHandler
 
 
-async def search_node(state: ResearchState) -> dict:
+async def search_node(
+    state: ResearchState, embedding_service: EmbeddingService | None = None
+) -> dict[str, Any]:
     """Execute search across all sources.
 
-    Returns partial state update (additive via operator.add).
+    Uses SearchHandler to query PubMed, ClinicalTrials, and EuropePMC.
+    Deduplicates evidence using EmbeddingService.
     """
-    query = state["query"]
-    # Reuse existing tools
-    results = await asyncio.gather(
-        search_pubmed(query),
-        search_clinicaltrials(query),
-        search_europepmc(query),
-    )
-    new_evidence_ids = [...]  # Store in ChromaDB, return IDs
+    # ... implementation ...
     return {
-        "evidence_ids": new_evidence_ids,
-        "messages": [AIMessage(content=f"Found {len(new_evidence_ids)} papers")],
+        "evidence_ids": new_ids,
+        "messages": [AIMessage(content=message)],
     }
 
 
-async def judge_node(state: ResearchState) -> dict:
+async def judge_node(
+    state: ResearchState, embedding_service: EmbeddingService | None = None
+) -> dict[str, Any]:
     """Evaluate evidence and update hypothesis confidence.
 
-    Key responsibility: Detect conflicts and flag them.
+    Uses pydantic_ai Agent to generate structured HypothesisAssessment.
     """
-    # LLM call to evaluate hypotheses against evidence
-    # If contradiction found: add to conflicts list
+    # ... implementation ...
     return {
-        "hypotheses": updated_hypotheses,  # With new confidence scores
-        "conflicts": new_conflicts,  # Any detected contradictions
-        "messages": [...],
+        "hypotheses": new_hypotheses,
+        "messages": [AIMessage(content=f"Judge: Generated {len(new_hypotheses)} hypotheses.")],
+        "next_step": "resolve",
     }
 
 
-async def resolve_node(state: ResearchState) -> dict:
-    """Handle open conflicts via tie-breaker logic.
-
-    Triggers targeted search or reasoning to resolve.
-    """
-    open_conflicts = [c for c in state["conflicts"] if c["status"] == "open"]
-    # For each conflict: search for decisive evidence or make judgment call
-    return {
-        "conflicts": resolved_conflicts,
-        "messages": [...],
-    }
-
+async def resolve_node(
+    state: ResearchState, embedding_service: EmbeddingService | None = None
+) -> dict[str, Any]:
+    """Handle open conflicts."""
+    # ... implementation ...
+    return {"messages": messages}
 
-async def synthesize_node(state: ResearchState) -> dict:
-    """Generate final research report.
 
-    Only uses confirmed hypotheses and resolved conflicts.
-    """
-    confirmed = [h for h in state["hypotheses"] if h["status"] == "confirmed"]
-    # Generate structured report
-    return {
-        "messages": [AIMessage(content=report_markdown)],
-        "next_step": "finish",
-    }
+async def synthesize_node(
+    state: ResearchState, embedding_service: EmbeddingService | None = None
+) -> dict[str, Any]:
+    """Generate final research report."""
+    # ... implementation ...
+    return {"messages": [AIMessage(content=report_markdown)], "next_step": "finish"}
 
 
-def supervisor_node(state: ResearchState) -> dict:
-    """Route to next node based on state.
+async def supervisor_node(
+    state: ResearchState, llm: BaseChatModel | None = None
+) -> dict[str, Any]:
+    """Route to next node based on state using robust Pydantic parsing.
 
     This is the "brain" - uses LLM to decide next action
-    based on STRUCTURED STATE (not just chat).
+    based on STRUCTURED STATE.
     """
-    # Decision logic:
-    # 1. If open conflicts exist -> "resolve"
-    # 2. If hypotheses need more evidence -> "search"
-    # 3. If evidence is sufficient -> "judge"
-    # 4. If all hypotheses confirmed -> "synthesize"
-    # 5. If max iterations -> "synthesize" (forced)
-    return {"next_step": decided_step, "iteration_count": state["iteration_count"] + 1}
+    # ... implementation ...
+    return {
+        "next_step": decision.next_step,
+        "iteration_count": state["iteration_count"] + 1,
+        "messages": [AIMessage(content=f"Supervisor: {decision.reasoning}")],
+    }
 ```
 
 ### 4.3 Graph Definition
@@ -261,57 +254,40 @@ def supervisor_node(state: ResearchState) -> dict:
 
 ```python
 """LangGraph workflow definition."""
+from functools import partial
 from langgraph.graph import StateGraph, END
-from langgraph.checkpoint.sqlite import SqliteSaver
+from langgraph.graph.state import CompiledStateGraph
 
 from src.agents.graph.state import ResearchState
-from src.agents.graph.nodes import (
-    search_node,
-    judge_node,
-    resolve_node,
-    synthesize_node,
-    supervisor_node,
-)
+from src.services.embeddings import EmbeddingService
+# ... imports ...
 
 
-def create_research_graph(checkpointer=None):
+def create_research_graph(
+    llm=None,
+    checkpointer=None,
+    embedding_service: EmbeddingService | None = None,
+) -> CompiledStateGraph:
     """Build the research state graph.
 
     Args:
-        checkpointer: Optional SqliteSaver/MongoDBSaver for persistence
+        llm: Supervisor LLM
+        checkpointer: Optional persistence layer
+        embedding_service: Service for evidence storage
     """
     graph = StateGraph(ResearchState)
 
-    # Add nodes
-    graph.add_node("supervisor", supervisor_node)
-    graph.add_node("search", search_node)
-    graph.add_node("judge", judge_node)
-    graph.add_node("resolve", resolve_node)
-    graph.add_node("synthesize", synthesize_node)
-
-    # Define edges (supervisor routes based on state.next_step)
-    graph.add_edge("search", "supervisor")
-    graph.add_edge("judge", "supervisor")
-    graph.add_edge("resolve", "supervisor")
-    graph.add_edge("synthesize", END)
-
-    # Conditional routing from supervisor
-    graph.add_conditional_edges(
-        "supervisor",
-        lambda state: state["next_step"],
-        {
-            "search": "search",
-            "judge": "judge",
-            "resolve": "resolve",
-            "synthesize": "synthesize",
-            "finish": END,
-        },
-    )
+    # Bind dependencies using partial
+    bound_supervisor = partial(supervisor_node, llm=llm) if llm else supervisor_node
+    bound_search = partial(search_node, embedding_service=embedding_service)
+    # ... binding other nodes ...
 
-    # Entry point
-    graph.set_entry_point("supervisor")
+    # Add nodes
+    graph.add_node("supervisor", bound_supervisor)
+    graph.add_node("search", bound_search)
+    # ...
 
-    return graph.compile(checkpointer=checkpointer)
+    # ... edges ...
 ```
 
 ### 4.4 Orchestrator Integration

docs/specs/SPEC_08_INTEGRATE_MEMORY_LAYER.md

@@ -54,34 +54,29 @@ Extract the memory logic from LangGraph nodes into a standalone service.
 ```python
 """Shared research memory layer for all orchestration modes."""
 
-from dataclasses import dataclass, field
 from typing import Literal
 
 from src.agents.graph.state import Conflict, Hypothesis
 from src.services.embeddings import EmbeddingService
-from src.utils.models import Evidence
+from src.utils.models import Citation, Evidence
 
 
-@dataclass
 class ResearchMemory:
     """Shared cognitive state for research workflows.
 
     This is the memory layer that ALL modes use.
-    Built from SPEC_07, now extracted for integration.
+    It mimics the LangGraph state management but for manual orchestration.
     """
 
-    query: str
-    hypotheses: list[Hypothesis] = field(default_factory=list)
-    conflicts: list[Conflict] = field(default_factory=list)
-    evidence_ids: list[str] = field(default_factory=list)
-    iteration_count: int = 0
-
-    # Injected services
-    _embedding_service: EmbeddingService | None = None
-
-    def __post_init__(self):
-        if self._embedding_service is None:
-            self._embedding_service = EmbeddingService()
+    def __init__(self, query: str, embedding_service: EmbeddingService | None = None):
+        self.query = query
+        self.hypotheses: list[Hypothesis] = []
+        self.conflicts: list[Conflict] = []
+        self.evidence_ids: list[str] = []
+        self.iteration_count: int = 0
+        
+        # Injected service
+        self._embedding_service = embedding_service or EmbeddingService()
 
     async def store_evidence(self, evidence: list[Evidence]) -> list[str]:
         """Store evidence and return new IDs (deduped)."""
@@ -113,7 +108,34 @@ class ResearchMemory:
         """Retrieve relevant evidence for current query."""
         if not self._embedding_service:
             return []
-        return await self._embedding_service.search_similar(self.query, n_results=n)
+            
+        results = await self._embedding_service.search_similar(self.query, n_results=n)
+        evidence_list = []
+        
+        for r in results:
+            meta = r.get("metadata", {})
+            authors_str = meta.get("authors", "")
+            authors = authors_str.split(",") if authors_str else []
+            
+            # Reconstruct Evidence object
+            # Note: SourceName validation might be needed, defaulting to 'web' or similar if unknown
+            source_raw = meta.get("source", "web")
+            
+            citation = Citation(
+                source=source_raw, # type: ignore
+                title=meta.get("title", "Unknown"),
+                url=meta.get("url", r["id"]),
+                date=meta.get("date", "Unknown"),
+                authors=authors
+            )
+            
+            evidence_list.append(Evidence(
+                content=r["content"],
+                citation=citation,
+                relevance=1.0 - r.get("distance", 0.5) # Approx conversion
+            ))
+            
+        return evidence_list
 
     def add_hypothesis(self, hypothesis: Hypothesis) -> None:
         """Add a hypothesis to tracking."""

pyproject.toml

@@ -26,11 +26,14 @@ dependencies = [
     "requests>=2.32.5", # ClinicalTrials.gov (httpx blocked by WAF)
     "limits>=3.0", # Rate limiting
     "duckduckgo-search>=5.0", # Web search
-    "langgraph>=0.2.50",
-    "langchain>=0.3.9",
-    "langchain-core>=0.3.21",
-    "langchain-huggingface>=0.1.2",
-    "langgraph-checkpoint-sqlite>=2.0.0",
+    # LangGraph deps - upper bounds prevent breaking changes from major versions
+    "langgraph>=0.2.50,<1.0",
+    "langchain>=0.3.9,<1.0",
+    "langchain-core>=0.3.21,<1.0",
+    "langchain-huggingface>=0.1.2,<1.0",
+    "langgraph-checkpoint-sqlite>=3.0.0,<4.0",  # 3.0.0 required for GHSA-wwqv-p2pp-99h5 fix
+    # Security: Pin urllib3 to fix GHSA-48p4-8xcf-vxj5 and GHSA-pq67-6m6q-mj2v
+    "urllib3>=2.5.0",
 ]
 
 [project.optional-dependencies]

src/agents/graph/nodes.py

@@ -43,15 +43,35 @@ def _convert_hypothesis_to_mechanism(h: Hypothesis) -> MechanismHypothesis:
     We parse this back into structured MechanismHypothesis fields.
     """
     # Parse statement format: "drug -> target -> pathway -> effect"
-    parts = h.statement.split(" -> ")
-    if len(parts) >= 4:
-        drug, target, pathway, effect = parts[0], parts[1], parts[2], parts[3]
+    # Handle both " -> " (standard) and "->" (compact) separators
+    separator = " -> " if " -> " in h.statement else "->"
+    parts = [p.strip() for p in h.statement.split(separator)]
+
+    # Validate: exactly 4 non-empty parts
+    if len(parts) == 4 and all(parts):
+        drug, target, pathway, effect = parts
+    elif len(parts) > 4 and all(parts[:4]):
+        # More than 4 parts: join extras into effect
+        drug, target, pathway = parts[0], parts[1], parts[2]
+        effect = f"{separator}".join(parts[3:])
+        logger.debug(
+            "Hypothesis has extra parts, joined into effect",
+            hypothesis_id=h.id,
+            parts_count=len(parts),
+        )
     else:
-        # Fallback if format is unexpected
-        drug = h.id
+        # Log parsing failure for debugging
+        logger.warning(
+            "Failed to parse hypothesis statement format",
+            hypothesis_id=h.id,
+            statement=h.statement[:100],  # Truncate for log safety
+            parts_count=len(parts),
+        )
+        # Use meaningful fallback values
+        drug = "Unknown"
         target = "Unknown"
         pathway = "Unknown"
-        effect = h.statement
+        effect = h.statement.strip() if h.statement else "Unknown effect"
 
     return MechanismHypothesis(
         drug=drug,

src/agents/graph/workflow.py

@@ -4,6 +4,7 @@ from functools import partial
 from typing import Any
 
 from langchain_core.language_models.chat_models import BaseChatModel
+from langgraph.checkpoint.base import BaseCheckpointSaver
 from langgraph.graph import END, StateGraph
 from langgraph.graph.state import CompiledStateGraph
 
@@ -20,9 +21,9 @@ from src.services.embeddings import EmbeddingService
 
 def create_research_graph(
     llm: BaseChatModel | None = None,
-    checkpointer: Any = None,
+    checkpointer: "BaseCheckpointSaver[Any]" | None = None,  # Generic type from langgraph
     embedding_service: EmbeddingService | None = None,
-) -> CompiledStateGraph:  # type: ignore
+) -> "CompiledStateGraph[Any]":  # type: ignore[type-arg]
     """Build the research state graph.
 
     Args:

src/agents/retrieval_agent.py

@@ -32,9 +32,8 @@ async def search_web(query: str, max_results: int = 10) -> str:
         logger.info("Web search returned no results", query=query)
         return f"No web results found for: {query}"
 
-    # Update state
-    # We add *all* found results to state
-    new_count = state.add_evidence(results.evidence)
+    # Store evidence with deduplication and embedding (all handled by memory layer)
+    new_count = await state.add_evidence(results.evidence)
     logger.info(
         "Web search complete",
         query=query,
@@ -42,11 +41,6 @@ async def search_web(query: str, max_results: int = 10) -> str:
         new_evidence=new_count,
     )
 
-    # Use embedding service for deduplication/indexing if available
-    if state.embedding_service:
-        # This method also adds to vector DB as a side effect for unique items
-        await state.embedding_service.deduplicate(results.evidence)
-
     output = [f"Found {len(results.evidence)} web results ({new_count} new stored):\n"]
     for i, r in enumerate(results.evidence[:max_results], 1):
         output.append(f"{i}. **{r.citation.title}**")

src/agents/state.py

@@ -5,78 +5,70 @@ searching simultaneously via Gradio).
 """
 
 from contextvars import ContextVar
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, cast
 
-from pydantic import BaseModel, Field
+from pydantic import BaseModel
 
-from src.utils.models import Citation, Evidence
+from src.services.research_memory import ResearchMemory
 
 if TYPE_CHECKING:
     from src.services.embeddings import EmbeddingService
+    from src.utils.models import Evidence
 
 
 class MagenticState(BaseModel):
     """Mutable state for a Magentic workflow session."""
 
-    evidence: list[Evidence] = Field(default_factory=list)
-    # Type as Any to avoid circular imports/runtime resolution issues
-    # The actual object injected will be an EmbeddingService instance
-    embedding_service: Any = None
+    # We wrap ResearchMemory. Type as Any to avoid pydantic validation issues with complex objects
+    memory: Any = None  # Instance of ResearchMemory
 
     model_config = {"arbitrary_types_allowed": True}
 
-    def add_evidence(self, new_evidence: list[Evidence]) -> int:
-        """Add new evidence, deduplicating by URL.
+    # --- Proxy methods for backwards compatibility with retrieval_agent.py ---
+
+    async def add_evidence(self, evidence: list["Evidence"]) -> int:
+        """Add evidence to memory with deduplication and embedding storage.
+
+        This method delegates to ResearchMemory.store_evidence() which:
+        1. Performs semantic deduplication (threshold 0.9)
+        2. Stores unique evidence in the vector store
+        3. Caches evidence for retrieval
+
+        Args:
+            evidence: List of Evidence objects to store.
 
         Returns:
-            Number of *new* items added.
+            Number of new (non-duplicate) evidence items stored.
         """
-        existing_urls = {e.citation.url for e in self.evidence}
-        count = 0
-        for item in new_evidence:
-            if item.citation.url not in existing_urls:
-                self.evidence.append(item)
-                existing_urls.add(item.citation.url)
-                count += 1
-        return count
-
-    async def search_related(self, query: str, n_results: int = 5) -> list[Evidence]:
-        """Search for semantically related evidence using the embedding service."""
-        if not self.embedding_service:
-            return []
-
-        results = await self.embedding_service.search_similar(query, n_results=n_results)
-
-        # Convert dict results back to Evidence objects
-        evidence_list = []
-        for item in results:
-            meta = item.get("metadata", {})
-            authors_str = meta.get("authors", "")
-            authors = [a.strip() for a in authors_str.split(",") if a.strip()]
-
-            ev = Evidence(
-                content=item["content"],
-                citation=Citation(
-                    title=meta.get("title", "Related Evidence"),
-                    url=item["id"],
-                    source="pubmed",  # Defaulting to pubmed if unknown
-                    date=meta.get("date", "n.d."),
-                    authors=authors,
-                ),
-                relevance=max(0.0, 1.0 - item.get("distance", 0.5)),
-            )
-            evidence_list.append(ev)
-
-        return evidence_list
+        if self.memory is None:
+            return 0
+
+        memory: ResearchMemory = self.memory
+        initial_count = len(memory.evidence_ids)
+        await memory.store_evidence(evidence)
+        return len(memory.evidence_ids) - initial_count
+
+    @property
+    def embedding_service(self) -> "EmbeddingService | None":
+        """Get the embedding service from memory."""
+        if self.memory is None:
+            return None
+        # Cast needed because memory is typed as Any to avoid Pydantic issues
+        from src.services.embeddings import EmbeddingService as EmbeddingSvc
+
+        return cast(EmbeddingSvc | None, self.memory._embedding_service)
 
 
 # The ContextVar holds the MagenticState for the current execution context
 _magentic_state_var: ContextVar[MagenticState | None] = ContextVar("magentic_state", default=None)
 
 
-def init_magentic_state(embedding_service: "EmbeddingService | None" = None) -> MagenticState:
+def init_magentic_state(
+    query: str, embedding_service: "EmbeddingService | None" = None
+) -> MagenticState:
     """Initialize a new state for the current context."""
-    state = MagenticState(embedding_service=embedding_service)
+    memory = ResearchMemory(query=query, embedding_service=embedding_service)
+    state = MagenticState(memory=memory)
     _magentic_state_var.set(state)
     return state
 
@@ -85,6 +77,5 @@ def get_magentic_state() -> MagenticState:
     """Get the current state. Raises RuntimeError if not initialized."""
     state = _magentic_state_var.get()
     if state is None:
-        # Auto-initialize if missing (e.g. during tests or simple scripts)
-        return init_magentic_state()
+        raise RuntimeError("MagenticState not initialized. Call init_magentic_state() first.")
     return state

src/agents/tools.py

@@ -38,27 +38,29 @@ async def search_pubmed(query: str, max_results: int = 10) -> str:
     if not results:
         return f"No PubMed results found for: {query}"
 
-    # 2. Semantic Deduplication & Expansion (The "Digital Twin" Brain)
-    display_results = results
-    if state.embedding_service:
-        # Deduplicate against what we just found vs what's in the DB
-        unique_results = await state.embedding_service.deduplicate(results)
+    # 2. Store in Memory (handles dedup and persistence)
+    # ResearchMemory handles semantic deduplication and persistence
+    new_ids = await state.memory.store_evidence(results)
+    new_count = len(new_ids)
 
-        # Search for related context in the vector DB (previous searches)
-        related = await state.search_related(query, n_results=3)
+    # 3. Context Expansion (The "Digital Twin" Brain)
+    # Combine what we just found with what we already know is relevant
+    display_results = list(results)
 
-        # Combine unique new results + relevant historical results
-        display_results = unique_results + related
+    # Search for related context in the memory (previous searches)
+    related = await state.memory.get_relevant_evidence(n=3)
 
-    # 3. Update State (Persist for ReportAgent)
-    # We add *all* found results to state, not just the displayed ones
-    new_count = state.add_evidence(results)
+    # Add related items if they aren't already in the results
+    current_urls = {r.citation.url for r in display_results}
+    for item in related:
+        if item.citation.url not in current_urls:
+            display_results.append(item)
 
     # 4. Format Output for LLM
     output = [f"Found {len(results)} results ({new_count} new stored):\n"]
 
     # Limit display to avoid context window overflow, but state has everything
-    limit = min(len(display_results), max_results)
+    limit = min(len(display_results), max_results + 3)
 
     for i, r in enumerate(display_results[:limit], 1):
         title = r.citation.title
@@ -96,7 +98,8 @@ async def search_clinical_trials(query: str, max_results: int = 10) -> str:
         return f"No clinical trials found for: {query}"
 
     # Update state
-    new_count = state.add_evidence(results)
+    new_ids = await state.memory.store_evidence(results)
+    new_count = len(new_ids)
 
     output = [f"Found {len(results)} clinical trials ({new_count} new stored):\n"]
     for i, r in enumerate(results[:max_results], 1):
@@ -135,7 +138,8 @@ async def search_preprints(query: str, max_results: int = 10) -> str:
         return f"No papers found for: {query}"
 
     # Update state
-    new_count = state.add_evidence(results)
+    new_ids = await state.memory.store_evidence(results)
+    new_count = len(new_ids)
 
     output = [f"Found {len(results)} papers ({new_count} new stored):\n"]
     for i, r in enumerate(results[:max_results], 1):
@@ -164,11 +168,13 @@ async def get_bibliography() -> str:
         Formatted bibliography string.
     """
     state = get_magentic_state()
-    if not state.evidence:
+    all_evidence = state.memory.get_all_evidence()
+
+    if not all_evidence:
         return "No evidence collected."
 
     output = ["## References"]
-    for i, ev in enumerate(state.evidence, 1):
+    for i, ev in enumerate(all_evidence, 1):
         output.append(f"{i}. {ev.citation.formatted}")
         output.append(f"   URL: {ev.citation.url}")
 

src/app.py

@@ -252,7 +252,7 @@ def create_demo() -> tuple[gr.ChatInterface, gr.Accordion]:
             ],
             [
                 "Clinical trials for erectile dysfunction alternatives to PDE5 inhibitors?",
-                "god",
+                "advanced",
                 None,
                 None,
             ],
@@ -266,10 +266,10 @@ def create_demo() -> tuple[gr.ChatInterface, gr.Accordion]:
         additional_inputs_accordion=additional_inputs_accordion,
         additional_inputs=[
             gr.Radio(
-                choices=["simple", "advanced", "god"],
+                choices=["simple", "advanced"],
                 value="simple",
                 label="Orchestrator Mode",
-                info="⚡ Simple: Free/Any | 🔬 Advanced: OpenAI | 🧠 God: Graph + Llama 3.1 (Exp)",
+                info="⚡ Simple: Free/Any | 🔬 Advanced: OpenAI (Deep Research)",
             ),
             gr.Textbox(
                 label="🔑 API Key (Optional)",

src/orchestrators/advanced.py

@@ -152,7 +152,7 @@ class AdvancedOrchestrator(OrchestratorProtocol):
 
         # Initialize context state
         embedding_service = self._init_embedding_service()
-        init_magentic_state(embedding_service)
+        init_magentic_state(query, embedding_service)
 
         workflow = self._build_workflow()
 
@@ -355,6 +355,7 @@ def _create_deprecated_alias() -> type["AdvancedOrchestrator"]:
         """
 
         def __init__(self, *args: Any, **kwargs: Any) -> None:
+            """Initialize deprecated MagenticOrchestrator (use AdvancedOrchestrator)."""
             warnings.warn(
                 "MagenticOrchestrator is deprecated, use AdvancedOrchestrator instead. "
                 "The name 'magentic' was confusing with the 'magentic' PyPI package.",

src/orchestrators/factory.py

@@ -52,33 +52,11 @@ def _get_advanced_orchestrator_class() -> type["AdvancedOrchestrator"]:
         ) from e
 
 
-def _get_langgraph_orchestrator_class() -> type["OrchestratorProtocol"]:
-    """Import LangGraphOrchestrator lazily.
-
-    Returns:
-        The LangGraphOrchestrator class
-
-    Raises:
-        ValueError: If langgraph dependencies are missing
-    """
-    try:
-        from src.orchestrators.langgraph_orchestrator import LangGraphOrchestrator
-
-        return LangGraphOrchestrator  # type: ignore
-    except ImportError as e:
-        logger.error("Failed to import LangGraphOrchestrator", error=str(e))
-        raise ValueError(
-            "LangGraph mode requires langgraph and langchain-huggingface. "
-            "Install with: uv add langgraph langchain-huggingface"
-        ) from e
-
-
 def create_orchestrator(
     search_handler: SearchHandlerProtocol | None = None,
     judge_handler: JudgeHandlerProtocol | None = None,
     config: OrchestratorConfig | None = None,
-    mode: Literal["simple", "magentic", "advanced", "hierarchical", "langgraph", "god"]
-    | None = None,
+    mode: Literal["simple", "magentic", "advanced", "hierarchical"] | None = None,
     api_key: str | None = None,
 ) -> OrchestratorProtocol:
     """
@@ -92,9 +70,8 @@ def create_orchestrator(
         search_handler: The search handler (required for simple mode)
         judge_handler: The judge handler (required for simple mode)
         config: Optional configuration (max_iterations, timeouts, etc.)
-        mode: "simple", "magentic", "advanced", "hierarchical", "langgraph" or "god"
+        mode: "simple", "magentic", "advanced", or "hierarchical"
               Note: "magentic" is an alias for "advanced" (kept for backwards compatibility)
-              Note: "god" is an alias for "langgraph"
         api_key: Optional API key for advanced mode (OpenAI)
 
     Returns:
@@ -108,15 +85,6 @@ def create_orchestrator(
     effective_mode = _determine_mode(mode, api_key)
     logger.info("Creating orchestrator", mode=effective_mode)
 
-    if effective_mode == "langgraph":
-        orchestrator_cls = _get_langgraph_orchestrator_class()
-        # Checkpoint path for dev persistence
-        checkpoint_path = "checkpoints.sqlite"
-        return orchestrator_cls(  # type: ignore
-            max_iterations=effective_config.max_iterations,
-            checkpoint_path=checkpoint_path,
-        )
-
     if effective_mode == "advanced":
         orchestrator_cls = _get_advanced_orchestrator_class()
         return orchestrator_cls(
@@ -152,11 +120,9 @@ def _determine_mode(explicit_mode: str | None, api_key: str | None) -> str:
         api_key: API key provided by caller
 
     Returns:
-        Effective mode string: "simple", "advanced", "hierarchical", or "langgraph"
+        Effective mode string: "simple", "advanced", or "hierarchical"
     """
     if explicit_mode:
-        if explicit_mode in ("langgraph", "god"):
-            return "langgraph"
         if explicit_mode in ("magentic", "advanced"):
             return "advanced"
         if explicit_mode == "hierarchical":

src/orchestrators/hierarchical.py

@@ -98,7 +98,7 @@ class HierarchicalOrchestrator(OrchestratorProtocol):
         logger.info("Starting hierarchical orchestrator", query=query)
 
         service = get_embedding_service_if_available()
-        init_magentic_state(service)
+        init_magentic_state(query, service)
 
         yield AgentEvent(type="started", message=f"Starting research: {query}")
 

src/orchestrators/langgraph_orchestrator.py

@@ -1,6 +1,12 @@
-"""LangGraph-based orchestrator implementation."""
+"""LangGraph-based orchestrator implementation.
+
+NOTE: This orchestrator is deprecated in favor of the shared memory layer
+integrated into Simple and Advanced modes (SPEC-08). It remains as a reference
+implementation for LangGraph patterns.
+"""
 
 import os
+import uuid
 from collections.abc import AsyncGenerator, AsyncIterator
 from typing import Any, Literal
 
@@ -16,7 +22,11 @@ from src.utils.models import AgentEvent
 
 
 class LangGraphOrchestrator(OrchestratorProtocol):
-    """State-driven research orchestrator using LangGraph."""
+    """State-driven research orchestrator using LangGraph.
+
+    DEPRECATED: Memory features are now integrated into Simple and Advanced modes.
+    This class is kept for reference and potential future use.
+    """
 
     def __init__(
         self,
@@ -34,7 +44,7 @@ class LangGraphOrchestrator(OrchestratorProtocol):
         api_key = settings.hf_token
         if not api_key:
             raise ValueError(
-                "HF_TOKEN (Hugging Face API Token) is required for God Mode to use Llama 3.1."
+                "HF_TOKEN (Hugging Face API Token) is required for LangGraph orchestrator."
             )
 
         self.llm_endpoint = HuggingFaceEndpoint(  # type: ignore
@@ -53,8 +63,10 @@ class LangGraphOrchestrator(OrchestratorProtocol):
 
         # Setup checkpointer (SQLite for dev)
         if self._checkpoint_path:
-            # Ensure directory exists
-            os.makedirs(os.path.dirname(self._checkpoint_path), exist_ok=True)
+            # Ensure directory exists (handle paths without directory component)
+            dir_name = os.path.dirname(self._checkpoint_path)
+            if dir_name:
+                os.makedirs(dir_name, exist_ok=True)
             saver = AsyncSqliteSaver.from_conn_string(self._checkpoint_path)
         else:
             saver = None
@@ -91,10 +103,11 @@ class LangGraphOrchestrator(OrchestratorProtocol):
                 "max_iterations": self._max_iterations,
             }
 
-            yield AgentEvent(type="started", message=f"Starting 'God Mode' research: {query}")
+            yield AgentEvent(type="started", message=f"Starting LangGraph research: {query}")
 
-            # Config for persistence (thread_id required if checkpointer used)
-            config = {"configurable": {"thread_id": "1"}} if saver else {}
+            # Config for persistence (unique thread_id per run to avoid state conflicts)
+            thread_id = str(uuid.uuid4())
+            config = {"configurable": {"thread_id": thread_id}} if saver else {}
 
             # Stream events
             # We use astream to get updates from the graph

src/orchestrators/simple.py

@@ -93,36 +93,6 @@ class Orchestrator:
                 self._enable_analysis = False
         return self._analyzer
 
-    def _get_embeddings(self) -> EmbeddingService | None:
-        """Lazy initialization of EmbeddingService."""
-        if self._embeddings is None and self._enable_embeddings:
-            from src.utils.service_loader import get_embedding_service_if_available
-
-            self._embeddings = get_embedding_service_if_available()
-            if self._embeddings is None:
-                self._enable_embeddings = False
-        return self._embeddings
-
-    async def _deduplicate_and_rank(self, evidence: list[Evidence], query: str) -> list[Evidence]:
-        """Use embeddings to deduplicate and rank evidence by relevance."""
-        embeddings = self._get_embeddings()
-        if not embeddings or not evidence:
-            return evidence
-
-        try:
-            # Deduplicate using semantic similarity
-            unique_evidence: list[Evidence] = await embeddings.deduplicate(evidence, threshold=0.85)
-
-            logger.info(
-                "Deduplicated evidence",
-                before=len(evidence),
-                after=len(unique_evidence),
-            )
-            return unique_evidence
-        except Exception as e:
-            logger.warning("Deduplication failed, using original", error=str(e))
-            return evidence
-
     async def _run_analysis_phase(
         self, query: str, evidence: list[Evidence], iteration: int
     ) -> AsyncGenerator[AgentEvent, None]:
@@ -237,6 +207,10 @@ class Orchestrator:
         Yields:
             AgentEvent objects for each step of the process
         """
+        # Import here to avoid circular deps if any
+        from src.agents.graph.state import Hypothesis
+        from src.services.research_memory import ResearchMemory
+
         logger.info("Starting orchestrator", query=query)
 
         yield AgentEvent(
@@ -245,6 +219,9 @@ class Orchestrator:
             iteration=0,
         )
 
+        # Initialize Shared Memory
+        # We keep 'all_evidence' for local tracking/reporting, but use Memory for intelligence
+        memory = ResearchMemory(query=query)
         all_evidence: list[Evidence] = []
         current_queries = [query]
         iteration = 0
@@ -282,15 +259,14 @@ class Orchestrator:
                         # Should not happen with return_exceptions=True but safe fallback
                         errors.append(f"Unknown result type for '{q}': {type(result)}")
 
-                # Deduplicate evidence by URL (fast, basic)
-                seen_urls = {e.citation.url for e in all_evidence}
-                unique_new = [e for e in new_evidence if e.citation.url not in seen_urls]
+                # === MEMORY INTEGRATION: Store and Deduplicate ===
+                # ResearchMemory handles semantic deduplication and persistence
+                # It returns IDs of actual NEW evidence
+                new_ids = await memory.store_evidence(new_evidence)
 
-                # BUG FIX: Only dedup NEW evidence, not all_evidence
-                # Old evidence is already in the vector store - re-checking it
-                # would mark items as duplicates of themselves (distance ≈ 0)
-                if unique_new:
-                    unique_new = await self._deduplicate_and_rank(unique_new, query)
+                # Filter new_evidence to only keep what was actually new (based on IDs)
+                # Note: This assumes IDs are URLs, which match Citation.url
+                unique_new = [e for e in new_evidence if e.citation.url in new_ids]
 
                 all_evidence.extend(unique_new)
 
@@ -319,15 +295,35 @@ class Orchestrator:
             # === JUDGE PHASE ===
             yield AgentEvent(
                 type="judging",
-                message=f"Evaluating {len(all_evidence)} sources...",
+                message=f"Evaluating evidence (Memory: {len(memory.evidence_ids)} docs)...",
                 iteration=iteration,
             )
 
             try:
+                # Retrieve RELEVANT evidence from memory for the judge
+                # This keeps the context window manageable and focused
+                judge_context = await memory.get_relevant_evidence(n=30)
+
+                # Fallback if memory is empty (shouldn't happen if search worked)
+                if not judge_context and all_evidence:
+                    judge_context = all_evidence[-30:]
+
                 assessment = await self.judge.assess(
-                    query, all_evidence, iteration, self.config.max_iterations
+                    query, judge_context, iteration, self.config.max_iterations
                 )
 
+                # === MEMORY INTEGRATION: Track Hypotheses ===
+                # Convert loose strings to structured Hypotheses
+                for candidate in assessment.details.drug_candidates:
+                    h = Hypothesis(
+                        id=candidate.replace(" ", "_").lower(),
+                        statement=f"{candidate} is a potential candidate for {query}",
+                        status="proposed",
+                        confidence=assessment.confidence,
+                        reasoning=f" identified in iteration {iteration}",
+                    )
+                    memory.add_hypothesis(h)
+
                 yield AgentEvent(
                     type="judge_complete",
                     message=(
@@ -388,6 +384,7 @@ class Orchestrator:
                     )
 
                     # Generate final response
+                    # Use all gathered evidence for the final report
                     final_response = self._generate_synthesis(query, all_evidence, assessment)
 
                     yield AgentEvent(

src/services/research_memory.py

@@ -0,0 +1,133 @@
+"""Shared research memory layer for all orchestration modes."""
+
+from typing import Any
+
+import structlog
+
+from src.agents.graph.state import Conflict, Hypothesis
+from src.services.embeddings import EmbeddingService
+from src.utils.models import Citation, Evidence
+
+logger = structlog.get_logger()
+
+
+class ResearchMemory:
+    """Shared cognitive state for research workflows.
+
+    This is the memory layer that ALL modes use.
+    It mimics the LangGraph state management but for manual orchestration.
+    """
+
+    def __init__(self, query: str, embedding_service: EmbeddingService | None = None):
+        """Initialize ResearchMemory with a query and optional embedding service.
+
+        Args:
+            query: The research query to track evidence for.
+            embedding_service: Service for semantic search and deduplication.
+                             Creates a new instance if not provided.
+        """
+        self.query = query
+        self.hypotheses: list[Hypothesis] = []
+        self.conflicts: list[Conflict] = []
+        self.evidence_ids: list[str] = []
+        self._evidence_cache: dict[str, Evidence] = {}
+        self.iteration_count: int = 0
+
+        # Injected service
+        self._embedding_service = embedding_service or EmbeddingService()
+
+    async def store_evidence(self, evidence: list[Evidence]) -> list[str]:
+        """Store evidence and return new IDs (deduped)."""
+        if not self._embedding_service:
+            return []
+
+        unique = await self._embedding_service.deduplicate(evidence)
+        new_ids = []
+
+        for ev in unique:
+            ev_id = ev.citation.url
+            await self._embedding_service.add_evidence(
+                evidence_id=ev_id,
+                content=ev.content,
+                metadata={
+                    "source": ev.citation.source,
+                    "title": ev.citation.title,
+                    "date": ev.citation.date,
+                    "authors": ",".join(ev.citation.authors or []),
+                    "url": ev.citation.url,
+                },
+            )
+            new_ids.append(ev_id)
+            self._evidence_cache[ev_id] = ev
+
+        self.evidence_ids.extend(new_ids)
+        if new_ids:
+            logger.info("Stored new evidence", count=len(new_ids))
+        return new_ids
+
+    def get_all_evidence(self) -> list[Evidence]:
+        """Get all accumulated evidence objects."""
+        return list(self._evidence_cache.values())
+
+    async def get_relevant_evidence(self, n: int = 20) -> list[Evidence]:
+        """Retrieve relevant evidence for current query."""
+        if not self._embedding_service:
+            return []
+
+        results = await self._embedding_service.search_similar(self.query, n_results=n)
+        evidence_list = []
+
+        for r in results:
+            meta = r.get("metadata", {})
+            authors_str = meta.get("authors", "")
+            authors = authors_str.split(",") if authors_str else []
+
+            # Reconstruct Evidence object
+            source_raw = meta.get("source", "web")
+
+            # Basic validation/fallback for source
+            valid_sources = [
+                "pubmed",
+                "clinicaltrials",
+                "europepmc",
+                "preprint",
+                "openalex",
+                "web",
+            ]
+            source_name: Any = source_raw if source_raw in valid_sources else "web"
+
+            citation = Citation(
+                source=source_name,
+                title=meta.get("title", "Unknown"),
+                url=meta.get("url", r.get("id", "")),
+                date=meta.get("date", "Unknown"),
+                authors=authors,
+            )
+
+            evidence_list.append(
+                Evidence(
+                    content=r.get("content", ""),
+                    citation=citation,
+                    relevance=1.0 - r.get("distance", 0.5),  # Approx conversion
+                )
+            )
+
+        return evidence_list
+
+    def add_hypothesis(self, hypothesis: Hypothesis) -> None:
+        """Add a hypothesis to tracking."""
+        self.hypotheses.append(hypothesis)
+        logger.info("Added hypothesis", id=hypothesis.id, confidence=hypothesis.confidence)
+
+    def add_conflict(self, conflict: Conflict) -> None:
+        """Add a detected conflict."""
+        self.conflicts.append(conflict)
+        logger.info("Added conflict", id=conflict.id)
+
+    def get_open_conflicts(self) -> list[Conflict]:
+        """Get unresolved conflicts."""
+        return [c for c in self.conflicts if c.status == "open"]
+
+    def get_confirmed_hypotheses(self) -> list[Hypothesis]:
+        """Get high-confidence hypotheses."""
+        return [h for h in self.hypotheses if h.confidence > 0.8]

tests/unit/services/test_research_memory.py

@@ -0,0 +1,118 @@
+"""Tests for the shared ResearchMemory service."""
+
+from unittest.mock import AsyncMock, MagicMock
+
+import pytest
+
+from src.agents.graph.state import Conflict, Hypothesis
+from src.services.research_memory import ResearchMemory
+from src.utils.models import Citation, Evidence
+
+
+@pytest.fixture
+def mock_embedding_service():
+    service = MagicMock()
+    service.deduplicate = AsyncMock()
+    service.add_evidence = AsyncMock()
+    service.search_similar = AsyncMock()
+    return service
+
+
+@pytest.fixture
+def memory(mock_embedding_service):
+    return ResearchMemory(query="test query", embedding_service=mock_embedding_service)
+
+
+@pytest.mark.asyncio
+async def test_store_evidence(memory, mock_embedding_service):
+    # Setup
+    ev1 = Evidence(
+        content="content1",
+        citation=Citation(source="pubmed", title="t1", url="u1", date="2023", authors=["a1"]),
+    )
+    ev2 = Evidence(
+        content="content2",
+        citation=Citation(source="pubmed", title="t2", url="u2", date="2023", authors=["a2"]),
+    )
+
+    # deduplicate returns only ev1 (simulating ev2 is duplicate)
+    mock_embedding_service.deduplicate.return_value = [ev1]
+
+    # Execute
+    new_ids = await memory.store_evidence([ev1, ev2])
+
+    # Verify
+    assert new_ids == ["u1"]
+    assert memory.evidence_ids == ["u1"]
+
+    # deduplicate called with both
+    mock_embedding_service.deduplicate.assert_called_once_with([ev1, ev2])
+
+    # add_evidence called only for ev1
+    mock_embedding_service.add_evidence.assert_called_once()
+    args = mock_embedding_service.add_evidence.call_args[1]
+    assert args["evidence_id"] == "u1"
+    assert args["content"] == "content1"
+
+
+@pytest.mark.asyncio
+async def test_get_relevant_evidence(memory, mock_embedding_service):
+    # Setup mock return from ChromaDB format
+    mock_embedding_service.search_similar.return_value = [
+        {
+            "id": "u1",
+            "content": "content1",
+            "metadata": {
+                "source": "pubmed",
+                "title": "t1",
+                "date": "2023",
+                "authors": "a1,a2",
+                "url": "u1",
+            },
+            "distance": 0.1,
+        }
+    ]
+
+    # Execute
+    results = await memory.get_relevant_evidence(n=5)
+
+    # Verify
+    assert len(results) == 1
+    ev = results[0]
+    assert isinstance(ev, Evidence)
+    assert ev.content == "content1"
+    assert ev.citation.title == "t1"
+    assert ev.citation.authors == ["a1", "a2"]
+    assert ev.relevance > 0.8  # 1.0 - 0.1 = 0.9
+
+
+def test_hypothesis_tracking(memory):
+    h1 = Hypothesis(id="h1", statement="drug -> target", status="confirmed", confidence=0.9)
+    h2 = Hypothesis(id="h2", statement="drug -> unknown", status="proposed", confidence=0.5)
+
+    memory.add_hypothesis(h1)
+    memory.add_hypothesis(h2)
+
+    assert len(memory.hypotheses) == 2
+    confirmed = memory.get_confirmed_hypotheses()
+    assert len(confirmed) == 1
+    assert confirmed[0].id == "h1"
+
+
+def test_conflict_tracking(memory):
+    c1 = Conflict(id="c1", description="conflict", source_a_id="a", source_b_id="b", status="open")
+    c2 = Conflict(
+        id="c2",
+        description="resolved conflict",
+        source_a_id="a",
+        source_b_id="b",
+        status="resolved",
+    )
+
+    memory.add_conflict(c1)
+    memory.add_conflict(c2)
+
+    assert len(memory.conflicts) == 2
+    open_conflicts = memory.get_open_conflicts()
+    assert len(open_conflicts) == 1
+    assert open_conflicts[0].id == "c1"

tests/unit/test_ui_elements.py

@@ -4,11 +4,11 @@ from src.app import create_demo
 
 
 def test_examples_include_advanced_mode():
-    """Verify that one example entry uses 'god' or 'advanced' mode."""
+    """Verify that one example entry uses 'advanced' mode."""
     demo, _ = create_demo()
     assert any(
-        example[1] in ["advanced", "god"] for example in demo.examples
-    ), "Expected at least one example to be 'advanced' or 'god' mode"
+        example[1] == "advanced" for example in demo.examples
+    ), "Expected at least one example to be 'advanced' mode"
 
 
 def test_accordion_label_updated():
@@ -24,7 +24,7 @@ def test_orchestrator_mode_info_text_updated():
     demo, _ = create_demo()
     # Assuming additional_inputs is a list and the Radio is the first element
     orchestrator_radio = demo.additional_inputs[0]
-    expected_info = "⚡ Simple: Free/Any | 🔬 Advanced: OpenAI | 🧠 God: Graph + Llama 3.1 (Exp)"
+    expected_info = "⚡ Simple: Free/Any | 🔬 Advanced: OpenAI (Deep Research)"
     assert isinstance(
         orchestrator_radio, gr.Radio
     ), "Expected first additional input to be gr.Radio"

uv.lock

@@ -1138,6 +1138,7 @@ dependencies = [
     { name = "requests" },
     { name = "structlog" },
     { name = "tenacity" },
+    { name = "urllib3" },
     { name = "xmltodict" },
 ]
 
@@ -1184,11 +1185,11 @@ requires-dist = [
     { name = "gradio", extras = ["mcp"], specifier = ">=6.0.0" },
     { name = "httpx", specifier = ">=0.27" },
     { name = "huggingface-hub", specifier = ">=0.20.0" },
-    { name = "langchain", specifier = ">=0.3.9" },
-    { name = "langchain-core", specifier = ">=0.3.21" },
-    { name = "langchain-huggingface", specifier = ">=0.1.2" },
-    { name = "langgraph", specifier = ">=0.2.50" },
-    { name = "langgraph-checkpoint-sqlite", specifier = ">=2.0.0" },
+    { name = "langchain", specifier = ">=0.3.9,<1.0" },
+    { name = "langchain-core", specifier = ">=0.3.21,<1.0" },
+    { name = "langchain-huggingface", specifier = ">=0.1.2,<1.0" },
+    { name = "langgraph", specifier = ">=0.2.50,<1.0" },
+    { name = "langgraph-checkpoint-sqlite", specifier = ">=3.0.0,<4.0" },
     { name = "limits", specifier = ">=3.0" },
     { name = "llama-index", marker = "extra == 'modal'", specifier = ">=0.11.0" },
     { name = "llama-index-embeddings-openai", marker = "extra == 'modal'" },
@@ -1215,6 +1216,7 @@ requires-dist = [
     { name = "structlog", specifier = ">=24.1" },
     { name = "tenacity", specifier = ">=8.2" },
     { name = "typer", marker = "extra == 'dev'", specifier = ">=0.9.0" },
+    { name = "urllib3", specifier = ">=2.5.0" },
     { name = "xmltodict", specifier = ">=0.13" },
 ]
 provides-extras = ["dev", "magentic", "embeddings", "modal"]
@@ -2350,12 +2352,13 @@ wheels = [
 
 [[package]]
 name = "kubernetes"
-version = "34.1.0"
+version = "33.1.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "certifi" },
     { name = "durationpy" },
     { name = "google-auth" },
+    { name = "oauthlib" },
     { name = "python-dateutil" },
     { name = "pyyaml" },
     { name = "requests" },
@@ -2364,28 +2367,32 @@ dependencies = [
     { name = "urllib3" },
     { name = "websocket-client" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/ef/55/3f880ef65f559cbed44a9aa20d3bdbc219a2c3a3bac4a30a513029b03ee9/kubernetes-34.1.0.tar.gz", hash = "sha256:8fe8edb0b5d290a2f3ac06596b23f87c658977d46b5f8df9d0f4ea83d0003912", size = 1083771 }
+sdist = { url = "https://files.pythonhosted.org/packages/ae/52/19ebe8004c243fdfa78268a96727c71e08f00ff6fe69a301d0b7fcbce3c2/kubernetes-33.1.0.tar.gz", hash = "sha256:f64d829843a54c251061a8e7a14523b521f2dc5c896cf6d65ccf348648a88993", size = 1036779 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/ca/ec/65f7d563aa4a62dd58777e8f6aa882f15db53b14eb29aba0c28a20f7eb26/kubernetes-34.1.0-py2.py3-none-any.whl", hash = "sha256:bffba2272534e224e6a7a74d582deb0b545b7c9879d2cd9e4aae9481d1f2cc2a", size = 2008380 },
+    { url = "https://files.pythonhosted.org/packages/89/43/d9bebfc3db7dea6ec80df5cb2aad8d274dd18ec2edd6c4f21f32c237cbbb/kubernetes-33.1.0-py2.py3-none-any.whl", hash = "sha256:544de42b24b64287f7e0aa9513c93cb503f7f40eea39b20f66810011a86eabc5", size = 1941335 },
 ]
 
 [[package]]
 name = "langchain"
-version = "1.1.0"
+version = "0.3.27"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
-    { name = "langgraph" },
+    { name = "langchain-text-splitters" },
+    { name = "langsmith" },
     { name = "pydantic" },
+    { name = "pyyaml" },
+    { name = "requests" },
+    { name = "sqlalchemy" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/a1/06/be7273c6c15f5a7e64788ed2aa6329dd019170a176977acff7bcde2cdea2/langchain-1.1.0.tar.gz", hash = "sha256:583c892f59873c0329dbe04169fb3234ac794c50780e7c6fb62a61c7b86a981b", size = 528416 }
+sdist = { url = "https://files.pythonhosted.org/packages/83/f6/f4f7f3a56626fe07e2bb330feb61254dbdf06c506e6b59a536a337da51cf/langchain-0.3.27.tar.gz", hash = "sha256:aa6f1e6274ff055d0fd36254176770f356ed0a8994297d1df47df341953cec62", size = 10233809 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/0b/6f/889c01d22c84934615fa3f2dcf94c2fe76fd0afa7a7d01f9b798059f0ecc/langchain-1.1.0-py3-none-any.whl", hash = "sha256:af080f3a4a779bfa5925de7aacb6dfab83249d4aab9a08f7aa7b9bec3766d8ea", size = 101797 },
+    { url = "https://files.pythonhosted.org/packages/f6/d5/4861816a95b2f6993f1360cfb605aacb015506ee2090433a71de9cca8477/langchain-0.3.27-py3-none-any.whl", hash = "sha256:7b20c4f338826acb148d885b20a73a16e410ede9ee4f19bb02011852d5f98798", size = 1018194 },
 ]
 
 [[package]]
 name = "langchain-core"
-version = "1.1.0"
+version = "0.3.80"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "jsonpatch" },
@@ -2396,28 +2403,40 @@ dependencies = [
     { name = "tenacity" },
     { name = "typing-extensions" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/1e/17/67c1cc2ace919e2b02dd9d783154d7fb3f1495a4ef835d9cd163b7855ac2/langchain_core-1.1.0.tar.gz", hash = "sha256:2b76a82d427922c8bc51c08404af4fc2a29e9f161dfe2297cb05091e810201e7", size = 781995 }
+sdist = { url = "https://files.pythonhosted.org/packages/49/49/f76647b7ba1a6f9c11b0343056ab4d3e5fc445981d205237fed882b2ad60/langchain_core-0.3.80.tar.gz", hash = "sha256:29636b82513ab49e834764d023c4d18554d3d719a185d37b019d0a8ae948c6bb", size = 583629 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/71/1e/e129fc471a2d2a7b3804480a937b5ab9319cab9f4142624fcb115f925501/langchain_core-1.1.0-py3-none-any.whl", hash = "sha256:2c9f27dadc6d21ed4aa46506a37a56e6a7e2d2f9141922dc5c251ba921822ee6", size = 473752 },
+    { url = "https://files.pythonhosted.org/packages/da/e8/e7a090ebe37f2b071c64e81b99fb1273b3151ae932f560bb94c22f191cde/langchain_core-0.3.80-py3-none-any.whl", hash = "sha256:2141e3838d100d17dce2359f561ec0df52c526bae0de6d4f469f8026c5747456", size = 450786 },
 ]
 
 [[package]]
 name = "langchain-huggingface"
-version = "1.1.0"
+version = "0.3.1"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "huggingface-hub" },
     { name = "langchain-core" },
     { name = "tokenizers" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/9f/d7/ffcf97cd977c535df2c621c59eafa82df73f801323f670d88819c23fc304/langchain_huggingface-1.1.0.tar.gz", hash = "sha256:43c3b06413158b0cd1edcdbadf545c24d5f64f180bb71c80dc960959a728c1fd", size = 252295 }
+sdist = { url = "https://files.pythonhosted.org/packages/3f/15/f832ae485707bf52f9a8f055db389850de06c46bc6e3e4420a0ef105fbbf/langchain_huggingface-0.3.1.tar.gz", hash = "sha256:0a145534ce65b5a723c8562c456100a92513bbbf212e6d8c93fdbae174b41341", size = 25154 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/b1/4b/2bdd63464a7bb3aa7911777636cff8e54a2a1edc7b7a85a4acb7decebb23/langchain_huggingface-1.1.0-py3-none-any.whl", hash = "sha256:a3a5218a839062941cb616992bcbc4fe73352454727bafc351a452e76aead1a8", size = 29925 },
+    { url = "https://files.pythonhosted.org/packages/bf/26/7c5d4b4d3e1a7385863acc49fb6f96c55ccf941a750991d18e3f6a69a14a/langchain_huggingface-0.3.1-py3-none-any.whl", hash = "sha256:de10a692dc812885696fbaab607d28ac86b833b0f305bccd5d82d60336b07b7d", size = 27609 },
+]
+
+[[package]]
+name = "langchain-text-splitters"
+version = "0.3.11"
+source = { registry = "https://pypi.org/simple" }
+dependencies = [
+    { name = "langchain-core" },
+]
+sdist = { url = "https://files.pythonhosted.org/packages/11/43/dcda8fd25f0b19cb2835f2f6bb67f26ad58634f04ac2d8eae00526b0fa55/langchain_text_splitters-0.3.11.tar.gz", hash = "sha256:7a50a04ada9a133bbabb80731df7f6ddac51bc9f1b9cab7fa09304d71d38a6cc", size = 46458 }
+wheels = [
+    { url = "https://files.pythonhosted.org/packages/58/0d/41a51b40d24ff0384ec4f7ab8dd3dcea8353c05c973836b5e289f1465d4f/langchain_text_splitters-0.3.11-py3-none-any.whl", hash = "sha256:cf079131166a487f1372c8ab5d0bfaa6c0a4291733d9c43a34a16ac9bcd6a393", size = 33845 },
 ]
 
 [[package]]
 name = "langgraph"
-version = "1.0.4"
+version = "0.6.11"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
@@ -2427,9 +2446,9 @@ dependencies = [
     { name = "pydantic" },
     { name = "xxhash" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/d6/3c/af87902d300c1f467165558c8966d8b1e1f896dace271d3f35a410a5c26a/langgraph-1.0.4.tar.gz", hash = "sha256:86d08e25d7244340f59c5200fa69fdd11066aa999b3164b531e2a20036fac156", size = 484397 }
+sdist = { url = "https://files.pythonhosted.org/packages/87/4d/8dfe5e0f9c69655dfb1f450922699ab683b3abbc038cfe38f769eaf871c2/langgraph-0.6.11.tar.gz", hash = "sha256:cd5373d0a59701ab39c9f8af33a33c5704553de815318387fa7f240511e0efd7", size = 492075 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/14/52/4eb25a3f60399da34ba34adff1b3e324cf0d87eb7a08cebf1882a9b5e0d5/langgraph-1.0.4-py3-none-any.whl", hash = "sha256:b1a835ceb0a8d69b9db48075e1939e28b1ad70ee23fa3fa8f90149904778bacf", size = 157271 },
+    { url = "https://files.pythonhosted.org/packages/df/94/430f0341c5c2fe3e3b9f5ab2622f35e2bda12c4a7d655c519468e853d1b0/langgraph-0.6.11-py3-none-any.whl", hash = "sha256:49268de69d85b7db3da9e2ca582a474516421c1c44be5cff390416cfa6967faa", size = 155424 },
 ]
 
 [[package]]
@@ -2461,15 +2480,15 @@ wheels = [
 
 [[package]]
 name = "langgraph-prebuilt"
-version = "1.0.5"
+version = "0.6.5"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
     { name = "langchain-core" },
     { name = "langgraph-checkpoint" },
 ]
-sdist = { url = "https://files.pythonhosted.org/packages/46/f9/54f8891b32159e4542236817aea2ee83de0de18bce28e9bdba08c7f93001/langgraph_prebuilt-1.0.5.tar.gz", hash = "sha256:85802675ad778cc7240fd02d47db1e0b59c0c86d8369447d77ce47623845db2d", size = 144453 }
+sdist = { url = "https://files.pythonhosted.org/packages/98/6a/76ed0f0d740b187ac2014beae929658881b8d18291bd107571aae5515b12/langgraph_prebuilt-0.6.5.tar.gz", hash = "sha256:9c63e9e867e62b345805fd1e8ea5c2df5cc112e939d714f277af84f2afe5950d", size = 125791 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/87/5e/aeba4a5b39fe6e874e0dd003a82da71c7153e671312671a8dacc5cb7c1af/langgraph_prebuilt-1.0.5-py3-none-any.whl", hash = "sha256:22369563e1848862ace53fbc11b027c28dd04a9ac39314633bb95f2a7e258496", size = 35072 },
+    { url = "https://files.pythonhosted.org/packages/8e/d1/e4727f4822943befc3b7046f79049b1086c9493a34b4d44a1adf78577693/langgraph_prebuilt-0.6.5-py3-none-any.whl", hash = "sha256:b6ceb5db31c16a30a3ee3c0b923667f02e7c9e27852621abf9d5bd5603534141", size = 28158 },
 ]
 
 [[package]]
@@ -6302,11 +6321,11 @@ wheels = [
 
 [[package]]
 name = "urllib3"
-version = "2.3.0"
+version = "2.5.0"
 source = { registry = "https://pypi.org/simple" }
-sdist = { url = "https://files.pythonhosted.org/packages/aa/63/e53da845320b757bf29ef6a9062f5c669fe997973f966045cb019c3f4b66/urllib3-2.3.0.tar.gz", hash = "sha256:f8c5449b3cf0861679ce7e0503c7b44b5ec981bec0d1d3795a07f1ba96f0204d", size = 307268 }
+sdist = { url = "https://files.pythonhosted.org/packages/15/22/9ee70a2574a4f4599c47dd506532914ce044817c7752a79b6a51286319bc/urllib3-2.5.0.tar.gz", hash = "sha256:3fc47733c7e419d4bc3f6b3dc2b4f890bb743906a30d56ba4a5bfa4bbff92760", size = 393185 }
 wheels = [
-    { url = "https://files.pythonhosted.org/packages/c8/19/4ec628951a74043532ca2cf5d97b7b14863931476d117c471e8e2b1eb39f/urllib3-2.3.0-py3-none-any.whl", hash = "sha256:1cee9ad369867bfdbbb48b7dd50374c0967a0bb7710050facf0dd6911440e3df", size = 128369 },
+    { url = "https://files.pythonhosted.org/packages/a7/c2/fe1e52489ae3122415c51f387e221dd0773709bad6c6cdaa599e8a2c5185/urllib3-2.5.0-py3-none-any.whl", hash = "sha256:e6b01673c0fa6a13e374b50871808eb3bf7046c4b125b216f6bf1cc604cff0dc", size = 129795 },
 ]
 
 [[package]]