Update app.py

app.py

@@ -1,4 +1,4 @@
-# app.py — Optimized Nexari G1 (Faster & Fixed Search)
+# app.py — Fixed RAG Context Injection (Solves Data Ignoring)
 import os
 import json
 import logging
@@ -11,18 +11,17 @@ from pydantic import BaseModel
 from typing import Any, Dict, List
 
 # Local model modules
-# NOTE: router_model removed to save RAM as it was unused in logic
 import coder_model
 import chat_model
 
 # === SAFE IMPORT FOR NEW LIBRARIES ===
 try:
     from sentence_transformers import SentenceTransformer, util
-    from duckduckgo_search import DDGS # Switched to Sync DDGS for stability
+    from duckduckgo_search import DDGS # Sync DDGS is more reliable
     NEURAL_AVAILABLE = True
 except ImportError:
     NEURAL_AVAILABLE = False
-    print("⚠️ WARNING: sentence-transformers or duckduckgo-search not found. Running in Basic Mode.")
+    print("⚠️ WARNING: sentence-transformers or duckduckgo-search not found.")
 
 logging.basicConfig(level=logging.INFO)
 logger = logging.getLogger("nexari.app")
@@ -42,7 +41,7 @@ INTENT_ANCHORS = {
     "coding": ["write python code", "fix bug", "create function", "script", "debug", "sql query", "html css"],
     "reasoning": ["solve math", "explain logic", "why", "prove that", "analyze", "physics"],
     "sad": ["i am sad", "depressed", "lonely", "feeling low", "heartbroken"],
-    "search": ["search google", "who is", "latest news", "price of", "weather", "find info", "current status", "gold price"],
+    "search": ["search google", "who is", "latest news", "price of", "weather", "find info", "current status", "gold price", "stock price"],
     "time": ["what time is it", "current time", "date", "clock", "day is today"]
 }
 
@@ -56,14 +55,11 @@ def ensure_model_dir_or_fail():
 # === LOADERS ===
 
 def load_neural_network():
-    """Background loader for Neural Network."""
     global neural_classifier, encoded_anchors
-    if not NEURAL_AVAILABLE:
-        return
+    if not NEURAL_AVAILABLE: return
 
     try:
-        logger.info("⏳ Loading Neural Model (in background)...")
-        # CPU friendly loading
+        logger.info("⏳ Loading Neural Model...")
         model = SentenceTransformer(NEURAL_MODEL_NAME, cache_folder=NEURAL_DIR, device="cpu")
         
         anchors = {}
@@ -81,21 +77,17 @@ async def load_neural_async():
 
 @app.on_event("startup")
 async def startup_event():
-    logger.info("Startup: Initializing Nexari G1 systems...")
     ensure_model_dir_or_fail()
-
     coder_model.BASE_DIR = os.path.join(MODEL_DIR, "coder")
     chat_model.BASE_DIR = os.path.join(MODEL_DIR, "chat")
 
-    # Removed Router Model loading to save RAM and reduce Latency
     tasks = [
         asyncio.create_task(coder_model.load_model_async()),
         asyncio.create_task(chat_model.load_model_async()),
         asyncio.create_task(load_neural_async()),
     ]
-    
     asyncio.gather(*tasks, return_exceptions=True)
-    logger.info("🚀 Server Startup Complete (Models loading in background)")
+    logger.info("🚀 Server Startup Complete")
 
 class Message(BaseModel):
     role: str
@@ -116,46 +108,43 @@ def get_real_time():
         return str(datetime.now())
 
 def search_sync(query: str):
-    """Synchronous search execution to avoid AsyncDDGS loops issues."""
+    """Robust Sync Search with Retry Logic"""
+    logger.info(f"🔎 Executing Search for: {query}")
     try:
         with DDGS() as ddgs:
-            # Using basic text search, lighter and more reliable
-            results = list(ddgs.text(query, max_results=3))
+            # max_results increased to 4 for better context
+            results = list(ddgs.text(query, max_results=4))
             if not results:
-                return "No results found on the web."
-            formatted = "\n".join([f"- Title: {r['title']}\n  Snippet: {r['body']}\n  Link: {r['href']}" for r in results])
-            return formatted
+                return None
+            
+            formatted_res = ""
+            for r in results:
+                formatted_res += f"Source: {r['title']}\nSnippet: {r['body']}\nLink: {r['href']}\n\n"
+            return formatted_res
     except Exception as e:
-        logger.error(f"DDGS Sync Search Error: {e}")
-        return f"Search Error: {str(e)}"
+        logger.error(f"DDGS Error: {e}")
+        return None
 
 async def perform_web_search(query: str):
-    if not NEURAL_AVAILABLE: return "Search unavailable (Lib missing)."
-    logger.info(f"🔍 Searching Web for: {query}")
-    # Running sync code in a thread to keep FastAPI async happy
+    if not NEURAL_AVAILABLE: return None
     return await asyncio.to_thread(search_sync, query)
 
 # === INTENT LOGIC ===
 
 def get_intent_neural(text: str):
-    if not neural_classifier:
-        return None
+    if not neural_classifier: return "chat"
     try:
-        # Quick check: If text is very short, skip neural overhead
         if len(text.split()) < 2: return "chat"
-
         user_embedding = neural_classifier.encode(text, convert_to_tensor=True)
         scores = {}
         for intent, anchor_embeddings in encoded_anchors.items():
             cosine_scores = util.cos_sim(user_embedding, anchor_embeddings)
             scores[intent] = float(cosine_scores.max())
-        
         best = max(scores, key=scores.get)
-        # Threshold adjusted for better accuracy
-        if scores[best] < 0.30: return "chat"
+        if scores[best] < 0.28: return "chat"
         return best
     except Exception:
-        return None
+        return "chat"
 
 def sanitize_chunk(chunk: Any) -> Dict[str, Any]:
     if isinstance(chunk, dict):
@@ -164,11 +153,9 @@ def sanitize_chunk(chunk: Any) -> Dict[str, Any]:
 
 SYSTEM_PREFIX = (
     "You are Nexari-G1, an advanced AI created by Piyush, the CEO of Nexari AI. "
-    "always understand the user behaviour and request. "
-    "If the user gives a short or simple message, respond instantly without doing deep thinking. "
-    "always add emoji according to the user question and behaviour. "
-    "Your name is Nexari-G1. Always be helpful, honest, and clearly identify yourself as Nexari-G1 when appropriate. "
-    "IMPORTANT: If Search Results are provided below, USE THEM to answer the user's question directly. Do not say you cannot search."
+    "Your goal is to provide accurate, helpful, and concise answers. "
+    "Always identify yourself as Nexari-G1. "
+    "Use emojis to make the conversation lively. "
 )
 
 def limit_context(messages: List[Dict]) -> List[Dict]:
@@ -187,21 +174,27 @@ async def chat_endpoint(request: ChatRequest):
     raw_msgs = [m.dict() for m in request.messages] if request.messages else []
     if not raw_msgs: return {"error": "Empty messages"}
     
-    last_msg = raw_msgs[-1]['content']
-    intent = get_intent_neural(last_msg) or "chat"
+    # 1. Capture User's Last Message
+    last_user_msg_obj = raw_msgs[-1]
+    last_msg_text = last_user_msg_obj['content']
     
-    # Fallback keyword check (for when Neural is loading or misses)
-    if intent == "chat" and len(last_msg) > 3:
-        lower = last_msg.lower()
+    intent = get_intent_neural(last_msg_text) or "chat"
+    
+    # Fallback keyword check
+    if intent == "chat" and len(last_msg_text) > 3:
+        lower = last_msg_text.lower()
         if "time" in lower and ("what" in lower or "tell" in lower): intent = "time"
         elif "search" in lower or "google" in lower or "price" in lower or "news" in lower: intent = "search"
     
     selected_model = chat_model.model
     sys_msg = SYSTEM_PREFIX
-    status = "Analyse Request"
-    tool_context = ""
+    status = "Thinking..."
+    
+    # Context Injection Variables
+    injected_context = ""
+    
+    # === ROUTING & TOOL EXECUTION ===
     
-    # Routing Logic
     if intent == "coding" and getattr(coder_model, "model", None):
         selected_model = coder_model.model
         sys_msg += " You are an Expert Coder. Provide clean, working code."
@@ -209,47 +202,65 @@ async def chat_endpoint(request: ChatRequest):
     
     elif intent == "reasoning" and getattr(chat_model, "model", None):
         selected_model = chat_model.model
-        sys_msg += " Think step-by-step to solve this."
+        sys_msg += " Think step-by-step."
         status = "Reasoning..."
         
-    elif intent == "sad":
-        status = "Empathizing..."
-        
     elif intent == "time":
         t = get_real_time()
-        tool_context = f"\n\n[SYSTEM UPDATE]: Current Date & Time is {t}. Tell this to the user."
+        # Inject directly into user prompt for high attention
+        injected_context = f"CURRENT DATE & TIME: {t}"
         status = "Checking Time..."
         
     elif intent == "search":
         status = "Searching Web..."
-        # Extract query: remove "search" keyword for better results if possible
-        clean_query = last_msg.replace("search", "").replace("google", "").strip()
-        search_q = clean_query if len(clean_query) > 3 else last_msg
+        clean_query = last_msg_text.replace("search", "").replace("google", "").strip()
+        search_q = clean_query if len(clean_query) > 2 else last_msg_text
         
         res = await perform_web_search(search_q)
-        tool_context = f"\n\n[WEB SEARCH RESULTS]:\n{res}\n\n[INSTRUCTION]: Use the above search results to answer the user's question accurately."
-
-    # Warmup check
-    if not selected_model:
-        # Fallback to whatever model is available if the selected one isn't ready
-        if chat_model.model: selected_model = chat_model.model
-        elif coder_model.model: selected_model = coder_model.model
-        else: return {"error": "Nexari-G1 is warming up, please try again in 20 seconds."}
+        
+        if res:
+            # STRONG INJECTION PATTERN
+            injected_context = (
+                f"### SEARCH RESULTS (REAL-TIME DATA):\n{res}\n"
+                "### INSTRUCTION:\n"
+                "Answer the user's question using ONLY the Search Results above. "
+                "Do NOT use your internal training data if it conflicts. "
+                "If the price or data is in the results, state it clearly."
+            )
+        else:
+            injected_context = (
+                "### SYSTEM NOTE:\n"
+                "Attempted to search the web but found no results. "
+                "Please politely inform the user that you couldn't find current info."
+            )
 
-    # Construct Message
+    # === MESSAGE CONSTRUCTION ===
+    
+    # 1. Set System Prompt
     if raw_msgs[0].get("role") != "system":
         raw_msgs.insert(0, {"role":"system","content": sys_msg})
     else:
         raw_msgs[0]["content"] = sys_msg
-    
-    if tool_context: 
-        # Add tool context to the SYSTEM message for better adherence
-        raw_msgs[0]["content"] += tool_context
 
-    final_msgs = limit_context(raw_msgs)
+    # 2. INJECT CONTEXT INTO LAST USER MESSAGE (Crucial Fix)
+    # This forces the model to see the context immediately before generating the answer.
+    if injected_context:
+        new_content = (
+            f"{injected_context}\n\n"
+            f"### USER QUESTION:\n{last_msg_text}"
+        )
+        # Update the last message in the list
+        raw_msgs[-1]['content'] = new_content
+
+    # 3. Model Warmup Check
+    if not selected_model:
+        if chat_model.model: selected_model = chat_model.model
+        elif coder_model.model: selected_model = coder_model.model
+        else: return {"error": "System warming up..."}
 
-    logger.info(f"Intent: {intent} | Model: {'Coder' if selected_model == coder_model.model else 'Chat'}")
+    final_msgs = limit_context(raw_msgs)
 
+    # Streamer
     def iter_response():
         try:
             yield f"event: status\ndata: {json.dumps({'status': status})}\n\n"