new server

app.py

@@ -1,38 +1,60 @@
+# app.py
 from fastapi import FastAPI
 from pydantic import BaseModel
 from fastapi.middleware.cors import CORSMiddleware
-import google.generativeai as genai
-import os
-from dotenv import load_dotenv
+from bot_instance import gemini_bot, llama_bot  # singleton ErrorBot instance
+from typing import List, Optional
 
-# Load variables from .env file
-load_dotenv()
-# ✅ Configure API Key (set GOOGLE_API_KEY in environment variables)
-genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
+app = FastAPI(title="ErrorBot API")
 
-app = FastAPI()
-
-# ✅ Allow all origins
+# ✅ Allow all origins (adjust in production)
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],  
+    allow_origins=["*"],
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
+# ---------------- Request Models ----------------
+class MessageItem(BaseModel):
+    role: str  # "user" or "bot"
+    content: str
+
 class ChatRequest(BaseModel):
     message: str
+    history: Optional[List[MessageItem]] = []  # optional conversation history
 
-# ✅ Load Gemini model (example: gemini-1.5-flash is lightweight & fast)
-model = genai.GenerativeModel("gemini-2.5-flash")
-
+# ---------------- Endpoints ----------------
 @app.get("/")
 def root():
     return {"status": "ok"}
 
-@app.post("/chat")
-def chat(request: ChatRequest):
-    """Chat endpoint using Gemini"""
-    response = model.generate_content(request.message)
-    return {"reply": response.text}
+# @app.post("/chat")
+# def chat(request: ChatRequest):
+#     """
+#     Main chat endpoint:
+#     - Accepts a message and optional conversation history
+#     - Uses ErrorBot with RAG + LLM
+#     """
+#     history_list = [
+#         {"role": msg.role, "content": msg.content} for msg in request.history
+#     ]
+
+#     # Ask bot with history
+#     answer = bot.ask(request.message, history=history_list)
+
+#     return {"reply": answer}
+
+
+@app.post("/gemini/chat")
+def gemini_chat(request: ChatRequest):
+    history_list = [{"role": msg.role, "content": msg.content} for msg in request.history]
+    answer = gemini_bot.ask(request.message, history=history_list)
+    return {"reply": answer}
+
+@app.post("/llama/chat")
+def llama_chat(request: ChatRequest):
+    history_list = [{"role": msg.role, "content": msg.content} for msg in request.history]
+    answer = llama_bot.ask(request.message, history=history_list)
+    return {"reply": answer}

app2.py

@@ -37,7 +37,8 @@ tokenizer = AutoTokenizer.from_pretrained(model_name)
 model = AutoModelForCausalLM.from_pretrained(
     model_name,
     torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-    device_map="auto"
+    device_map="auto",
+    offload_folder="offload"
 )
 print("Model loaded ✅")
 
@@ -54,4 +55,4 @@ def chat(request: ChatRequest):
     reply = tokenizer.decode(outputs[0], skip_special_tokens=True)
     
    
-    return {"reply": reply}
+    return {"reply": reply}

app3.py

