Final Changes

app.py

@@ -33,7 +33,7 @@ with st.sidebar:
                 # Send the POST request to your local FastAPI server
                 try:
                     response = requests.post(
-                        "http://127.0.0.1:8000", 
+                        "http://127.0.0.1:8000/upload", 
                         files=files,
                         data=payload_data
                     )
@@ -74,7 +74,7 @@ if prompt := st.chat_input("Ask a question about your documents..."):
         
         try:
             # Send the question to your LangGraph backend
-            chat_response = requests.post("http://127.0.0.1:8000", json=payload)
+            chat_response = requests.post("http://127.0.0.1:8000/chat", json=payload)
             
             if chat_response.status_code == 200:
                 # Extract the answer from the JSON response

src/embedding.py

@@ -1,92 +1,192 @@
 from src.ingestion import ingestion_and_chunking
+
 from qdrant_client import QdrantClient
+
 from qdrant_client.models import Distance, VectorParams, SparseVectorParams, PointStruct
-from fastembed import SparseTextEmbedding
+
+from fastembed import TextEmbedding, SparseTextEmbedding
+
 import uuid
+
 from dotenv import load_dotenv
+
 import os
-from langchain_community.embeddings import HuggingFaceInferenceAPIEmbeddings
+
+
 
 load_dotenv()
+
 qdrant_api_key = os.getenv("QDRANT_API_KEY")
+
 qdrant_url = os.getenv("QDRANT_URL")
-hf_token = os.getenv("HF_TOKEN")
 
-def upload_file(file_path: str, user_id: str, collection_name="pdf_rag_chat"):
+
+
+def upload_file(file_path: str, user_id: str, collection_name="pdf_rag"):
+
+
 
     client = QdrantClient(url=qdrant_url, api_key=qdrant_api_key)
 
