"""
LangGraph state machine for Agentic Adaptive RAG.
9 nodes orchestrated in a self-reflective loop with 2 retries.
Uses the LangGraph StateGraph API with typed state and conditional edges.
Architecture:
START → memory_retrieve → route_query
├─ "direct" → generate_answer → self_reflect → memory_store → END
└─ "search"/"kg"/"web" → rewrite_query → retrieve → grade_documents
├─ relevant → generate_answer → self_reflect → memory_store → END
└─ irrelevant → rewrite_retry → rewrite_query (loop, max 2)
Self-reflection: hallucination check + completeness check → verdict pass/fail.
FAIL → rewrite_retry → rewrite_query (loop, max 2)
PASS → memory_store → END
"""
from __future__ import annotations
import json
import logging
from typing import Annotated, Any, Dict, List, Literal, Optional, TypedDict
from langgraph.graph import StateGraph, START, END
from langgraph.graph.message import add_messages
from langgraph.checkpoint.memory import MemorySaver
from langchain_core.messages import HumanMessage, AIMessage
from src.agents.agent_config import (
AGENT_MAX_RETRIES, AGENT_SEARCH_TIMEOUT,
AGENT_MAX_CONTEXT_TOKENS, AGENT_DEFAULT_K,
)
from src.agents.prompts import (
ROUTE_SYSTEM_PROMPT, REWRITE_PROMPT, REWRITE_IRRELEVANT_PROMPT,
REWRITE_HALLUCINATION_PROMPT, REWRITE_INCOMPLETE_PROMPT,
GRADE_PROMPT, GRADE_BATCH_PROMPT, GENERATE_PROMPT, GENERATE_NO_CONTEXT,
REFLECT_HALLUCINATION_PROMPT, REFLECT_COMPLETENESS_PROMPT,
STRUCTURED_REWRITE_PROMPT, HYDE_PROMPT,
)
from src.agents.tracing import traced_llm_call
logger = logging.getLogger(__name__)
class RetrievedDoc(TypedDict, total=False):
"""Typed schema for a retrieved document. Filled incrementally by nodes."""
id: str
content: str
score: float
collection: str
cve_ids: list[str]
relevance_grade: str
class ReflectionResult(TypedDict, total=False):
"""Structured reflection output for routing decisions."""
verdict: Literal["pass", "fail"]
hallucination: bool
completeness: bool
hallucination_score: float
completeness_score: float
unsupported_claims: list[str]
missing_aspects: list[str]
class RAGState(TypedDict):
"""Typed state for the agent graph (9 functional nodes)."""
messages: Annotated[list, add_messages]
original_query: str
rewritten_query: str
route_decision: str
rewrite_reason: str
rewrite_strategy: str
search_collections: list[str]
retrieved_docs: list[dict]
kg_context: str
kg_enriched: bool
memory_context: str
generation: str
reflection: dict
retry_count: int
_relevant_count: int
mem0_user_id: str
tracing_trace_id: str
kg_seeds: list[dict]
hyde_doc: str
filters: dict
web_fallback_used: bool
def _parse_json_safely(text: str, default: dict = None) -> dict:
"""Robust JSON parser handling markdown code blocks, think-tags, and partial output."""
if default is None:
default = {}
import re as _re
text = (text or "").strip()
# Strip DeepSeek/reasoning ... blocks before any other processing
text = _re.sub(r'.*?', '', text, flags=_re.DOTALL).strip()
for prefix in ("```json", "```"):
if text.startswith(prefix):
text = text[len(prefix):]
if text.endswith("```"):
text = text[:-3]
text = text.strip()
try:
return json.loads(text)
except json.JSONDecodeError:
try:
match = _re.search(r'\{.*\}', text, _re.DOTALL)
if match:
return json.loads(match.group())
except (json.JSONDecodeError, AttributeError):
pass
return default
def _extract_cve_ids(text: str) -> list[str]:
"""Extract CVE IDs from text."""
import re
return list(set(re.findall(r'CVE-\d{4}-\d{4,}', text, re.IGNORECASE)))
# ─────────────────────────────────────────────────────────────────────────────
# Node factories (runtime deps injected at compile time)
# ─────────────────────────────────────────────────────────────────────────────
def make_memory_retrieve(memory):
"""Pre-hook: recall past context from Mem0."""
def memory_retrieve(state: RAGState) -> dict:
query = state.get("original_query", "")
user_id = state.get("mem0_user_id", "default_session")
if memory is None or not query:
return {"memory_context": ""}
try:
ctx = memory.recall(query, user_id)
logger.info("Memory recall: %d chars", len(ctx))
return {"memory_context": ctx}
except Exception as e:
logger.warning("Memory recall failed: %s", e)
return {"memory_context": ""}
return memory_retrieve
def make_route_query(llm_client):
"""Route node: classify user intent + decide which collections to search."""
def route_query(state: RAGState) -> dict:
query = state.get("original_query", "")
if llm_client is None:
return {"route_decision": "search", "search_collections": ["cve"]}
try:
trace_id = state.get("tracing_trace_id", "")
with traced_llm_call(
llm_client, ROUTE_SYSTEM_PROMPT + f"\n\nUser query: {query}",
"route", trace_id=trace_id, max_tokens=200,
) as gen:
response = gen()
parsed = _parse_json_safely(response, {"intent": "search", "collections": ["cve"]})
intent = parsed.get("intent", "search")
collections = parsed.get("collections", ["cve"])
if not isinstance(collections, list) or not collections:
collections = ["cve"]
logger.info("Route: intent=%s collections=%s", intent, collections)
return {
"route_decision": intent,
"search_collections": collections,
"rewrite_reason": "",
"retry_count": state.get("retry_count", 0),
"kg_enriched": False,
}
except Exception as e:
logger.warning("Route failed: %s — defaulting to search/cve", e)
return {
"route_decision": "search", "search_collections": ["cve"],
"rewrite_reason": "", "kg_enriched": False,
}
return route_query
def _pick_rewrite_prompt(reason: str, query: str) -> str:
"""Select the right rewrite prompt based on retry reason."""
if reason == "irrelevant_docs":
return REWRITE_IRRELEVANT_PROMPT.format(question=query)
if reason == "hallucination":
return REWRITE_HALLUCINATION_PROMPT.format(question=query)
if reason == "incomplete":
return REWRITE_INCOMPLETE_PROMPT.format(question=query)
return REWRITE_PROMPT.format(question=query)
def _select_rewrite_strategy(reason: str, retry: int, route: str) -> str:
"""Choose rewrite strategy based on retry context."""
if route == "investigate":
return "hyde"
if reason == "irrelevant_docs" and retry == 1:
return "hyde"
if reason == "irrelevant_docs":
return "irrelevant"
if reason == "hallucination":
return "hallucination"
if reason == "incomplete":
return "incomplete"
return "structured"
def make_rewrite_query(llm_client, cheat_sheet=None):
"""Rewrite node: reformulate query with cheat-sheet hints and strategy selection.
Strategies:
structured — initial pass: JSON output {hyde_doc, search_query, kg_seeds, filters}
hyde — retry-1 or investigate route: hypothetical document embedding
irrelevant — retry-2 after irrelevant docs: broaden/rephrase
hallucination / incomplete — reflection-driven rewrites
"""
def rewrite_query(state: RAGState) -> dict:
query = state.get("original_query", "")
reason = state.get("rewrite_reason", "")
retry = state.get("retry_count", 0)
route = state.get("route_decision", "search")
memctx = state.get("memory_context", "") or "(none)"
trace_id = state.get("tracing_trace_id", "")
strategy = _select_rewrite_strategy(reason, retry, route)
out: dict = {"rewrite_strategy": strategy}
# Build cheat-sheet hint block
hint_block = ""
if cheat_sheet is not None:
try:
hints = cheat_sheet.entity_to_hints(query)
hint_block = cheat_sheet.render_hint_block(hints) or ""
except Exception as e:
logger.debug("Cheat-sheet hint failed: %s", e)
if llm_client is None:
out["rewritten_query"] = query
return out
try:
if strategy == "structured":
prompt = STRUCTURED_REWRITE_PROMPT.format(
question=query,
memory_context=memctx,
cheat_sheet_hints=hint_block or "(none)",
)
with traced_llm_call(
llm_client, prompt, "rewrite_structured",
trace_id=trace_id,
system_prompt="Answer in JSON only.", max_tokens=400,
) as gen:
raw = gen()
parsed = _parse_json_safely(raw, {})
out["rewritten_query"] = parsed.get("search_query") or query
out["hyde_doc"] = parsed.get("hyde_doc") or ""
out["kg_seeds"] = [
s for s in parsed.get("kg_seeds", [])
if isinstance(s, dict) and "node_label" in s and "node_id" in s
]
out["filters"] = parsed.get("filters") or {}
elif strategy == "hyde":
prompt = HYDE_PROMPT.format(
question=query,
cheat_sheet_hints=hint_block or "(none)",
)
with traced_llm_call(
llm_client, prompt, "rewrite_hyde",
trace_id=trace_id, max_tokens=300,
) as gen:
hyde = gen().strip()
out["hyde_doc"] = hyde
out["rewritten_query"] = hyde or query
out["kg_seeds"] = state.get("kg_seeds") or []
else:
template = {
"irrelevant": REWRITE_IRRELEVANT_PROMPT,
"hallucination": REWRITE_HALLUCINATION_PROMPT,
"incomplete": REWRITE_INCOMPLETE_PROMPT,
}[strategy]
with traced_llm_call(
llm_client, template.format(question=query),
f"rewrite_{strategy}",
trace_id=trace_id, max_tokens=200,
) as gen:
out["rewritten_query"] = gen().strip() or query
except Exception as e:
logger.warning("Rewrite[%s] failed: %s", strategy, e)
out.setdefault("rewritten_query", query)
logger.info(
"Rewrite[%s] retry=%d → '%s' (seeds=%d, hyde=%d chars, hints=%d chars)",
strategy, retry,
out.get("rewritten_query", "")[:60],
len(out.get("kg_seeds") or []),
len(out.get("hyde_doc") or ""),
len(hint_block),
)
return out
return rewrite_query
def _parse_search_text(text: str) -> list[dict]:
"""Parse the formatted output of the search() tool back into doc dicts.
The tool emits blocks: '[N] (meta) score=X.XXX\\n'
Unrecognised formats are returned as a single raw doc.
"""
import re
docs = []
for block in re.split(r"\n(?=\[\d+\])", text.strip()):
m = re.match(r"\[(\d+)\]\s+(\S+).*?score=([\d.]+)\n(.+)", block, re.DOTALL)
if m:
doc_id = m.group(2)
docs.append({
"id": doc_id,
"text": m.group(4).strip(),
"score": float(m.group(3)),
"metadata": {"cve_id": doc_id if doc_id.upper().startswith("CVE-") else ""},
})
if not docs and text.strip():
docs.append({"id": "search-raw", "text": text.strip(), "score": 0.5, "metadata": {}})
return docs
def _render_subgraph(sub: dict, seed_ids: list[str]) -> str:
parts = [f"Knowledge Graph (seeds: {', '.join(seed_ids)}):"]
for n in sub.get("nodes", [])[:15]:
parts.append(f" [{n.get('label','?')}] {n.get('id') or n.get('name') or '?'}")
edge_types = sorted({e.get("type", "") for e in sub.get("edges", [])})
if edge_types:
parts.append(f"Relationships: {', '.join(edge_types)}")
return "\n".join(parts)
_REACT_SYSTEM = (
"You are a CVE evidence-gathering agent. Your job: collect the best context for "
"the user query by calling tools strategically. Plan briefly then act.\n\n"
"Heuristics:\n"
"- ALWAYS call `search` first with the reformulated query and chosen collections.\n"
"- If the query or pre-extracted seeds contain a CVE-ID → also call `explore_kg` "
" with node_label='CVE'.\n"
"- If seeds contain a Product, CWE, Technique, Tactic, Vendor, or CAPEC ID → call "
" `explore_kg` with that node_label.\n"
"- If the user describes a SYMPTOM or BEHAVIOR (no CVE/CWE/product) → call "
" `translate_symptom` FIRST, then use returned keywords for `search` and returned "
" techniques/CWEs for `explore_kg`.\n"
"- For 'similar to CVE-X' queries → call `find_similar_cves`.\n"
"- Do NOT call `search_web` — it is reserved for automatic fallback only.\n"
"- Stop after at most 4 tool calls. Return a 1-sentence summary when done."
)
def make_retrieve(rag_system, graph_service, agent_tools=None, chat_model=None, cheat_sheet=None):
"""
Retrieve node: ReAct tool-calling loop (primary) with hardcoded-pipeline fallback.
When chat_model is available, uses LangGraph's create_react_agent with the
agent_tools toolbelt (search, explore_kg, find_similar_cves, translate_symptom,
search_web). Falls back to direct rag_system.search + KG auto-enrich if
chat_model is None or if the ReAct agent raises.
After the ReAct loop (or fallback), always runs post-loop KG auto-enrichment
on CVE IDs surfaced in retrieved docs.
"""
from langchain_core.messages import SystemMessage, HumanMessage, ToolMessage
def _legacy_retrieve(state: RAGState) -> dict:
"""Original hardcoded pipeline — kept as fallback."""
query = state.get("rewritten_query") or state.get("original_query", "")
collections = state.get("search_collections", ["cve"])
route = state.get("route_decision", "search")
k = AGENT_DEFAULT_K
retrieved_docs: list[dict] = []
kg_context = ""
kg_enriched = False
if route != "direct":
all_results: list[dict] = []
for col in collections:
try:
results = rag_system.search(query, n_results=k * 2, collection=col)
all_results.extend(results)
except Exception as e:
logger.warning("Search failed for %s: %s", col, e)
all_results.sort(key=lambda x: x.get("score", 0), reverse=True)
seen = set()
for r in all_results:
rid = r.get("id", "")
if rid not in seen:
seen.add(rid)
retrieved_docs.append(r)
retrieved_docs = retrieved_docs[:k]
if not retrieved_docs and route == "kg" and graph_service is not None:
cve_ids = _extract_cve_ids(query)
if cve_ids:
try:
sub = graph_service.subgraph_from_nodes(
[{"label": "CVE", "id": cve_ids[0]}], hops=1
)
nodes = sub.get("nodes", [])
if nodes:
kg_context = _render_subgraph(sub, [cve_ids[0]])
kg_enriched = True
retrieved_docs.append({
"id": cve_ids[0], "text": kg_context,
"metadata": {"source": "neo4j_knowledge_graph"}, "score": 1.0,
})
except Exception as e:
logger.warning("KG fallback failed: %s", e)
# KG auto-enrich from top docs
if graph_service is not None and retrieved_docs and not kg_context:
cve_ids_found = [
doc.get("metadata", {}).get("cve_id", "")
for doc in retrieved_docs[:3]
if doc.get("metadata", {}).get("cve_id")
]
if cve_ids_found:
try:
sub = graph_service.subgraph_from_nodes(
[{"label": "CVE", "id": cid} for cid in cve_ids_found], hops=1
)
if sub.get("nodes"):
kg_context = _render_subgraph(sub, cve_ids_found)
kg_enriched = True
except Exception as e:
logger.warning("KG auto-enrich failed: %s", e)
logger.info("Legacy retrieve: %d docs, kg_enriched=%s", len(retrieved_docs), kg_enriched)
return {"retrieved_docs": retrieved_docs, "kg_context": kg_context, "kg_enriched": kg_enriched}
def retrieve(state: RAGState) -> dict:
route = state.get("route_decision", "search")
if route == "direct":
return {"retrieved_docs": [], "kg_context": "", "kg_enriched": False}
if chat_model is None or not agent_tools:
return _legacy_retrieve(state)
query = state.get("rewritten_query") or state.get("original_query", "")
cols = state.get("search_collections", ["cve"])
seeds = state.get("kg_seeds") or []
filters = state.get("filters") or {}
hint_block = ""
if cheat_sheet is not None:
try:
hd = cheat_sheet.entity_to_hints(state.get("original_query", ""))
hint_block = cheat_sheet.render_hint_block(hd) or ""
except Exception:
pass
user_msg = (
f"Reformulated query: {query}\n"
f"Collections: {cols}\n"
f"Pre-extracted KG seeds: {seeds}\n"
f"Payload filters: {filters}\n"
f"Cheat-sheet hints: {hint_block or '(none)'}"
)
try:
from langgraph.prebuilt import create_react_agent
agent = create_react_agent(chat_model, tools=agent_tools)
result = agent.invoke(
{"messages": [SystemMessage(_REACT_SYSTEM), HumanMessage(user_msg)]},
config={"recursion_limit": 12},
)
except Exception as e:
logger.warning("ReAct retrieve failed: %s — falling back to legacy pipeline", e)
return _legacy_retrieve(state)
# ── Collect docs from ToolMessages ───────────────────────────────────
retrieved_docs: list[dict] = []
all_cve_ids: set[str] = set()
for m in result.get("messages", []):
if not isinstance(m, ToolMessage):
continue
text = str(m.content or "")
all_cve_ids.update(_extract_cve_ids(text))
tool_name = getattr(m, "name", "") or ""
if tool_name == "search":
retrieved_docs.extend(_parse_search_text(text))
elif tool_name in ("explore_kg", "find_similar_cves"):
if text.strip():
retrieved_docs.append({
"id": f"kg-{len(retrieved_docs)}",
"text": text,
"score": 0.6,
"metadata": {"source": "neo4j"},
})
elif tool_name == "translate_symptom":
pass # symptoms result is used by LLM for next tool calls, not a doc
elif tool_name == "search_web":
if text.strip():
retrieved_docs.append({
"id": f"web-{len(retrieved_docs)}",
"text": text,
"score": 0.5,
"metadata": {"source": "tavily"},
})
# ── Post-loop KG auto-enrichment ────────────────────────────────────
kg_context = ""
kg_enriched = False
if graph_service is not None and all_cve_ids:
try:
sub = graph_service.subgraph_from_nodes(
[{"label": "CVE", "id": cid} for cid in list(all_cve_ids)[:3]], hops=1
)
if sub.get("nodes"):
kg_context = _render_subgraph(sub, list(all_cve_ids)[:3])
kg_enriched = True
except Exception as e:
logger.warning("Post-ReAct KG enrich failed: %s", e)
retrieved_docs = retrieved_docs[:AGENT_DEFAULT_K]
logger.info(
"ReAct retrieve: %d docs, %d CVE IDs surfaced, kg_enriched=%s",
len(retrieved_docs), len(all_cve_ids), kg_enriched,
)
return {"retrieved_docs": retrieved_docs, "kg_context": kg_context, "kg_enriched": kg_enriched}
return retrieve
def make_web_fallback(web_search_tool=None):
"""Web fallback node: triggered at retry-max when all retrieval attempts returned 0 relevant docs."""
def web_fallback(state: RAGState) -> dict:
if web_search_tool is None:
logger.info("Web fallback: no web tool configured, skipping")
return {"web_fallback_used": False}
query = state.get("rewritten_query") or state.get("original_query", "")
try:
text = web_search_tool.invoke({"query": query})
text = str(text or "")
except Exception as e:
logger.warning("Web fallback invocation failed: %s", e)
return {"web_fallback_used": False}
existing = list(state.get("retrieved_docs") or [])
existing.append({
"id": "web-fallback",
"text": text,
"score": 0.5,
"metadata": {"source": "tavily"},
})
logger.info("Web fallback engaged: +1 web doc (%d chars)", len(text))
return {
"retrieved_docs": existing,
"web_fallback_used": True,
"_relevant_count": 1, # force graph to proceed to generate_answer
}
return web_fallback
def make_grade_documents(llm_client, reranker=None):
"""
Grader node: score retrieved docs for relevance and decide whether to retry.
Backend priority:
1. reranker — Jina Reranker v3 (fast, no tokens, reorders docs best-first)
2. llm — single batched LLM call (fallback when reranker is None)
3. pass-all — when both are unavailable (llm_client is also None)
"""
def grade_documents(state: RAGState) -> dict:
docs = state.get("retrieved_docs", [])
query = state.get("original_query", "")
retry_count = state.get("retry_count", 0)
if not docs:
logger.info("Grade: no docs → irrelevant")
return {"_relevant_count": 0, "retry_count": retry_count, "rewrite_reason": "irrelevant_docs"}
# ── Reranker path ────────────────────────────────────────────────────
if reranker is not None:
try:
scored_docs, relevant_count = reranker.grade(query, docs)
return {
"_relevant_count": relevant_count,
"retrieved_docs": scored_docs, # reranked: best docs first
"retry_count": retry_count,
"rewrite_reason": "irrelevant_docs" if relevant_count == 0 else "",
}
except Exception as e:
logger.warning("Reranker failed → LLM fallback: %s", e)
# ── LLM batch path ───────────────────────────────────────────────────
if llm_client is None:
return {"_relevant_count": max(1, len(docs)), "retry_count": retry_count, "rewrite_reason": ""}
batch = docs[:8]
snippets = [f"[{i + 1}] {d.get('text', '')[:500]}" for i, d in enumerate(batch)]
prompt = GRADE_BATCH_PROMPT.format(
question=query,
numbered_docs="\n\n".join(snippets),
)
try:
with traced_llm_call(
llm_client, prompt, "grade_batch",
trace_id=state.get("tracing_trace_id", ""),
system_prompt="Answer in JSON only.", max_tokens=400,
) as gen:
response = gen()
parsed = _parse_json_safely(response, {"grades": []})
relevant_count = sum(
1 for g in parsed.get("grades", [])
if g.get("binary_score", "no") == "yes"
)
except Exception as e:
logger.warning("Batch grade failed, defaulting all relevant: %s", e)
relevant_count = len(batch)
logger.info("Grade (LLM): %d/%d relevant", relevant_count, len(batch))
return {
"_relevant_count": relevant_count,
"retry_count": retry_count,
"rewrite_reason": "irrelevant_docs" if relevant_count == 0 else "",
}
return grade_documents
def make_generate_answer(llm_client, llm_runnable=None):
"""Generator node: synthesize answer from docs + KG + memory.
When llm_runnable is provided, streams tokens via BaseLLMRunnable so that
astream_events(version="v2") captures on_chain_stream events per token.
Falls back to llm_client.generate() (traced) when llm_runnable is None.
"""
from langchain_core.runnables.config import RunnableConfig
def generate_answer(state: RAGState, config: RunnableConfig = None) -> dict:
query = state.get("original_query", "")
docs = state.get("retrieved_docs", [])
kg_context = state.get("kg_context", "")
memory_context = state.get("memory_context", "")
if llm_client is None and llm_runnable is None:
top_cve = "N/A"
if docs:
top_cve = docs[0].get("metadata", {}).get("cve_id", "Unknown")
return {
"generation": f"Found {len(docs)} results. Top match: {top_cve}. LLM unavailable — raw search only.",
"messages": [AIMessage(content=f"Found {len(docs)} results. Top match: {top_cve}. LLM unavailable — raw search only.")],
}
if docs:
retrieved_text = "\n\n".join(
f"[{i+1}] {d.get('metadata', {}).get('cve_id', d.get('id', ''))}\n{d.get('text', '')[:600]}"
for i, d in enumerate(docs[:6])
)
prompt = GENERATE_PROMPT.format(
memory_context=memory_context or "(no past context)",
retrieved_context=retrieved_text,
kg_context=kg_context or "(no graph context)",
question=query,
)
else:
prompt = GENERATE_NO_CONTEXT.format(
memory_context=memory_context or "(no past context)",
question=query,
)
try:
if llm_runnable is not None:
# Stream via Runnable — each yielded token fires an on_chain_stream
# event that astream_events(version="v2") surfaces to the caller.
generation = ""
for token in llm_runnable.stream(prompt, config=config):
generation += token
else:
with traced_llm_call(llm_client, prompt, "generate",
trace_id=state.get("tracing_trace_id", ""),
max_tokens=800) as gen:
generation = gen()
logger.info("Generation: %d chars", len(generation))
return {"generation": generation, "messages": [AIMessage(content=generation)]}
except Exception as e:
logger.error("Generation failed: %s", e)
return {
"generation": f"Answer generation failed: {e}",
"messages": [AIMessage(content=f"Answer generation failed: {e}")],
}
return generate_answer
def make_self_reflect(llm_client):
"""Reflection node: hallucination check + completeness check → verdict."""
def self_reflect(state: RAGState) -> dict:
generation = state.get("generation", "")
docs = state.get("retrieved_docs", [])
query = state.get("original_query", "")
retry_count = state.get("retry_count", 0)
reflection = {
"verdict": "pass",
"hallucination": True,
"completeness": True,
"hallucination_score": 1.0,
"completeness_score": 1.0,
"unsupported_claims": [],
"missing_aspects": [],
}
if llm_client is None or not generation or not docs:
return {"reflection": reflection, "retry_count": retry_count}
context_text = "\n\n".join(d.get("text", "")[:400] for d in docs[:4])
# ── Hallucination check ──
try:
h_prompt = REFLECT_HALLUCINATION_PROMPT.format(context=context_text, generation=generation)
with traced_llm_call(
llm_client, h_prompt, "reflect_hallucination",
trace_id=state.get("tracing_trace_id", ""),
system_prompt="Answer in JSON only.", max_tokens=600,
) as gen:
h_response = gen()
h_parsed = _parse_json_safely(h_response, {"is_grounded": "yes", "unsupported_claims": [], "score": 1.0})
if not isinstance(h_parsed, dict):
h_parsed = {"is_grounded": "yes", "unsupported_claims": [], "score": 1.0}
grounded = h_parsed.get("is_grounded", "yes") == "yes"
reflection["hallucination"] = grounded
reflection["hallucination_score"] = h_parsed.get("score", 1.0 if grounded else 0.0)
reflection["unsupported_claims"] = h_parsed.get("unsupported_claims", [])
logger.info("Reflect hallucination: %s score=%.2f", "PASS" if grounded else "FAIL", reflection["hallucination_score"])
except Exception as e:
logger.warning("Hallucination check failed: %s", e)
# ── Completeness check ──
try:
c_prompt = REFLECT_COMPLETENESS_PROMPT.format(question=query, generation=generation)
with traced_llm_call(
llm_client, c_prompt, "reflect_completeness",
trace_id=state.get("tracing_trace_id", ""),
system_prompt="Answer in JSON only.", max_tokens=400,
) as gen:
c_response = gen()
c_parsed = _parse_json_safely(c_response, {"is_complete": "yes", "missing_aspects": [], "score": 1.0})
if not isinstance(c_parsed, dict):
c_parsed = {"is_complete": "yes", "missing_aspects": [], "score": 1.0}
complete = c_parsed.get("is_complete", "yes") == "yes"
reflection["completeness"] = complete
reflection["completeness_score"] = c_parsed.get("score", 1.0 if complete else 0.0)
reflection["missing_aspects"] = c_parsed.get("missing_aspects", [])
logger.info("Reflect completeness: %s score=%.2f", "PASS" if complete else "FAIL", reflection["completeness_score"])
except Exception as e:
logger.warning("Completeness check failed: %s", e)
# ── Determine verdict and rewrite_reason ──
overall_pass = reflection["hallucination"] and reflection["completeness"]
reflection["verdict"] = "pass" if overall_pass else "fail"
rewrite_reason = ""
if not reflection["hallucination"]:
rewrite_reason = "hallucination"
elif not reflection["completeness"]:
rewrite_reason = "incomplete"
return {"reflection": reflection, "retry_count": retry_count, "rewrite_reason": rewrite_reason}
return self_reflect
def make_memory_store(memory):
"""Post-hook: save interaction to Mem0 for future recall."""
def memory_store(state: RAGState) -> dict:
query = state.get("original_query", "")
generation = state.get("generation", "")
user_id = state.get("mem0_user_id", "default_session")
if memory is not None and generation:
try:
memory.save(query, generation, user_id)
logger.info("Memory stored for user=%s", user_id)
except Exception as e:
logger.warning("Memory store failed: %s", e)
return {}
return memory_store
# ─────────────────────────────────────────────────────────────────────────────
# Conditional edge logic
# ─────────────────────────────────────────────────────────────────────────────
def _route_after_classify(state: RAGState) -> Literal["rewrite_query", "generate_answer"]:
if state.get("route_decision", "search") == "direct":
return "generate_answer"
return "rewrite_query"
def _route_after_grade(state: RAGState) -> Literal["generate_answer", "rewrite_query", "web_fallback"]:
from src.agents.agent_config import WEB_SEARCH_ENABLED
relevant = state.get("_relevant_count", 0)
retry = state.get("retry_count", 0)
if relevant > 0:
return "generate_answer"
if retry < AGENT_MAX_RETRIES:
return "rewrite_query"
if WEB_SEARCH_ENABLED and not state.get("web_fallback_used", False):
return "web_fallback"
return "generate_answer"
def _route_after_reflect(state: RAGState) -> Literal["memory_store", "rewrite_query"]:
reflection = state.get("reflection", {})
retry = state.get("retry_count", 0)
if reflection.get("verdict", "pass") == "pass":
return "memory_store"
if retry < AGENT_MAX_RETRIES:
return "rewrite_query"
return "memory_store"
def _increment_retry(state: RAGState) -> dict:
return {"retry_count": state.get("retry_count", 0) + 1}
# ─────────────────────────────────────────────────────────────────────────────
# Graph compilation
# ─────────────────────────────────────────────────────────────────────────────
def compile_agent_graph(
llm_client: Any,
rag_system: Any,
graph_service: Any = None,
memory: Any = None,
llm_runnable: Any = None,
reranker: Any = None,
cheat_sheet: Any = None,
agent_tools: list = None,
chat_model: Any = None,
) -> StateGraph:
"""
Build and compile the full agent graph (10 nodes).
Nodes: memory_retrieve, route_query, rewrite_query, retrieve,
grade_documents, web_fallback, generate_answer, self_reflect,
memory_store, rewrite_retry (incrementer)
Returns compiled LangGraph StateGraph ready for .stream() or .invoke().
"""
# Extract search_web tool from agent_tools for the web_fallback node
web_search_tool = next(
(t for t in (agent_tools or []) if getattr(t, "name", "") == "search_web"),
None,
)
workflow = StateGraph(RAGState)
workflow.add_node("memory_retrieve", make_memory_retrieve(memory))
workflow.add_node("route_query", make_route_query(llm_client))
workflow.add_node("rewrite_query", make_rewrite_query(llm_client, cheat_sheet))
workflow.add_node("rewrite_retry", _increment_retry)
workflow.add_node("retrieve", make_retrieve(rag_system, graph_service, agent_tools, chat_model, cheat_sheet))
workflow.add_node("grade_documents", make_grade_documents(llm_client, reranker))
workflow.add_node("web_fallback", make_web_fallback(web_search_tool))
workflow.add_node("generate_answer", make_generate_answer(llm_client, llm_runnable))
workflow.add_node("self_reflect", make_self_reflect(llm_client))
workflow.add_node("memory_store", make_memory_store(memory))
workflow.add_edge(START, "memory_retrieve")
workflow.add_edge("memory_retrieve", "route_query")
workflow.add_conditional_edges(
"route_query", _route_after_classify,
{"rewrite_query": "rewrite_query", "generate_answer": "generate_answer"},
)
workflow.add_edge("rewrite_query", "retrieve")
workflow.add_edge("retrieve", "grade_documents")
workflow.add_conditional_edges(
"grade_documents", _route_after_grade,
{
"generate_answer": "generate_answer",
"rewrite_query": "rewrite_retry",
"web_fallback": "web_fallback",
},
)
workflow.add_edge("rewrite_retry", "rewrite_query")
workflow.add_edge("web_fallback", "generate_answer")
workflow.add_edge("generate_answer", "self_reflect")
workflow.add_conditional_edges(
"self_reflect", _route_after_reflect,
{"memory_store": "memory_store", "rewrite_query": "rewrite_retry"},
)
workflow.add_edge("memory_store", END)
checkpointer = MemorySaver()
graph = workflow.compile(checkpointer=checkpointer)
grading = f"reranker(backend={reranker.backend})" if reranker else "llm"
react = "react" if (chat_model is not None and agent_tools) else "legacy"
logger.info(
"Agent graph compiled ✓ 10 nodes max_retries=%d grading=%s retrieve=%s",
AGENT_MAX_RETRIES, grading, react,
)
return graph