""" LangGraph node functions for the Agentic RAG pipeline. Each node receives AgentState and returns a partial state update. """ import json import logging from langchain_core.documents import Document from langchain_core.messages import HumanMessage, AIMessage, SystemMessage from langchain_openai import ChatOpenAI from app.agent.state import AgentState from app.agent.prompts import ( SYSTEM_PROMPT, INTENT_CLASSIFICATION_PROMPT, RELEVANCE_GRADING_PROMPT, HALLUCINATION_CHECK_PROMPT, QUERY_REWRITE_PROMPT, GENERATION_PROMPT, ) from app.retrieval.retriever import retrieve_and_rerank, format_sources from app.config import settings logger = logging.getLogger(__name__) def _get_llm(temperature: float = 0.0) -> ChatOpenAI: return ChatOpenAI( model=settings.llm_model, api_key=settings.openai_api_key, base_url=settings.openai_api_base, temperature=temperature, default_headers={ "HTTP-Referer": "https://acpc.gujarat.gov.in", "X-Title": "ACPC Chatbot", }, ) def classify_intent(state: AgentState) -> dict: """Node: Classify whether the query is ACPC-related, off-topic, or injection.""" query = state["query"] llm = _get_llm(temperature=0.0) prompt = INTENT_CLASSIFICATION_PROMPT.format(query=query) response = llm.invoke([HumanMessage(content=prompt)]) classification = response.content.strip().upper() if classification not in ("ACPC_RELATED", "OFF_TOPIC", "INJECTION"): # Default to ACPC_RELATED if response is unexpected classification = "ACPC_RELATED" logger.info("Intent classification: %s for query: %s", classification, query[:80]) if classification in ("OFF_TOPIC", "INJECTION"): return {"route": "fallback"} return {"route": "retrieve"} def retrieve(state: AgentState) -> dict: """Node: Retrieve documents from Qdrant using hybrid search + Cohere rerank.""" query = state["query"] logger.info("Retrieving documents for query: %s", query[:80]) documents = retrieve_and_rerank(query) logger.info("Retrieved %d documents", len(documents)) return {"retrieved_documents": documents} def grade_documents(state: AgentState) -> dict: """Node: Grade each retrieved document for relevance to the query.""" query = state["query"] documents = state["retrieved_documents"] if not documents: return {"relevant_documents": [], "confidence": 0.0} llm = _get_llm(temperature=0.0) relevant = [] for doc in documents: prompt = RELEVANCE_GRADING_PROMPT.format( document=doc.page_content[:1000], question=query, ) try: response = llm.invoke([HumanMessage(content=prompt)]) result = json.loads(response.content.strip()) if result.get("relevant") == "yes": relevant.append(doc) except (json.JSONDecodeError, Exception) as e: logger.warning("Grading error for doc: %s", e) # On error, include the document (fail open for retrieval) relevant.append(doc) confidence = len(relevant) / len(documents) if documents else 0.0 logger.info("Grading complete: %d/%d relevant (confidence=%.2f)", len(relevant), len(documents), confidence) return {"relevant_documents": relevant, "confidence": confidence} def rewrite_query(state: AgentState) -> dict: """Node: Rewrite the query for better retrieval and increment retry count.""" original_query = state["query"] llm = _get_llm(temperature=0.3) prompt = QUERY_REWRITE_PROMPT.format(query=original_query) response = llm.invoke([HumanMessage(content=prompt)]) rewritten = response.content.strip() retry_count = state.get("retry_count", 0) + 1 logger.info("Query rewritten (retry %d): '%s' -> '%s'", retry_count, original_query[:60], rewritten[:60]) return {"query": rewritten, "retry_count": retry_count} def generate(state: AgentState) -> dict: """Node: Generate an answer from relevant documents using gpt-4o.""" query = state["query"] relevant_docs = state["relevant_documents"] history = state.get("messages", []) # Build context string from relevant documents context_parts = [] for i, doc in enumerate(relevant_docs): meta = doc.metadata or {} url = meta.get("url", "") source_line = f"[Source {i+1}: {meta.get('file_name', 'unknown')}]" if url: source_line += f" {url}" context_parts.append(f"{source_line}\n{doc.page_content}") context = "\n\n---\n\n".join(context_parts) generation_content = GENERATION_PROMPT.format(context=context, question=query) # Build messages: system + trimmed history + current generation prompt messages = [SystemMessage(content=SYSTEM_PROMPT)] # Add conversation history (excluding the current user message, already in query) for msg in history[:-1]: # Skip last (current user message) messages.append(msg) messages.append(HumanMessage(content=generation_content)) llm = _get_llm(temperature=0.1) response = llm.invoke(messages) generation = response.content.strip() sources = format_sources(relevant_docs) logger.info("Generation complete (%d chars, %d sources)", len(generation), len(sources)) return {"generation": generation, "sources": sources} def check_hallucination(state: AgentState) -> dict: """Node: Verify that the generated answer is grounded in the retrieved context.""" generation = state["generation"] relevant_docs = state["relevant_documents"] context = "\n\n".join(doc.page_content[:800] for doc in relevant_docs) prompt = HALLUCINATION_CHECK_PROMPT.format(documents=context, answer=generation) llm = _get_llm(temperature=0.0) try: response = llm.invoke([HumanMessage(content=prompt)]) result = json.loads(response.content.strip()) is_grounded = result.get("grounded", True) except (json.JSONDecodeError, Exception) as e: logger.warning("Hallucination check error: %s — defaulting to grounded=True", e) is_grounded = True if is_grounded: logger.info("Hallucination check passed") return {"route": "grounded"} else: logger.warning("Hallucination check FAILED — routing to fallback") return {"route": "not_grounded"} def fallback(state: AgentState) -> dict: """Node: Return the hardcoded fallback response (never LLM-generated).""" return { "generation": settings.fallback_response, "sources": [], "confidence": 0.0, } def respond(state: AgentState) -> dict: """Terminal node: Package the final response into messages.""" generation = state.get("generation", settings.fallback_response) return {"messages": [AIMessage(content=generation)]} # ---- Edge condition functions ---- def route_after_classify(state: AgentState) -> str: return state.get("route", "retrieve") def route_after_grade(state: AgentState) -> str: relevant = state.get("relevant_documents", []) retry_count = state.get("retry_count", 0) confidence = state.get("confidence", 0.0) if relevant and confidence >= settings.confidence_threshold: return "generate" elif retry_count < settings.max_retrieval_retries: return "rewrite" else: return "fallback" def route_after_hallucination(state: AgentState) -> str: return "respond" if state.get("route") == "grounded" else "fallback"