-    dense_model = HuggingFaceInferenceAPIEmbeddings(
-        api_key=hf_token,
-        model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+
+    dense_model = TextEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
     sparse_model = SparseTextEmbedding(model_name="Qdrant/bm25")
 
+
+
     # 1. ONLY the database creation should be inside this IF block
+
     if not client.collection_exists(collection_name):
+
         client.create_collection(
+
             collection_name=collection_name,
+
             vectors_config={
+
                 "dense": VectorParams(size=384, distance=Distance.COSINE)
+
             },
+
             sparse_vectors_config={
+
                 "sparse": SparseVectorParams()
+
             }
+
         )
 
+
+
     # 2. EVERYTHING ELSE MUST BE UN-INDENTED SO IT RUNS EVERY TIME
+
     try:
+
         docs = ingestion_and_chunking(file_path)        
+
         texts = [doc.page_content for doc in docs]
 
-        dense_vectors = dense_model.embed_documents(texts)
+
+
+        dense_vectors = list(dense_model.embed(texts))
+
         sparse_vectors = list(sparse_model.embed(texts))
 
+
+
         points = []
+
         file_id = str(uuid.uuid4())
 
+
+
         for i, doc in enumerate(docs):
+
             # 1. Convert numpy array to standard Python list
-            dense_vec = dense_vectors[i]
-            
+
+            dense_vec = dense_vectors[i].tolist()
+
+           
+
             # 2. Extract indices and values from FastEmbed's custom object
+
             sparse_emb = sparse_vectors[i]
+
             sparse_vec = {
+
                 "indices": sparse_emb.indices.tolist(),
+
                 "values": sparse_emb.values.tolist()
+
             }
+
             chunk_id = str(uuid.uuid4())
 
+
+
             point = PointStruct(
+
                 id=chunk_id, # Reusing the same file_id so all chunks tie back to one file
+
                 vector={
+
                     'dense': dense_vec,
+
                     'sparse': sparse_vec
+
                 },
+
                 payload={
+
                     'user_id': user_id,
+
                     'file_id': file_id,
+
                     'text': doc.page_content,
+
                     "source": doc.metadata.get("source"),
+
                     "pages": doc.metadata.get("pages"),
+
                     "section": doc.metadata.get("section")
+
                 }
+
             )
+
             points.append(point)
 
+
+
         # (Optional but safe) Tell Qdrant to index it just in case
+
         try:
+
             client.create_payload_index(
-                collection_name=collection_name, 
+
+                collection_name=collection_name,
+
                 field_name="user_id",
+
                 field_schema="keyword"
+
             )
+
         except Exception:
+
             pass
 
+
+
         # Send to database
+
         client.upsert(collection_name=collection_name, points=points)
+
+
+
+        # 3. THE LOUD TERMINAL ANNOUNCEMENT
+
+        print("\n" + "="*60, flush=True)
+
+        print(f"✅ SUCCESS: PDF FULLY PROCESSED FOR USER {user_id}", flush=True)
+
+        print("✅ YOU CAN NOW ASK QUESTIONS IN STREAMLIT!", flush=True)
+
+        print("="*60 + "\n", flush=True)
+
+
+
     except Exception as e:
+
+        # 4. IF IT CRASHES, SCREAM THE ERROR TO THE TERMINAL
+
         print("\n" + "!"*60, flush=True)
+
         print(f"❌ UPLOAD FAILED SILENTLY IN BACKGROUND:", flush=True)
+
         print(f"{str(e)}", flush=True)
-        print("!"*60 + "\n", flush=True)
+
+        print("!"*60 + "\n", flush=True) 
+

src/ingestion.py

@@ -2,8 +2,6 @@ from docling.document_converter import DocumentConverter
 from docling.chunking import HybridChunker
 from transformers import AutoTokenizer
 from langchain_core.documents import Document
-from docling_core.transforms.chunker.tokenizer.openai import OpenAITokenizer
-
 
 def ingestion_and_chunking(file_path : str) :
 

src/retrieval.py

@@ -1,95 +1,138 @@
 import os
-import requests
+
 from dotenv import load_dotenv
+
 from qdrant_client import QdrantClient
+
 from qdrant_client import models
-from fastembed import SparseTextEmbedding
-from langchain_community.embeddings import HuggingFaceInferenceAPIEmbeddings
+
+from fastembed import TextEmbedding, SparseTextEmbedding
+
+from fastembed.rerank.cross_encoder import TextCrossEncoder
+
+
 
 load_dotenv()
 
+
+
 qdrant_api_key = os.getenv("QDRANT_API_KEY")
+
 qdrant_url = os.getenv("QDRANT_URL")
-hf_token = os.getenv("HF_TOKEN")
+
+
 
 class Retriever() :
-    def __init__(self , collection_name = 'pdf_rag_v3') :
+
+    def __init__(self , collection_name = 'pdf_rag') :
+
         self.collection_name = collection_name
+
         self.client = QdrantClient(url=qdrant_url , api_key=qdrant_api_key)
 
-        # 🚨 THE FIX: Do NOT load models here. Let the server boot fast and light.
-        self.dense_model = None
-        self.sparse_model = None
-
-    def cloud_rerank(self, query, texts):
-        API_URL = "https://api-inference.huggingface.co/models/cross-encoder/ms-marco-MiniLM-L-6-v2"
-        headers = {"Authorization": f"Bearer {hf_token}"}
-        payload = {
-            "inputs": {
-                "source_sentence": query,
-                "sentences": texts
-            }
-        }
-        try:
-            response = requests.post(API_URL, headers=headers, json=payload)
-            if response.status_code == 200:
-                return response.json()
-        except Exception as e:
-            print(f"Cloud reranker failed: {e}")
-            pass
-        
-        return [0.0] * len(texts)
+
+
+        self.dense_model = TextEmbedding(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+        self.sparse_model = SparseTextEmbedding(model_name="Qdrant/bm25")
+
+
+
+        self.reranker = TextCrossEncoder(model_name="Xenova/ms-marco-MiniLM-L-6-v2")
+
+
+
 
 
     def retrieve(self , query : str , user_id : str) :
-        # 🚨 THE FIX: Lazy Load. Only turn the models on the very first time someone asks a question!
-        if self.dense_model is None:
-            self.dense_model = HuggingFaceInferenceAPIEmbeddings(
-                api_key=hf_token,
-                model_name="sentence-transformers/all-MiniLM-L6-v2"
-            )
-        if self.sparse_model is None:
-            self.sparse_model = SparseTextEmbedding(model_name="Qdrant/bm25")
 
-        dense_query_vector = self.dense_model.embed_query(query)
+
+
+        dense_query_vector = list(self.dense_model.embed([query]))[0]
+
+
 
         sparse_query = list(self.sparse_model.embed([query]))[0]
+
         sparse_query_vector = models.SparseVector(indices=sparse_query.indices,
+
                                                   values=sparse_query.values)
-        
+
+       
+
         user_filter = models.Filter(must=[models.FieldCondition(key="user_id" , match=models.MatchValue(value=user_id))])
 
+
+
         results = self.client.query_points(collection_name=self.collection_name,
+
                                            prefetch=[models.Prefetch(
+
                                                query=dense_query_vector,
+
                                                limit=20,
+
                                                using='dense',
+
                                                filter=user_filter
+
                                            ),
+
                                            models.Prefetch(
+
                                                query=sparse_query_vector,
+
                                                using='sparse',
+
                                                limit=20,
+
                                                filter=user_filter
+
                                            )],
+
                                            query=models.FusionQuery(fusion=models.Fusion.RRF),
+
                                            limit=20)
-        
+
+       
+
         texts = [point.payload.get('text' , '') for point in results.points]
 
-        rerank_scores = self.cloud_rerank(query, texts)
+
+
+        rerank_scores = list(self.reranker.rerank(query, texts))
+
+
 
         reranked_results = []
+
         for point, score in zip(results.points, rerank_scores):
+
             reranked_results.append({
+
                 "text": point.payload.get("text"),
+
                 "source": point.payload.get("source"),
+
                 "pages": point.payload.get("pages"),
+
                 "section": point.payload.get("section"),
+
                 "original_qdrant_score": point.score,
+
                 "rerank_score": float(score)
+
             })
 
+
+
         reranked_results.sort(key=lambda x: x["rerank_score"], reverse=True)
 
-        return reranked_results[:5]
+
+
+        final_top_results = reranked_results[:5]
+
+       
+
+        return final_top_results 
+