@@ -0,0 +1,86 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from fastapi.middleware.cors import CORSMiddleware
+import torch
+import os
+
+# Ensure Hugging Face cache uses a writable path
+os.environ["TRANSFORMERS_CACHE"] = "./.cache"
+os.environ["HF_HOME"] = "./.cache"
+
+app = FastAPI()
+
+# ✅ Allow all origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  
+    allow_credentials=True,
+    allow_methods=["*"],  
+    allow_headers=["*"],  
+)
+
+
+class ChatRequest(BaseModel):
+    message: str
+    max_tokens: int = 200  # default shorter responses for speed
+
+
+# 🔹 Choose a model (smaller = faster on CPU)
+#model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+#model_name = "Qwen/Qwen2.5-1.5B-Instruct"
+model_name = "deepseek-ai/deepseek-coder-1.3b-base"
+
+print("🚀 Loading model... this may take a minute ⏳")
+
+try:
+    if torch.cuda.is_available():
+        # ✅ GPU with quantization
+        from transformers import BitsAndBytesConfig
+        quant_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_compute_dtype=torch.float16,
+        )
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            device_map="auto",
+            quantization_config=quant_config,
+        )
+    else:
+        # ✅ CPU fallback (no quantization)
+        model = AutoModelForCausalLM.from_pretrained(
+            model_name,
+            torch_dtype=torch.float32,
+            device_map="auto",
+        )
+    tokenizer = AutoTokenizer.from_pretrained(model_name)
+    print("✅ Model loaded successfully!")
+
+except Exception as e:
+    print("❌ Model loading failed:", str(e))
+    raise
+
+
+@app.get("/")
+def root():
+    return {"status": "ok"}
+
+
+@app.post("/chat")
+def chat(request: ChatRequest):
+    """Chat endpoint"""
+    inputs = tokenizer(request.message, return_tensors="pt").to(model.device)
+
+    outputs = model.generate(
+        **inputs,
+        max_new_tokens=request.max_tokens,
+        do_sample=True,
+        top_p=0.9,
+        temperature=0.7
+    )
+
+    # 🔹 Only decode new tokens
+    reply_tokens = outputs[0][inputs["input_ids"].shape[1]:]
+    reply = tokenizer.decode(reply_tokens, skip_special_tokens=True)
+
+    return {"reply": reply}

backup_gemini_llm.py

@@ -0,0 +1,38 @@
+from fastapi import FastAPI
+from pydantic import BaseModel
+from fastapi.middleware.cors import CORSMiddleware
+import google.generativeai as genai
+import os
+from dotenv import load_dotenv
+
+# Load variables from .env file
+load_dotenv()
+# ✅ Configure API Key (set GOOGLE_API_KEY in environment variables)
+genai.configure(api_key=os.environ["GOOGLE_API_KEY"])
+
+app = FastAPI()
+
+# ✅ Allow all origins
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],  
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+class ChatRequest(BaseModel):
+    message: str
+
+# ✅ Load Gemini model (example: gemini-1.5-flash is lightweight & fast)
+model = genai.GenerativeModel("gemini-2.5-flash")
+
+@app.get("/")
+def root():
+    return {"status": "ok"}
+
+@app.post("/chat")
+def chat(request: ChatRequest):
+    """Chat endpoint using Gemini"""
+    response = model.generate_content(request.message)
+    return {"reply": response.text}

bot_instance.py

@@ -0,0 +1,45 @@
+import os
+from dotenv import load_dotenv
+from util import ErrorBot
+
+# Load environment variables
+load_dotenv()
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY")
+# if not GOOGLE_API_KEY:
+#     raise ValueError("Set GOOGLE_API_KEY in your environment variables")
+
+# EMBEDDING_MODEL = "BAAI/bge-base-en-v1.5"
+# LLM_MODEL = "gemini-2.5-flash"  # Gemini model
+
+# # Initialize singleton bot
+# bot = ErrorBot(
+#     embedding_model_name=EMBEDDING_MODEL,
+#     llm_model_name=LLM_MODEL,
+#     google_api_key=GOOGLE_API_KEY,
+# )
+
+# Ingest MongoDB
+# bot.ingest_from_mongodb(
+#     mongo_uri="mongodb+srv://dhaval:Dhaval15@cluster0.rwu1ze6.mongodb.net/prontoDB?retryWrites=true&w=majority&appName=Cluster0",
+#     db_name="prontoDB",
+# )
+
+GROQ_API_KEY = os.getenv("GROQ_API_KEY")
+
+EMBEDDING_MODEL = "BAAI/bge-base-en-v1.5"
+
+# --- Gemini Bot ---
+gemini_bot = ErrorBot(
+    embedding_model_name=EMBEDDING_MODEL,
+    llm_model_name="gemini-2.5-flash",
+    google_api_key=GOOGLE_API_KEY,
+    llm_provider="gemini",
+)
+
+# --- Groq Bot (LLaMA) ---
+llama_bot = ErrorBot(
+    embedding_model_name=EMBEDDING_MODEL,
+    llm_model_name="llama-3.3-70b-versatile",
+    groq_api_key=GROQ_API_KEY,
+    llm_provider="groq",
+)

main.py

