Reranker and Debug Added

app/main.py

@@ -27,6 +27,11 @@ app.add_middleware(
 app.include_router(ingest_routes.router, prefix="/api", tags=["Ingestion"])
 app.include_router(ask_routes.router, prefix="/api", tags=["Query"])
 app.include_router(metrics_routes.router, prefix="/api", tags=["Metrics"])
+app.include_router(debug_routes.router, prefix="/api", tags=["Debug"])
+
+logger.info("✅ Routers initialized:")
+for route in app.routes:
+    logger.info(f" - {route.path}")
 
 @app.get("/")
 async def root():

app/routes/ask_routes.py

@@ -4,6 +4,7 @@ from fastapi import APIRouter, HTTPException
 from app.models.jira_schema import QueryRequest, QueryResponse
 from app.services.retriever import retriever
 from app.services.generator import generator
+from app.services.reranker import reranker
 from app.utils.response_builder import build_query_response, extract_chart_intent
 from app.utils.logger import setup_logger
 from collections import Counter
@@ -32,8 +33,14 @@ async def ask_question(request: QueryRequest):
                 sources=[]
             )
         
+        # 🧠 Re-rank results
+        logger.info("[RERANKER] Starting re-ranking process...")
+        reranked_results = reranker.rerank(request.query, results, top_k=5)
+
         # Format context
-        context = retriever.format_context(results)
+        #context = retriever.format_context(results)
+        # Use reranked results for context
+        context = retriever.format_context(context = retriever.format_context(results))
         
         # Generate answer
         answer = generator.generate_rag_response(request.query, context)

app/routes/debug_routes.py

@@ -0,0 +1,10 @@
+@router.post("/debug/retrieval")
+async def debug_retrieval(request: QueryRequest):
+    results = retriever.retrieve(request.query)
+    reranked = reranker.rerank(request.query, results, top_k=10)
+    return {
+        "query": request.query,
+        "raw_faiss_scores": [r["score"] for r in results],
+        "reranked_scores": [r["rerank_score"] for r in reranked],
+        "top_docs": [r["payload"].get("summary") for r in reranked[:5]]
+    }

app/services/embeddings.py

@@ -39,7 +39,7 @@ class EmbeddingService:
     def embed_batch(
         self,
         texts: List[str],
-        batch_size: int = 32,
+        batch_size: int = 16,
         is_query: bool = False,
     ) -> List[List[float]]:
         """Generate embeddings for a batch of texts (queries or passages)."""

app/services/reranker.py

@@ -0,0 +1,50 @@
+# app/services/reranker.py
+from sentence_transformers import CrossEncoder
+from app.utils.logger import setup_logger
+
+logger = setup_logger(__name__)
+
+class RerankerService:
+    """
+    Cross-Encoder based re-ranker for improving top-k retrieval precision.
+    """
+    def __init__(self, model_name: str = "cross-encoder/ms-marco-MiniLM-L-6-v2"):
+        logger.info(f"Loading reranker model: {model_name}")
+        self.model = CrossEncoder(model_name)
+    
+    def rerank(self, query: str, results: list, top_k: int = 5) -> list:
+        """
+        Re-rank retrieved documents using CrossEncoder scores.
+
+        Args:
+            query: User query text
+            results: List of FAISS results [{"payload": {...}, "score": float}]
+            top_k: Return top_k reranked items
+
+        Returns:
+            List of reranked documents with updated scores
+        """
+        if not results:
+            return []
+        
+        pairs = [(query, r["payload"].get("searchable_text", "")) for r in results]
+        
+        logger.info(f"[RERANKER] Scoring {len(pairs)} query-document pairs...")
+        scores = self.model.predict(pairs)
+        
+        # Attach rerank score to each document
+        for i, s in enumerate(scores):
+            results[i]["rerank_score"] = float(s)
+        
+        # Sort by rerank_score (descending)
+        reranked = sorted(results, key=lambda x: x["rerank_score"], reverse=True)
+        
+        logger.info(
+            f"[RERANKER] Top reranked scores: "
+            f"{[round(r['rerank_score'], 3) for r in reranked[:min(top_k, len(reranked))]]}"
+        )
+        
+        return reranked[:top_k]
+
+# Global instance
+reranker = RerankerService()

app/services/retriever.py

@@ -24,7 +24,7 @@ class RetrieverService:
             top_k = settings.TOP_K
         
         # Generate query embedding
-        logger.info(f"Retrieving documents for query: {query}")
+        logger.info(f"[RETRIEVER] Retrieving documents for query: {query}")
         query_embedding = self.embedding_service.embed_text(query,is_query=True)
         #logger.debug(f"Embedded query: {query_embedding}")
         
@@ -59,7 +59,12 @@ class RetrieverService:
         #     score_threshold=settings.SCORE_THRESHOLD
         # ) 
         
-        logger.info(f"Retrieved {len(results)} documents")
+        logger.info(f"[RETRIEVER] Retrieved {len(results)} documents")
+
+        if results:
+            logger.debug("[RETRIEVER] Raw FAISS top-5 scores: " +
+                 ", ".join(f"{r['score']:.4f}" for r in results[:5]))
+
         return results
     
     def format_context(self, results: List[Dict[str, Any]]) -> str: