Update app/api/routes.py

app/api/routes.py

@@ -1,5 +1,239 @@
-# app/api/routes.py
+# # app/api/routes.py
+
+# from fastapi import APIRouter, UploadFile, Form, HTTPException
+# from fastapi.responses import StreamingResponse
+# import uuid, os, json, asyncio
+# from collections import defaultdict
+# from bson import ObjectId
+
+# from app.core.pdf_processor import extract_text_from_pdf
+# from app.core.embedding_engine import embed_and_store, embedder, qdrant, COLLECTION_NAME
+# from qdrant_client.http.models import Filter, FieldCondition, MatchValue
+# from app.core.llm_engine import ask_gemini
+# from app.core.mongo import conversations
+# from qdrant_client import QdrantClient
+# from app.core.config import QDRANT_URL, QDRANT_API_KEY
+
+# router = APIRouter()
+# UPLOAD_DIR = "uploads"
+# os.makedirs(UPLOAD_DIR, exist_ok=True)
+
+# # Qdrant Client
+# qdrant_client = QdrantClient(
+#     url=QDRANT_URL,
+#     api_key=QDRANT_API_KEY,
+#     check_compatibility=False)
+
+# # In-memory (for fallback)
+# chat_histories = defaultdict(list)
+
+
+# # ---------------------------------------------------
+# # ✅ Upload endpoint
+# # ---------------------------------------------------
+# @router.post("/upload")
+# async def upload_pdf(file: UploadFile):
+#     doc_id = str(uuid.uuid4())
+#     file_path = os.path.join(UPLOAD_DIR, f"{doc_id}.pdf")
+
+#     with open(file_path, "wb") as f:
+#         f.write(await file.read())
+
+#     text = extract_text_from_pdf(file_path)
+#     chunks = [text[i:i + 1000] for i in range(0, len(text), 1000)]
+#     embed_and_store(chunks, doc_id)
+
+#     # ✅ Create MongoDB record
+#     conversations.insert_one({
+#         "doc_id": doc_id,
+#         "name": file.filename,
+#         "file_path": file_path,
+#         "qdrant_collection": COLLECTION_NAME,
+#         "history": [],
+#         "created_at": asyncio.get_event_loop().time(),
+#     })
+
+#     return {"doc_id": doc_id, "message": "PDF uploaded and processed successfully."}
+
+
+# # ---------------------------------------------------
+# # ✅ Streaming Upload endpoint (with Mongo insert)
+# # ---------------------------------------------------
+# @router.post("/upload-stream")
+# async def upload_stream(file: UploadFile):
+#     doc_id = str(uuid.uuid4())
+#     file_path = os.path.join(UPLOAD_DIR, f"{doc_id}.pdf")
+
+#     with open(file_path, "wb") as f:
+#         content = await file.read()
+#         f.write(content)
+
+#     async def generate_upload_events():
+#         try:
+#             yield f"data: {json.dumps({'status': '✅ File uploaded successfully. Starting processing...'})}\n\n"
+#             await asyncio.sleep(0.5)
+
+#             yield f"data: {json.dumps({'status': '📄 Extracting text from PDF...'})}\n\n"
+#             text = extract_text_from_pdf(file_path)
+#             await asyncio.sleep(0.5)
+
+#             yield f"data: {json.dumps({'status': '🧠 Generating embeddings...'})}\n\n"
+#             chunks = [text[i:i + 1000] for i in range(0, len(text), 1000)]
+#             await asyncio.sleep(0.5)
+
+#             yield f"data: {json.dumps({'status': '💾 Storing vectors into database...'})}\n\n"
+#             embed_and_store(chunks, doc_id)
+#             await asyncio.sleep(0.5)
+
+#             # ✅ Save chat info to MongoDB
+#             conversations.insert_one({
+#                 "doc_id": doc_id,
+#                 "name": file.filename,
+#                 "file_path": file_path,
+#                 "qdrant_collection": COLLECTION_NAME,
+#                 "history": [],
+#                 "created_at": asyncio.get_event_loop().time(),
+#             })
+
+#             yield f"data: {json.dumps({'status': '🎉 Done! You’re good to go.', 'doc_id': doc_id})}\n\n"
+#             yield "event: end\ndata: {}\n\n"
+
+#         except Exception as e:
+#             yield f"data: {json.dumps({'status': f'⚠️ Error: {str(e)}'})}\n\n"
+#             yield "event: end\ndata: {}\n\n"
+
+#     return StreamingResponse(generate_upload_events(), media_type="text/event-stream")
+
+
+# # ---------------------------------------------------
+# # ✅ Fetch All Chats (for Sidebar)
+# # ---------------------------------------------------
+# @router.get("/chats")
+# async def get_all_chats():
+#     try:
+#         chats = list(conversations.find({}, {"_id": 1, "name": 1, "doc_id": 1}))
+#         for c in chats:
+#             c["_id"] = str(c["_id"])
+#         return {"chats": chats}
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+
+
+# # ---------------------------------------------------
+# # ✅ Delete Chat (Qdrant + Mongo + File)
+# # ---------------------------------------------------
+# @router.delete("/chat/{chat_id}")
+# async def delete_chat(chat_id: str):
+#     try:
+#         chat = conversations.find_one({"_id": ObjectId(chat_id)})
+#         if not chat:
+#             raise HTTPException(status_code=404, detail="Chat not found")
+
+#         doc_id = chat.get("doc_id")
+
+#         # ✅ Delete embeddings from Qdrant
+#         try:
+#             qdrant.delete(
+#                 collection_name=COLLECTION_NAME,
+#                 points_selector=Filter(
+#                     must=[FieldCondition(key="doc_id", match=MatchValue(value=doc_id))]
+#                 ),
+#             )
+#         except Exception as e:
+#             print(f"⚠️ Qdrant delete failed: {e}")
+
+#         # ✅ Delete uploaded PDF file
+#         file_path = chat.get("file_path") or os.path.join("uploads", f"{doc_id}.pdf")
+#         if os.path.exists(file_path):
+#             os.remove(file_path)
+
+#         # ✅ Delete from MongoDB
+#         conversations.delete_one({"_id": ObjectId(chat_id)})
+
+#         return {"status": "success", "message": "Chat and embeddings deleted successfully"}
+
+#     except Exception as e:
+#         raise HTTPException(status_code=500, detail=str(e))
+
+
+
+# # ---------------------------------------------------
+# # ✅ Chat Query Endpoint (Persistent Memory)
+# # ---------------------------------------------------
+# @router.post("/query")
+# async def query_pdf(doc_id: str = Form(...), question: str = Form(...)):
+#     # ✅ Save user message
+#     conversations.update_one(
+#         {"doc_id": doc_id},
+#         {"$push": {"history": {"role": "user", "content": question}}},
+#         upsert=True
+#     )
+
+#     # ✅ Retrieve history
+#     doc = conversations.find_one({"doc_id": doc_id})
+#     history_list = doc["history"][-10:] if doc and "history" in doc else []
+
+#     structured_history = "\n".join(
+#         [f"{h['role'].title()}: {h['content']}" for h in history_list]
+#     )
+
+#     # ✅ Vector Search
+#     question_vector = embedder.encode([question])[0].tolist()
+    
+#     hits = qdrant_client.query_points(
+#         collection_name=COLLECTION_NAME,
+#         query=question_vector,
+#         query_filter=Filter(
+#             must=[FieldCondition(key="doc_id", match=MatchValue(value=doc_id))]
+#         ),
+#         limit=5,
+#     ).points
+
+
+#     context = "\n".join([hit.payload["text"] for hit in hits])
+#     full_context = f"{structured_history}\n\n{context}"
+
+#     # ✅ LLM Response
+#     answer = ask_gemini(full_context, question)
+
+#     # ✅ Save assistant response
+#     conversations.update_one(
+#         {"doc_id": doc_id},
+#         {"$push": {"history": {"role": "assistant", "content": answer}}},
+#         upsert=True
+#     )
+
+#     return {
+#         "answer": answer,
+#         "context_used": context,
+#         "history_count": len(history_list)
+#     }
+
+
+# @router.get("/conversations/{doc_id}")
+# async def get_conversation(doc_id: str):
+#     doc = conversations.find_one({"doc_id": doc_id})
+#     if not doc:
+#         return {"history": []}
+#     return {"history": doc.get("history", [])}
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 
+
+
+# app/api/routes.py
 from fastapi import APIRouter, UploadFile, Form, HTTPException
 from fastapi.responses import StreamingResponse
 import uuid, os, json, asyncio
@@ -9,11 +243,13 @@ from bson import ObjectId
 from app.core.pdf_processor import extract_text_from_pdf
 from app.core.embedding_engine import embed_and_store, embedder, qdrant, COLLECTION_NAME
 from qdrant_client.http.models import Filter, FieldCondition, MatchValue
-from app.core.llm_engine import ask_gemini
+# from app.core.llm_engine import ask_gemini
 from app.core.mongo import conversations
 from qdrant_client import QdrantClient
 from app.core.config import QDRANT_URL, QDRANT_API_KEY
 
+from app.graph.graph_builder import build_graph
+
 router = APIRouter()
 UPLOAD_DIR = "uploads"
 os.makedirs(UPLOAD_DIR, exist_ok=True)
@@ -162,6 +398,12 @@ async def delete_chat(chat_id: str):
 # ---------------------------------------------------
 @router.post("/query")
 async def query_pdf(doc_id: str = Form(...), question: str = Form(...)):
+
+    print("API DEBUG → doc_id:", doc_id)
+    print("API DEBUG → question:", question)
+
+
+
     # ✅ Save user message
     conversations.update_one(
         {"doc_id": doc_id},
@@ -178,23 +420,61 @@ async def query_pdf(doc_id: str = Form(...), question: str = Form(...)):
     )
 
     # ✅ Vector Search
-    question_vector = embedder.encode([question])[0].tolist()
+    # question_vector = embedder.encode([question])[0].tolist()
     
-    hits = qdrant_client.query_points(
-        collection_name=COLLECTION_NAME,
-        query=question_vector,
-        query_filter=Filter(
-            must=[FieldCondition(key="doc_id", match=MatchValue(value=doc_id))]
-        ),
-        limit=5,
-    ).points
+    # hits = qdrant_client.query_points(
+    #     collection_name=COLLECTION_NAME,
+    #     query=question_vector,
+    #     query_filter=Filter(
+    #         must=[FieldCondition(key="doc_id", match=MatchValue(value=doc_id))]
+    #     ),
+    #     limit=5,
+    # ).points
+
 
+    # context = "\n".join([hit.payload["text"] for hit in hits])
+    # full_context = f"{structured_history}\n\n{context}"
+
+    # # ✅ LLM Response
+    # answer = ask_gemini(full_context, question)
+
+    graph= build_graph()
+    
+    print("FINAL → sending to graph:", {
+    "query": question,
+    "doc_id": doc_id
+})
+
+    # Run LangGraph
+    # result = graph.invoke({
+    #     "query": question,
+    #     "doc_id": doc_id
+    # })
+
+
+
+    initial_state = {
+        "query": str(question),
+        "doc_id": str(doc_id),
+        "history": structured_history,
+        "route": None,
+        "context": None,
+        "final_answer": None
+    }
+
+    print("FINAL STATE →", initial_state)
+
+    result = graph.invoke(initial_state)
+
+
+
+
+    answer = result["final_answer"]
+    context = result.get("context", "")
+
+# ------------
 
-    context = "\n".join([hit.payload["text"] for hit in hits])
-    full_context = f"{structured_history}\n\n{context}"
 
-    # ✅ LLM Response
-    answer = ask_gemini(full_context, question)
 
     # ✅ Save assistant response
     conversations.update_one(
@@ -202,17 +482,21 @@ async def query_pdf(doc_id: str = Form(...), question: str = Form(...)):
         {"$push": {"history": {"role": "assistant", "content": answer}}},
         upsert=True
     )
-
+    print("EVALUATION →", result.get("evaluation"))
     return {
         "answer": answer,
-        "context_used": context,
+        # "context_used": context,
+        "sources": result.get("sources", []),
+        "evaluation": result.get("evaluation", []),
         "history_count": len(history_list)
     }
 
 
+
 @router.get("/conversations/{doc_id}")
 async def get_conversation(doc_id: str):
     doc = conversations.find_one({"doc_id": doc_id})
     if not doc:
         return {"history": []}
-    return {"history": doc.get("history", [])}
+    return {"history": doc.get("history", [])}
+