Update Prompt Template (Stranger Things RAG v7)

main.py

@@ -1,56 +1,42 @@
-import os
-from fastapi import FastAPI, Request
+from fastapi import FastAPI, Request, Form
 from fastapi.responses import HTMLResponse
 from fastapi.staticfiles import StaticFiles
 from fastapi.templating import Jinja2Templates
-from pydantic import BaseModel
 from langchain_community.vectorstores import FAISS
 from langchain_huggingface import HuggingFaceEmbeddings
-from langchain_huggingface import HuggingFaceEndpoint
+from langchain_core.prompts import PromptTemplate
+from langchain_core.runnables import RunnablePassthrough, RunnableLambda
+import os
+import requests
 from dotenv import load_dotenv
 
-# Load environment variables
 load_dotenv()
 
 app = FastAPI()
 
 # Mount static files
 app.mount("/static", StaticFiles(directory="static"), name="static")
-
-# Templates
 templates = Jinja2Templates(directory="templates")
 
-# Initialize RAG Components
-BASE_DIR = os.path.dirname(os.path.abspath(__file__))
-FAISS_PATH = os.path.join(BASE_DIR, "faiss_index")
-embeddings = HuggingFaceEmbeddings(model_name="all-MiniLM-L6-v2")
+# Load FAISS Index
+FAISS_PATH = "faiss_index"
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
 
-print(f"DEBUG: Checking for database at {FAISS_PATH}")
-# Check if DB exists
 if os.path.exists(FAISS_PATH):
-    print("DEBUG: Database found. Loading FAISS...")
-    try:
-        vector_db = FAISS.load_local(FAISS_PATH, embeddings, allow_dangerous_deserialization=True)
-        retriever = vector_db.as_retriever(search_kwargs={"k": 5})
-        print("DEBUG: Retriever initialized.")
-    except Exception as e:
-        print(f"DEBUG: Failed to load FAISS: {e}")
-        retriever = None
+    vector_db = FAISS.load_local(FAISS_PATH, embeddings, allow_dangerous_deserialization=True)
+    retriever = vector_db.as_retriever(search_kwargs={"k": 3})
+    print("DEBUG: FAISS index loaded.")
 else:
-    print("WARNING: FAISS index not found at path. Run ingest.py first.")
-import requests
-import json
-from langchain_core.runnables import RunnableLambda
+    print("WARNING: FAISS index not found. Run ingest.py first.")
+    retriever = None
 
-# Custom DeepSeek Connector (Cloned from Reference Repo)
+# Custom DeepSeek V3.2 Wrapper
 def call_deepseek_v3(prompt_input):
-    # Handle LangChain prompt objects
     if hasattr(prompt_input, "to_string"):
         prompt_text = prompt_input.to_string()
     else:
         prompt_text = str(prompt_input)
 
-    # Direct Router API used by the reference repo
     api_url = "https://router.huggingface.co/v1/chat/completions"
     token = os.getenv("HUGGINGFACEHUB_API_TOKEN")
     
@@ -67,7 +53,7 @@ def call_deepseek_v3(prompt_input):
         "messages": [
             {
                 "role": "system",
-                "content": "You are an expert on Stranger Things. Answer clearly and concisely."
+                "content": "You are a Stranger Things expert. Answer clearly."
             },
             {
                 "role": "user",
@@ -75,93 +61,76 @@ def call_deepseek_v3(prompt_input):
             }
         ],
         "temperature": 0.3,
-        "max_tokens": 512,
+        "max_tokens": 700,
         "stream": False 
     }
 
     try:
         response = requests.post(api_url, headers=headers, json=payload)
         if response.status_code != 200:
-             print(f"API Error {response.status_code}: {response.text}")
-             return f"DeepSeek Error: {response.text}"
+             return f"DeepSeek Error ({response.status_code}): {response.text}"
         return response.json()["choices"][0]["message"]["content"]
     except Exception as e:
-        print(f"DeepSeek Connection Exception: {e}")
-        return f"Error: {e}"
+        return f"Connection Error: {e}"
 
 llm = RunnableLambda(call_deepseek_v3)
