Upload 6 files

app/graph/nodes/evaluator.py

@@ -0,0 +1,43 @@
+# app/graph/nodes/evaluator.py
+from app.core.llm_engine import llm
+from app.core.prompts.evaluator_prompt import evaluator_prompt
+from langchain_core.output_parsers import StrOutputParser
+import json
+
+chain = evaluator_prompt | llm | StrOutputParser()
+
+
+def evaluator_node(state):
+    query = state.get("query")
+    answer = state.get("final_answer")
+    context = state.get("context", "")
+
+    try:
+        response = chain.invoke({
+                "query": query,
+                "answer": answer,
+                "context": context
+            })
+
+        # 🔥 clean response (important)
+        response = response.strip()
+
+        # sometimes model adds ```json
+        if response.startswith("```"):
+            response = response.replace("```json", "").replace("```", "").strip()
+
+        evaluation = json.loads(response)
+
+    except Exception as e:
+        print("EVALUATOR ERROR →", e)
+
+        evaluation = {
+            "relevance_score": 0.5,
+            "context_usage": 0.5,
+            "hallucination": True
+        }
+
+    return {
+        **state,
+        "evaluation": evaluation
+    }

app/graph/nodes/general_agent.py

@@ -0,0 +1,48 @@
+from app.core.llm_engine import llm
+from langchain_core.output_parsers import StrOutputParser
+from app.core.prompts.general_prompt import general_prompt
+
+# general_prompt= PromptTemplate(
+#     input_variables= ["query"],
+#     template= (
+#         "Answer clearly and concisely.\n"
+#         "Do NOT rely on any external document.\n"
+#         "Avoid long explanations.\n"
+#         "Use bullet points if helpful.\n"
+#         "Max 150 words.\n\n"
+#         "Question:\n{query}\n\n"
+#         "Answer:"        
+#     )
+# )
+
+# def general_agent_node(state):
+#     query = state.get("query")
+
+#     prompt = f"""
+#     Answer the following question directly.
+
+#     Question: {query}
+
+#     Do NOT rely on any external document.
+#     Answer clearly and accurately.
+#     """
+
+#     response = llm.invoke(prompt)
+
+#     return {
+#         **state,
+#         "general_answer": response.content
+#     }
+    
+
+def general_agent_node(state):
+    query = state.get("query")
+
+    chain = general_prompt | llm | StrOutputParser()
+    response = chain.invoke({"query": query})
+
+    return {
+        **state,
+        "general_answer": response.strip()
+    }
+    

app/graph/nodes/rag_agent.py

@@ -0,0 +1,41 @@
+# # app/graph/rag_agent.py
+# from app.core.rag_service import get_rag_context
+
+# def rag_agent_node(state):
+
+#     print("DEBUG → state received:", state)
+
+#     query= state["query"]
+#     doc_id= state["doc_id"]
+#     print("DEBUG → query:", query)
+#     print("DEBUG → doc_id:", doc_id)
+
+#     context, sources= get_rag_context(query, doc_id)
+#     print("DEBUG → context:", context[:200] if context else "EMPTY")
+
+#     return { 
+#         **state,
+#         "context": context,
+#         "sources": sources
+#     }
+
+
+
+
+def rag_agent_node(state):
+
+    print("DEBUG → state received:", state)
+
+    # ✅ context already comes from router now
+    context = state.get("context")
+    sources = state.get("sources")
+
+    print("DEBUG → context:", context[:200] if context else "EMPTY")
+
+    return {
+        **state,
+        "context": context,
+        "sources": sources
+    }
+
+

app/graph/nodes/rag_answer_node.py

