hope it works

app.py

@@ -155,9 +155,6 @@ def query_endpoint(req: QueryRequest):
     answer = generate_answer(req.query,"1")
 
     # Update conversation memory
-    add_message(req.user_id, "user", req.query)
-    add_message(req.user_id, "assistant", answer)
-
     return QueryResponse(
         user_id=req.user_id,
         query=req.query,
@@ -180,6 +177,11 @@ def classify_endpoint(req: QueryRequest):
         "urgency": urgency
     }
 
+@app.on_event("startup")
+def warmup():
+    classify_text("hello")
+    generate_answer("test", "1")
+
 
 if __name__ == "__main__":
     import uvicorn

service/data_loader_service.py

@@ -6,15 +6,12 @@ class CSVDataLoader:
         self.path = Path(filename)
 
     def load_qa_pairs(self) -> list[str]:
-        documents = []
-
+        docs = []
         with self.path.open(encoding="utf-8") as f:
             reader = csv.DictReader(f)
             for row in reader:
                 q = row.get("question", "").strip()
                 a = row.get("answer", "").strip()
-
                 if q and a:
-                    documents.append(f"Question: {q}\nAnswer: {a}")
-
-        return documents
+                    docs.append(f"Q: {q}\nA: {a}")
+        return docs

service/rag_service.py

@@ -1,55 +1,44 @@
+import pickle
+from pathlib import Path
 
 from service.data_loader_service import CSVDataLoader
 from service.embedded_service import EmbeddingService
 from service.vector_store_service import VectorStoreService
 from service.llm_service import LLMService
-from service.memory_service import get_memory, save_memory
 
 
-# Initialize once
+CACHE = Path("embeddings.pkl")
+
 embedder = EmbeddingService()
 llm = LLMService()
 
-loader = CSVDataLoader("final_data_set(in).csv")
+# Load documents
+loader = CSVDataLoader("data.csv")
 documents = loader.load_qa_pairs()
 
-doc_embeddings = embedder.embed(documents)
-vector_store = VectorStoreService(doc_embeddings, documents)
-
-
-def generate_answer(question: str, session_id: str) -> str:
-    query_embedding = embedder.embed([question])[0]
-    context = vector_store.search(query_embedding)
-
-    memory = get_memory(session_id)
-
-    prompt = f"""
-    <|system|>
-    You are a helpful assistant.
-    Answer ONLY using the provided context.
-    Give a COMPLETE, well-formed answer.
-    Do not stop mid-sentence.
-    If the answer is not in the context, say "I don't know".
+# Load or compute embeddings
+if CACHE.exists():
+    with CACHE.open("rb") as f:
+        embeddings = pickle.load(f)
+else:
+    embeddings = embedder.embed(documents)
+    with CACHE.open("wb") as f:
+        pickle.dump(embeddings, f)
 
-    Conversation memory:
-    {memory}
+vector_store = VectorStoreService(embeddings, documents)
 
-    <|user|>
-    Context:
-    {chr(10).join(context)}
-
-    Question:
-    {question}
-
-    <|assistant|>
+def generate_answer(question: str):
     """
+    Generates answer for a query using RAG (retrieval + LLM).
+    """
+    query_vec = embedder.embed([question])[0]
+    context = vector_store.search(query_vec, k=3)
 
+    prompt = (
+        "<|system|>Answer ONLY from context. If unsure say 'I don't know'.\n"
+        "<|user|>\n"
+        + "\n".join(context)
+        + f"\n\nQuestion: {question}\n<|assistant|>"
+    )
 
-    answer = llm.generate(prompt)
-
-    # ✅ Hard safety fallback
-    if not answer:
-        answer = context[0].split("Answer:", 1)[-1].strip()
-
-    save_memory(session_id, question, answer)
-    return answer
+    return llm.generate(prompt)

service/vector_store_service.py

@@ -2,13 +2,10 @@ import numpy as np
 
 class VectorStoreService:
     def __init__(self, embeddings, documents):
-        self.embeddings = np.array(embeddings, dtype="float32")
+        self.embeddings = np.array(embeddings)
         self.documents = documents
 
-    def search(self, query_embedding, top_k=3):
-        query = np.array(query_embedding, dtype="float32")
-
-        scores = np.dot(self.embeddings, query)
-        top_indices = scores.argsort()[-top_k:][::-1]
-
-        return [self.documents[i] for i in top_indices]
+    def search(self, query_embedding, k=3):
+        scores = query_embedding @ self.embeddings.T
+        top_k = scores.argsort()[-k:][::-1]
+        return [self.documents[i] for i in top_k]