-print("DeepSeek V3.2 Client (Custom Request) initialized!")
 
-from langchain_core.prompts import PromptTemplate
-from langchain_core.output_parsers import StrOutputParser
-from langchain_core.runnables import RunnablePassthrough
+# Updated Prompt Template (User Request)
+template = """
+You are a Stranger Things expert assistant. Answer the user's question using ONLY the provided context.
 
-# ... (Previous LLM setup remains)
+Important rules:
+- Do NOT copy sentences directly from the context. Rewrite in your own words.
+- If the context does NOT contain the answer, say: "I don’t have enough information in the provided context to answer that fully."
+- Keep the tone natural, friendly, and engaging.
+- Write at least 4–6 sentences unless the question is very simple.
 
-# LCEL RAG Chain
-template = """You are an expert on Stranger Things. Use the context below to generate a natural, engaging answer in your own words.
-Do not just copy the text. Synthesize the information.
-Format your answer as a detailed response (at least 3-4 sentences).
-Crucial: If the question is about a character, YOU MUST INCLUDE:
-1. Their key relationships (girlfriend/boyfriend, best friends).
-2. Their role or passion (e.g., Dungeon Master, journalist, sheriff).
-3. Any iconic traits.
+If the question is about a CHARACTER, you MUST include:
+1) Full name + who they are in the story
+2) Key relationships (friends, family, love interest, major connections)
+3) Role / occupation / passion (student, sheriff, journalist, Dungeon Master, etc.)
+4) Iconic traits (personality, behavior, famous moments or skills)
+
+If the question is about an EVENT / LOCATION / OBJECT, you MUST include:
+1) What it is
+2) Why it matters in the story
+3) Who is involved
+4) Any major consequences or impact
 
 Context:
 {context}
 
-Question:
+User Question:
 {question}
 
-Answer:"""
+Answer (detailed and structured):
+"""
 
 prompt = PromptTemplate.from_template(template)
 
 def format_docs(docs):
     return "\n\n".join(doc.page_content for doc in docs)
 
-if retriever and llm:
+if retriever:
     rag_chain = (
         {"context": retriever | format_docs, "question": RunnablePassthrough()}
         | prompt
         | llm
     )
-    print("DEBUG: rag_chain constructed successfully.")
 else:
-    print(f"DEBUG: rag_chain initialization skipped. Retriever: {retriever is not None}, LLM: {llm is not None}")
     rag_chain = None
 
-class QueryRequest(BaseModel):
-    query: str
-
 @app.get("/", response_class=HTMLResponse)
 async def read_root(request: Request):
     return templates.TemplateResponse("index.html", {"request": request})
 
-@app.post("/query")
-async def query_rag(request: QueryRequest):
-    print(f"DEBUG: Incoming query: {request.query}")
-    print(f"DEBUG: rag_chain type: {type(rag_chain)}")
-    print(f"DEBUG: rag_chain is: {rag_chain}")
-    
+@app.post("/get_response")
+async def get_response(request: Request, query: str = Form(...)):
     if not rag_chain:
-        return {"answer": "System is initializing or data is missing. Please check server logs.", "sources": []}
+        return templates.TemplateResponse("index.html", {"request": request, "response": "System Error: RAG chain not initialized."})
     
-    try:
-        # Get answer
-        answer = rag_chain.invoke(request.query)
-        
-        # Get sources separately since LCEL simple chain doesn't return them by default 
-        # unless we modify the runable to return a dict. For now, we'll re-retrieve for sources 
-        # or just skip sources to keep it simple as per user request for "|" operator specific demo.
-        # But to keep sources, let's do a quick retrieve:
-        source_docs = retriever.invoke(request.query)
-        sources = [doc.metadata.get("source", "Unknown") for doc in source_docs]
-        sources = list(set(sources))
-        
-        return {"answer": answer, "sources": sources}
-    except Exception as e:
-        return {"answer": f"Error: {str(e)}", "sources": []}
+    result = rag_chain.invoke(query)
+    return templates.TemplateResponse("index.html", {"request": request, "response": result})
 
 if __name__ == "__main__":
     import uvicorn