@@ -0,0 +1,64 @@
+# # app/graph/rag_answer_node.py
+
+# from langchain_core.prompts import PromptTemplate
+# from app.core.llm_engine import run_llm
+# from app.core.prompts.rag_prompt import rag_prompt
+# # rag_prompt = PromptTemplate(
+# #     input_variables=["context", "query"],
+# #     template=(
+# #         "You are a document intelligence system.\n"
+# #         "Answer ONLY using the provided context.\n"
+# #         "If answer is not present, say: 'Not in document'.\n\n"
+
+# #         "Keep response concise:\n"
+# #         "- Short explanation\n"
+# #         "- Bullet points if useful\n"
+# #         "- Max 120 words\n\n"
+
+# #         "Avoid repeating the question.\n\n"
+
+# #         "Context:\n{context}\n\n"
+# #         "Question:\n{query}\n\n"
+# #         "Answer:"
+# #     )
+# # )
+ 
+# def rag_answer_node(state):
+#     response = run_llm(rag_prompt, {
+#         "context": state.get("context", ""),
+#         "query": state.get("query")
+#     })
+
+#     return {
+#         **state,
+#         "final_answer": response
+#     }
+
+
+
+
+
+
+
+
+
+
+
+
+from app.core.llm_engine import llm
+from app.core.prompts.rag_prompt import rag_prompt
+from langchain_core.output_parsers import StrOutputParser
+
+chain = rag_prompt | llm | StrOutputParser()
+
+
+def rag_answer_node(state):
+    response = chain.invoke({
+        "context": state.get("context", ""),
+        "query": state.get("query")
+    })
+
+    return {
+        **state,
+        "final_answer": response
+    }

app/graph/nodes/router.py

@@ -0,0 +1,52 @@
+# app/graph/nodes/router.py
+
+from app.core.rag_service import get_rag_context
+
+
+def router_node(state):
+    query = state.get("query")
+    doc_id = state.get("doc_id")
+
+    # 🔥 Step 1: Try retrieving context
+    context, sources, scores = get_rag_context(query, doc_id)
+    print("ROUTER DEBUG → scores:", scores)
+
+    # print("ROUTER DEBUG → context:", context[:100] if context else "EMPTY")
+
+    # # 🔥 Step 2: Decide route based on context presence
+    # if context and len(context.strip()) > 50:
+    #     route = "rag"
+    # else:
+    #     route = "general"
+
+    # print("ROUTER DECISION →", route)
+
+    # return {
+    #     **state,
+    #     "route": route,
+    #     "context": context,   # ✅ pass forward (important)
+    #     "sources": sources
+    # }
+
+
+     # 🔥 Step 1: get best score
+    max_score = max(scores) if scores else 0
+
+    # 🔥 Step 2: threshold decision
+    THRESHOLD = 0.75   # 👈 tune this
+
+    if max_score >= THRESHOLD:
+        route = "rag"
+    else:
+        route = "general"
+        context = ""   # ❗ important: clear bad context
+
+    print("ROUTER DECISION →", route, "| score:", max_score)
+
+    return {
+        **state,
+        "route": route,
+        "context": context,
+        "sources": sources,
+        "score": max_score
+    }

app/graph/nodes/synthesizer.py

@@ -0,0 +1,38 @@
+from app.core.llm_engine import llm
+from app.core.prompts.rag_prompt import rag_prompt
+from langchain_core.output_parsers import StrOutputParser
+
+def synthesizer_node(state):
+    query= state["query"]
+    context= state.get("context", "")
+    history= state.get("histroy", "")
+
+    general_answer = state.get("general_answer")
+
+    # If general route, skip RAG context
+    if state.get("route") == "general":
+        return {
+            **state,
+            "final_answer": general_answer or "No answer generated."
+        }
+
+    full_context= f"""
+    Conversation History: 
+    {history}
+
+    Retrieved Context: 
+    {context}
+    """
+    
+   
+
+    chain = rag_prompt | llm | StrOutputParser()
+    answer = chain.invoke({
+        "context": full_context,
+        "query": query
+    })
+    
+    return {
+        **state,
+        "final_answer": answer.strip()
+    }