@@ -0,0 +1,9 @@
+from bot_instance import bot
+
+history = [
+        {"role": "user", "content": "My name is Shreekant"},
+        {"role": "bot", "content": "Ok"}
+    ]
+
+answer = bot.ask("What is my name?", history=history)
+print(answer)

main2.py

@@ -0,0 +1,28 @@
+from util2 import ErrorBot
+
+print("hello")
+
+if __name__ == "__main__":
+    EMBEDDING_MODEL = "BAAI/bge-base-en-v1.5"
+    LLM_MODEL = "deepseek-ai/deepseek-coder-1.3b-instruct"
+
+    bot = ErrorBot(embedding_model_name=EMBEDDING_MODEL, llm_model_name=LLM_MODEL)
+
+    # Ingest MongoDB
+    bot.ingest_from_mongodb(
+        mongo_uri="mongodb+srv://dhaval:Dhaval15@cluster0.rwu1ze6.mongodb.net/prontoDB?retryWrites=true&w=majority&appName=Cluster0",
+        db_name="prontoDB",
+    )
+
+    # Example queries
+    #bot.ask("who is author of problem Id: PR787807")
+    #bot.ask("Who is the responsiblePerson for correction CR1554963?")
+    bot.ask("What is the solution for this Installation failed In DCA State with NIV services in Stopped State || SprintLab837")
+
+    history = [
+        {"role": "user", "content": "My name is Shreekant"},
+        {"role": "bot", "content": "Ok"}
+    ]
+
+    answer = bot.ask("What is my name?", history=history)
+    print(answer)

requirements.txt

@@ -1,6 +1,8 @@
 accelerate==1.10.1
 annotated-types==0.7.0
 anyio==4.10.0
+bitsandbytes==0.47.0
+bitsandbytes-windows==0.37.5
 cachetools==5.5.2
 certifi==2025.8.3
 charset-normalizer==3.4.3

util.py

@@ -0,0 +1,206 @@
+import os
+import torch
+from qdrant_client import QdrantClient, models
+from sentence_transformers import SentenceTransformer, CrossEncoder
+from pymongo import MongoClient
+from bson import ObjectId
+from typing import List, Dict
+import google.generativeai as genai
+from groq import Groq 
+
+def build_content(doc: dict, entity_type: str) -> str:
+    """Convert MongoDB document into natural text for embeddings."""
+    parts = [f"{entity_type} ID: {doc.get('id', str(doc.get('_id', '')))}"]
+    for k, v in doc.items():
+        if k in ["_id"]:  # skip ObjectId
+            continue
+        if isinstance(v, list):
+            parts.append(f"{k}: {', '.join(map(str, v))}")
+        elif isinstance(v, dict):
+            nested = "; ".join([f"{nk}: {nv}" for nk, nv in v.items() if nv])
+            parts.append(f"{k}: {nested}")
+        else:
+            if v:
+                parts.append(f"{k}: {v}")
+    return "\n".join(parts)
+
+
+class ErrorBot:
+    """Chatbot using RAG (Qdrant + Gemini API)."""
+
+    def __init__(self, embedding_model_name: str, llm_model_name: str, google_api_key: str = None, groq_api_key: str = None, llm_provider: str = "gemini"):
+        print("🚀 Initializing ErrorBot...")
+
+        # --- Embedding model
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+        self.embedding_model = SentenceTransformer(embedding_model_name, device=self.device)
+        self.embedding_dim = self.embedding_model.get_sentence_embedding_dimension()
+
+        # --- Qdrant client
+        print("Connecting to Qdrant...")
+        self.qdrant = QdrantClient(
+            url=os.getenv("QDRANT_URL"),
+            api_key=os.getenv("QDRANT_API_KEY"),
+        )
+        self.collection_name = "technical_errors"
+        self._setup_collection()
+
+        # --- LLM setup
+        self.llm_provider = llm_provider.lower()
+        self.llm_model_name = llm_model_name
+
+        if self.llm_provider == "gemini":
+            genai.configure(api_key=google_api_key)
+            self.llm = genai.GenerativeModel(llm_model_name)
+
+        elif self.llm_provider == "groq":
+            self.llm = Groq(api_key=groq_api_key)
+
+        else:
+            raise ValueError(f"Unsupported LLM provider: {self.llm_provider}")
+
+        # --- Cross encoder reranker
+        self.reranker = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")
+        print(f"✅ ErrorBot ready with {self.llm_provider.upper()}")
+
+    def _setup_collection(self):
+        if not self.qdrant.collection_exists(self.collection_name):
+            self.qdrant.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=models.VectorParams(
+                    size=self.embedding_dim,
+                    distance=models.Distance.COSINE,
+                ),
+            )
+
+    def ingest_from_mongodb(self, mongo_uri: str, db_name: str, batch_size: int = 32):
+        client = MongoClient(mongo_uri)
+        db = client[db_name]
+
+        collections = {
+            "ProblemReport": db["problemReports"],
+            "FaultAnalysis": db["faultanalysis"],
+            "Correction": db["corrections"],
+        }
+
+        docs = []
+        for entity_type, coll in collections.items():
+            for doc in coll.find():
+                if "_id" in doc and isinstance(doc["_id"], ObjectId):
+                    doc["_id"] = str(doc["_id"])
+                docs.append({"entity_type": entity_type, "data": doc})
+
+        contents = [build_content(d["data"], d["entity_type"]) for d in docs]
+
+        all_embeddings = []
+        for i in range(0, len(contents), batch_size):
+            batch_contents = contents[i:i + batch_size]
+            embeddings = self.embedding_model.encode(batch_contents, show_progress_bar=True).tolist()
+            all_embeddings.extend(embeddings)
+
+        self.qdrant.upsert(
+            collection_name=self.collection_name,
+            points=[
+                models.PointStruct(
+                    id=i,
+                    vector=emb,
+                    payload={
+                        "id": d["data"].get("id", str(d["data"].get("_id", i))),
+                        "entity_type": d["entity_type"],
+                        "raw": d["data"],
+                        "content": c,
+                    },
+                )
+                for i, (d, emb, c) in enumerate(zip(docs, all_embeddings, contents))
+            ],
+            wait=True,
+        )
+        print(f"✅ Ingested {len(docs)} documents into '{self.collection_name}'")
+
+    def retrieve(self, query: str, top_k: int = 5, score_threshold: float = 0.3, rerank: bool = True):
+        query_embedding = self.embedding_model.encode(query).tolist()
+        hits = self.qdrant.query_points(
+            collection_name=self.collection_name,
+            query=query_embedding,
+            limit=top_k * 3 if rerank else top_k,
+            with_payload=True,
+            score_threshold=score_threshold,
+        ).points
+
+        candidates = [
+            {
+                "id": hit.payload.get("id"),
+                "entity_type": hit.payload.get("entity_type", ""),
+                "content": hit.payload.get("content", ""),
+                "score": hit.score,
+            }
+            for hit in hits
+        ]
+
+        if rerank and candidates:
+            pairs = [(query, c["content"]) for c in candidates]
+            scores = self.reranker.predict(pairs)
+            for i, score in enumerate(scores):
+                candidates[i]["rerank_score"] = float(score)
+            candidates = sorted(candidates, key=lambda x: x["rerank_score"], reverse=True)
+
+        return candidates[:top_k]
+
+    def generate_answer(self, query: str, context: List[Dict], history: list = None):
+        context_str = "\n---\n".join(
+            [f"{c['entity_type']} (Score: {c['score']:.2f}):\n{c['content']}" for c in context]
+        )
+
+        # --- System prompt
+        system_prompt = f"""
+    You are a technical assistant. You have access to Problem Reports (PR), Fault Analyses (FA), and Corrections (CR).
+    Use the provided context and conversation history to answer the question clearly and concisely.
+    If context is not relevant, say you do not have enough information.
+
+    ### Context
+    {context_str}
+    """
+
+        # --- Conversation history in list-of-dicts format
+        convo = []
+        if history:
+            for msg in history:
+                convo.append({
+                    "role": "user" if msg["role"] == "user" else "assistant",
+                    "content": msg["content"],
+                })
+
+        convo.append({"role": "user", "content": query})
+
+        # --- Gemini flow
+        if self.llm_provider == "gemini":
+            convo_str = "\n".join([f"{m['role'].capitalize()}: {m['content']}" for m in convo])
+            prompt = system_prompt + "\n\n" + convo_str + "\nAssistant:"
+            response = self.llm.generate_content(prompt)
+            return response.text.strip()
+
+        # --- Groq flow
+        elif self.llm_provider == "groq":
+            completion = self.llm.chat.completions.create(
+                model=self.llm_model_name,
+                messages=[{"role": "system", "content": system_prompt}] + convo
+            )
+            return completion.choices[0].message.content.strip()
+
+
+    def ask(self, query: str, history: list = None):
+        print(f"\n❓ Query: {query}")
+        retrieved_context = self.retrieve(query)
+
+        if not retrieved_context:
+            print("💬 No relevant context found.")
+            return "I could not find any relevant information."
+
+        print(f"✅ Retrieved {len(retrieved_context)} documents.")
+        for i, doc in enumerate(retrieved_context):
+            print(f"  - Context {i+1} ({doc['entity_type']}, ID: {doc['id']}, Score: {doc['score']:.2f})")
+
+        answer = self.generate_answer(query, retrieved_context, history)
+        print(f"\n🤖 Answer: {answer}")
+        return answer

util2.py

@@ -0,0 +1,185 @@
+import os
+import torch
+from qdrant_client import QdrantClient, models
+from sentence_transformers import SentenceTransformer, CrossEncoder
+from pymongo import MongoClient
+from bson import ObjectId
+from typing import List, Dict
+import google.generativeai as genai
+from groq import Groq 
+
+def build_content(doc: dict, entity_type: str) -> str:
+    """Convert MongoDB document into natural text for embeddings."""
+    parts = [f"{entity_type} ID: {doc.get('id', str(doc.get('_id', '')))}"]
+    for k, v in doc.items():
+        if k in ["_id"]:  # skip ObjectId
+            continue
+        if isinstance(v, list):
+            parts.append(f"{k}: {', '.join(map(str, v))}")
+        elif isinstance(v, dict):
+            nested = "; ".join([f"{nk}: {nv}" for nk, nv in v.items() if nv])
+            parts.append(f"{k}: {nested}")
+        else:
+            if v:
+                parts.append(f"{k}: {v}")
+    return "\n".join(parts)
+
+
+class ErrorBot:
+    """Chatbot using RAG (Qdrant + Gemini API)."""
+
+    def __init__(self, embedding_model_name: str, llm_model_name: str, google_api_key: str):
+        print("🚀 Initializing ErrorBot...")
+
+        # --- Embedding model
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        print(f"Using device: {self.device}")
+        self.embedding_model = SentenceTransformer(embedding_model_name, device=self.device)
+        self.embedding_dim = self.embedding_model.get_sentence_embedding_dimension()
+
+        # --- Qdrant client
+        print("Connecting to Qdrant...")
+        self.qdrant = QdrantClient(
+            url=os.getenv("QDRANT_URL"),
+            api_key=os.getenv("QDRANT_API_KEY"),
+        )
+        self.collection_name = "technical_errors"
+        self._setup_collection()
+
+        # --- Gemini LLM
+        genai.configure(api_key=google_api_key)
+        self.llm_model_name = llm_model_name
+        self.llm = genai.GenerativeModel(llm_model_name)
+
+        # --- Cross encoder reranker
+        print("Loading cross-encoder reranker...")
+        self.reranker = CrossEncoder("cross-encoder/ms-marco-MiniLM-L-6-v2")
+
+        print("✅ ErrorBot ready.")
+
+    def _setup_collection(self):
+        if not self.qdrant.collection_exists(self.collection_name):
+            self.qdrant.create_collection(
+                collection_name=self.collection_name,
+                vectors_config=models.VectorParams(
+                    size=self.embedding_dim,
+                    distance=models.Distance.COSINE,
+                ),
+            )
+
+    def ingest_from_mongodb(self, mongo_uri: str, db_name: str, batch_size: int = 32):
+        client = MongoClient(mongo_uri)
+        db = client[db_name]
+
+        collections = {
+            "ProblemReport": db["problemReports"],
+            "FaultAnalysis": db["faultanalysis"],
+            "Correction": db["corrections"],
+        }
+
+        docs = []
+        for entity_type, coll in collections.items():
+            for doc in coll.find():
+                if "_id" in doc and isinstance(doc["_id"], ObjectId):
+                    doc["_id"] = str(doc["_id"])
+                docs.append({"entity_type": entity_type, "data": doc})
+
+        contents = [build_content(d["data"], d["entity_type"]) for d in docs]
+
+        all_embeddings = []
+        for i in range(0, len(contents), batch_size):
+            batch_contents = contents[i:i + batch_size]
+            embeddings = self.embedding_model.encode(batch_contents, show_progress_bar=True).tolist()
+            all_embeddings.extend(embeddings)
+
+        self.qdrant.upsert(
+            collection_name=self.collection_name,
+            points=[
+                models.PointStruct(
+                    id=i,
+                    vector=emb,
+                    payload={
+                        "id": d["data"].get("id", str(d["data"].get("_id", i))),
+                        "entity_type": d["entity_type"],
+                        "raw": d["data"],
+                        "content": c,
+                    },
+                )
+                for i, (d, emb, c) in enumerate(zip(docs, all_embeddings, contents))
+            ],
+            wait=True,
+        )
+        print(f"✅ Ingested {len(docs)} documents into '{self.collection_name}'")
+
+    def retrieve(self, query: str, top_k: int = 5, score_threshold: float = 0.3, rerank: bool = True):
+        query_embedding = self.embedding_model.encode(query).tolist()
+        hits = self.qdrant.query_points(
+            collection_name=self.collection_name,
+            query=query_embedding,
+            limit=top_k * 3 if rerank else top_k,
+            with_payload=True,
+            score_threshold=score_threshold,
+        ).points
+
+        candidates = [
+            {
+                "id": hit.payload.get("id"),
+                "entity_type": hit.payload.get("entity_type", ""),
+                "content": hit.payload.get("content", ""),
+                "score": hit.score,
+            }
+            for hit in hits
+        ]
+
+        if rerank and candidates:
+            pairs = [(query, c["content"]) for c in candidates]
+            scores = self.reranker.predict(pairs)
+            for i, score in enumerate(scores):
+                candidates[i]["rerank_score"] = float(score)
+            candidates = sorted(candidates, key=lambda x: x["rerank_score"], reverse=True)
+
+        return candidates[:top_k]
+
+    def generate_answer(self, query: str, context: List[Dict], history: list = None):
+        context_str = "\n---\n".join(
+            [f"{c['entity_type']} (Score: {c['score']:.2f}):\n{c['content']}" for c in context]
+        )
+
+        convo_str = ""
+        if history:
+            for msg in history:
+                role = "User" if msg["role"] == "user" else "Assistant"
+                convo_str += f"{role}: {msg['content']}\n"
+
+        convo_str += f"User: {query}\nAssistant:"
+
+        prompt = f"""
+You are a technical assistant. You have access to Problem Reports (PR), Fault Analyses (FA), and Corrections (CR).
+Use the provided context and conversation history to answer the question clearly and concisely.
+If context is not relevant, say you do not have enough information.
+
+### Context
+{context_str}
+
+### Conversation
+{convo_str}
+"""
+
+        response = self.llm.generate_content(prompt)
+        return response.text.strip()
+
+    def ask(self, query: str, history: list = None):
+        print(f"\n❓ Query: {query}")
+        retrieved_context = self.retrieve(query)
+
+        if not retrieved_context:
+            print("💬 No relevant context found.")
+            return "I could not find any relevant information."
+
+        print(f"✅ Retrieved {len(retrieved_context)} documents.")
+        for i, doc in enumerate(retrieved_context):
+            print(f"  - Context {i+1} ({doc['entity_type']}, ID: {doc['id']}, Score: {doc['score']:.2f})")
+
+        answer = self.generate_answer(query, retrieved_context, history)
+        print(f"\n🤖 Answer: {answer}")
+        return answer