Update app.py

app.py

@@ -16,29 +16,27 @@ from collections import Counter, defaultdict
 from contextlib import asynccontextmanager
 from typing import List, Dict, Any, Tuple, Set
 
-from fastapi import FastAPI, Query, Form
+from fastapi import FastAPI, Query
 from fastapi.middleware.cors import CORSMiddleware
 from huggingface_hub import snapshot_download
 import torch
 import torch.nn.functional as F
 import faiss
 
-# Hugging Face imports
-from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel, pipeline, BitsAndBytesConfig
+# Hugging Face imports (Only for embeddings now)
+from transformers import AutoTokenizer, AutoModel
 
 # --- CONFIGURATION & MULTIPROCESSING ---
 TOTAL_CORES = multiprocessing.cpu_count()
-AI_CORES = max(1, int(TOTAL_CORES * 0.50)) 
-torch.set_num_threads(AI_CORES)
-print(f"🖥️ Total Cores: {TOTAL_CORES} | Dedicated AI Cores (50%): {AI_CORES} | Dedicated Search Cores: {TOTAL_CORES - AI_CORES}")
+torch.set_num_threads(TOTAL_CORES)
+faiss.omp_set_num_threads(TOTAL_CORES)
+print(f"🖥️ Total Cores Assigned for High-Speed Search: {TOTAL_CORES}")
 
-MAX_CONCURRENT_AI = max(1, AI_CORES)
-ai_semaphore = asyncio.Semaphore(MAX_CONCURRENT_AI)
-ai_generator = None
 HF_TOKEN = os.getenv("HF_TOKEN")
 
-AI_RESPONSE_CACHE = {}
-MAX_AI_CACHE_SIZE = 10000
+# Ultra-fast Cache for handling multiple users seamlessly
+QUERY_CACHE = {}
+MAX_CACHE_SIZE = 50000
 
 # --- DENSE RETRIEVAL GLOBALS (FAISS + E5) ---
 embed_tokenizer = None
@@ -67,16 +65,16 @@ EXPANSION_DICT = {
     "js": ["javascript"]
 }
 
-# Added W_DENSE for FAISS score fusion
+# Fine-tuned Weights for best Dense + Lexical Fusion
 WEIGHTS = {
     "W_BM25": 1.0, "W_TITLE": 4.0, "W_HEADINGS": 3.0, "W_DESCRIPTION": 2.0, "W_BODY": 1.0,
     "W_URL": 1.5, "W_DOMAIN": 1.5, "W_PHRASE": 2.5, "W_EXACT": 3.0, "W_FRESHNESS": 1.0,
     "W_QUALITY": 1.0, "W_POPULARITY": 0.5, "W_PROXIMITY": 1.5, 
-    "W_ROOT_DOMAIN": 8.0, "W_DENSE": 25.0 
+    "W_ROOT_DOMAIN": 8.0, "W_DENSE": 35.0 # Increased priority for Semantic Matching
 }
 
-MAX_RESULTS_PER_DOMAIN = 3
-STRICT_RESULT_LIMIT = 20
+MAX_RESULTS_PER_DOMAIN = 2 # Diversity constraint
+STRICT_RESULT_LIMIT = 5    # ✨ AS REQUESTED: Only return Top 5 URLs to boost speed
 
 def normalize_text(text: str) -> str:
     if not text: return ""
@@ -93,42 +91,26 @@ def tokenize(text: str, remove_stopwords: bool = True) -> List[str]:
 
 # --- E5 POOLING FUNCTION ---
 def average_pool(last_hidden_states, attention_mask):
-    """Mean pooling for E5 dense embeddings"""
     last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0)
     return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None]
 
 # --- 2. QUERY INTENT CLASSIFIER ---
 def detect_query_intent(query_tokens: List[str]) -> Dict[str, Any]:
     intents = []
-    news_terms = {"latest", "news", "today", "breaking", "recent", "updates", "current", "aaj"}
+    news_terms = {"latest", "news", "today", "breaking", "recent", "updates", "current"}
     if any(term in query_tokens for term in news_terms): intents.append("NEWS")
     def_terms = {"definition", "meaning", "kya", "matlab"}
     if any(term in query_tokens for term in def_terms): intents.append("DEFINITION")
     how_terms = {"tutorial", "guide", "steps", "learn", "how", "kaise"}
     if any(term in query_tokens for term in how_terms): intents.append("HOW_TO")
-    comp_terms = {"vs", "versus", "compare", "comparison", "difference", "best", "accha"}
+    comp_terms = {"vs", "versus", "compare", "comparison", "difference", "best"}
     if any(term in query_tokens for term in comp_terms): intents.append("COMPARISON")
-    local_terms = {"near", "restaurant", "restaurants", "location", "weather", "paas"}
+    local_terms = {"near", "restaurant", "restaurants", "location", "weather"}
     if any(term in query_tokens for term in local_terms): intents.append("LOCAL")
     if len(query_tokens) <= 2 and not intents: intents.append("NAVIGATIONAL")
     return {"intent": intents[0] if intents else "GENERAL", "signals": intents}
 
-# --- 3. INTERNAL RAG CHUNKING LOGIC ---
-def rank_chunks_for_rag(text: str, query_tokens: List[str]) -> List[str]:
-    if not text: return []
-    chunks = text.split("\n\n")
-    q_set = set(query_tokens)
-    scored_chunks = []
-    for c in chunks:
-        c_toks = set(tokenize(c))
-        score = len(q_set.intersection(c_toks))
-        if score > 0: scored_chunks.append((score, c))
-    if not scored_chunks and chunks: scored_chunks = [(0, c) for c in chunks[:3]]
-    scored_chunks.sort(reverse=True, key=lambda x: x[0])
-    return [c for score, c in scored_chunks[:2]] 
-
-
-# --- 4. CORE DETERMINISTIC + DENSE HYBRID INDEX ---
+# --- 3. CORE DETERMINISTIC + DENSE HYBRID INDEX ---
 class HybridSearchIndex:
     def __init__(self):
         self.docs = []
@@ -139,9 +121,7 @@ class HybridSearchIndex:
         self.df = defaultdict(int)
         self.avg_doc_len = 0.0
         
-        # Link dataset doc_id -> Internal List Index for FAISS matching
         self.dataset_id_to_internal = {}
-        
         self.inverted_index = defaultdict(lambda: array.array('I')) 
         self.suggestion_counter = Counter()
         self.suggestions = []
@@ -151,7 +131,6 @@ class HybridSearchIndex:
     def add_document(self, doc_json: dict):
         doc_id = len(self.docs)
         
-        # Map original dataset ID for FAISS metadata linking
         dataset_doc_id = doc_json.get("doc_id", "")
         if dataset_doc_id:
             self.dataset_id_to_internal[dataset_doc_id] = doc_id
@@ -170,7 +149,6 @@ class HybridSearchIndex:
         
         url = doc_json.get("url", "")
         parsed_url = urllib.parse.urlparse(url)
-        
         domain_str = sys.intern(parsed_url.netloc.lower().replace("www.", ""))
         
         clean_doc = {
@@ -192,7 +170,6 @@ class HybridSearchIndex:
         content_tokens = tokenize(clean_doc["_fast_content"])[:250] 
         
         all_tokens = title_tokens + desc_tokens + domain_tokens + headings_tokens + snippet_tokens + content_tokens
-        
         clean_doc["_token_len"] = len(all_tokens)
         self.total_len += len(all_tokens)
         
@@ -217,10 +194,9 @@ class HybridSearchIndex:
         self.avg_doc_len = self.total_len / max(1, self.total_docs)
         self.suggestions = self.suggestion_counter.most_common(20000)
         self.high_freq_vocab = [word for word, count in Counter(self.df).most_common(15000)]
-        
         self.suggestion_counter.clear()
         gc.collect()
-        print(f"🚀 Indexing Complete! Exactly {self.total_docs} records fully embedded inside Safe RAM Limits.")
+        print(f"🚀 Core Search Engine Indexing Complete! Total Docs: {self.total_docs}")
 
     def idf(self, term: str) -> float:
         df = self.df.get(term, 0)
@@ -257,17 +233,11 @@ class HybridSearchIndex:
 
         doc_len = doc.get("_token_len", 1)
         avg_dl = max(1.0, self.avg_doc_len)
-        
         content_lower = content.lower()
         snippet_lower = snippet.lower()
         
         for term in query_tokens_sorted:
-            tf = (title_toks.count(term) * 4 + 
-                  headings_toks.count(term) * 3 + 
-                  desc_toks.count(term) * 2 + 
-                  snippet_lower.count(term) * 2 + 
-                  content_lower.count(term))
-            
+            tf = (title_toks.count(term) * 4 + headings_toks.count(term) * 3 + desc_toks.count(term) * 2 + snippet_lower.count(term) * 2 + content_lower.count(term))
             if tf > 0:
                 tf_num = tf * (self.k1 + 1)
                 tf_den = tf + self.k1 * (1 - self.b + self.b * (doc_len / avg_dl))
@@ -370,24 +340,23 @@ class HybridSearchIndex:
         intent = intent_info["intent"]
         user_wants_adult = any(aw in query_norm for aw in ADULT_KEYWORDS)
         
-        # 1. Lexical Retrieval (BM25)
+        # 1. Lexical Retrieval (Fast BM25 Base Candidates)
         candidates_ids = self._get_candidates(sorted_tokens)
         
-        # 2. Dense Semantic Retrieval (FAISS) - True Hybrid Merging
+        # 2. Dense Semantic Retrieval (FAISS - Top Priority)
         dense_scores_map = {}
         if faiss_index is not None and embed_model is not None and embed_tokenizer is not None:
             try:
-                # E5 Requires 'query: ' prefix
-                embed_inputs = embed_tokenizer(
-                    f"query: {query_norm}", return_tensors="pt", padding=True, truncation=True, max_length=512
-                )
-                with torch.no_grad():
+                embed_inputs = embed_tokenizer(f"query: {query_norm}", return_tensors="pt", padding=True, truncation=True, max_length=512)
+                
+                # Use inference_mode for maximum PyTorch speed
+                with torch.inference_mode():
                     embed_outputs = embed_model(**embed_inputs)
                     xq = average_pool(embed_outputs.last_hidden_state, embed_inputs["attention_mask"])
                     xq = F.normalize(xq, p=2, dim=1).numpy()
                 
-                # Fetch Top 50 Contextual Matches
-                D, I = faiss_index.search(xq, k=50)
+                # Fetch Top 20 Contextual Matches via FAISS
+                D, I = faiss_index.search(xq, k=20)
                 
                 for score, idx in zip(D[0], I[0]):
                     if 0 <= idx < len(faiss_metadata):
@@ -395,9 +364,9 @@ class HybridSearchIndex:
                         if ds_id in self.dataset_id_to_internal:
                             internal_id = self.dataset_id_to_internal[ds_id]
                             dense_scores_map[internal_id] = float(score)
-                            candidates_ids.add(internal_id) # Inject Semantic Results into Candidate Pool
+                            candidates_ids.add(internal_id) # Merge into Hybrid Pool
             except Exception as e:
-                print(f"⚠️ FAISS Dense Search Error: {e}")
+                print(f"⚠️ FAISS Search Warning: {e}")
 
         scored_results = []
         seen_domains = defaultdict(int)
@@ -418,11 +387,10 @@ class HybridSearchIndex:
             w_title = WEIGHTS["W_TITLE"] + (2.0 if intent == "DEFINITION" else 0.0)
             w_phrase = WEIGHTS["W_PHRASE"] + (1.5 if intent in ("DEFINITION", "COMPARISON") else 0.0)
             
-            # Fetch Dense Score (Cosine Sim typically 0.70 - 1.0)
             dense_score = dense_scores_map.get(doc_id, 0.0)
             features["dense_score"] = dense_score
             
-            # Fusion: Give high boost only if semantic similarity is significantly strong (>0.75)
+            # Massive Dense Boost (Threshold >= 0.75 gets heavily rewarded)
             dense_boost = max(0.0, dense_score - 0.75) * WEIGHTS["W_DENSE"]
 
             final_score = (
@@ -438,11 +406,10 @@ class HybridSearchIndex:
                 WEIGHTS["W_ROOT_DOMAIN"] * features["root_domain"] +
                 WEIGHTS["W_HEADINGS"] * features["headings"] +
                 WEIGHTS["W_BODY"] * features["body"] +
-                dense_boost  # HYBRID BOOST APPLIED
+                dense_boost 
             )
             
-            # True Semantic Safety Check: Don't heavily penalize missing exact keywords if dense similarity is very high!
-            is_semantic_match = dense_score >= 0.82 
+            is_semantic_match = dense_score >= 0.81 
             
             if len(sorted_tokens) > 0:
                 top_term = sorted_tokens[0]
@@ -452,16 +419,16 @@ class HybridSearchIndex:
                 doc_headings = tokenize(doc.get("_fast_headings", ""), False)
                 
                 if top_term not in doc_title and top_term not in doc_desc and top_term not in doc.get("_fast_domain", "") and top_term not in doc_content and top_term not in doc_headings:
-                    if is_semantic_match: final_score *= 0.6  # Soft semantic penalty
-                    else: final_score *= 0.1  # Harsh Lexical penalty
+                    if is_semantic_match: final_score *= 0.7 
+                    else: final_score *= 0.1 
                     
             if len(sorted_tokens) > 1:
                 second_term = sorted_tokens[1]
                 if second_term not in doc_title and second_term not in doc_desc and second_term not in doc.get("_fast_domain", "") and second_term not in doc_content and second_term not in doc_headings:
-                    if is_semantic_match: final_score *= 0.8 
+                    if is_semantic_match: final_score *= 0.85 
                     else: final_score *= 0.4 
             
-            if final_score > 0.05:
+            if final_score > 0.1:
                 doc_out = {
                     "doc_id": str(doc_id),
                     "title": doc.get("_fast_title", ""),
@@ -486,7 +453,7 @@ class HybridSearchIndex:
             seen_domains[domain] += 1
             seen_urls.add(b_url)
             diversified_results.append(doc_info)
-            if len(diversified_results) >= STRICT_RESULT_LIMIT: break 
+            if len(diversified_results) >= STRICT_RESULT_LIMIT: break # 🔥 Only 5 URLs
                 
         for idx, item in enumerate(diversified_results): item["rank"] = idx + 1
         return diversified_results, intent_info, corrected_query_str
@@ -496,22 +463,18 @@ search_index = HybridSearchIndex()
 # --- DATA LOADER (FAISS & LEXICAL) ---
 def load_dense_retriever():
     global embed_tokenizer, embed_model, faiss_index, faiss_metadata
-    print("🧠 Loading E5-Small-v2 Embedder for Dense Semantic Search...")
+    print("🧠 Loading Lightning Fast E5-Small-v2 Embedder (CPU Optimized)...")
     try:
         embed_tokenizer = AutoTokenizer.from_pretrained("intfloat/e5-small-v2")
-        embed_model = AutoModel.from_pretrained("intfloat/e5-small-v2")
-        embed_model.eval()
+        # Load directly in eval mode for speed
+        embed_model = AutoModel.from_pretrained("intfloat/e5-small-v2").eval()
         print("✅ E5 Embedder Ready!")
     except Exception as e:
         print(f"❌ E5 Loading Failed: {e}")
 
-    print("📥 Downloading Secured FAISS Index from Nebulixlabs/embedded-data...")
+    print("📥 Downloading FAISS Index via HF_TOKEN...")
     try:
-        dense_path = snapshot_download(
-            repo_id="Nebulixlabs/embedded-data",
-            repo_type="dataset",
-            token=HF_TOKEN
-        )
+        dense_path = snapshot_download(repo_id="Nebulixlabs/embedded-data", repo_type="dataset", token=HF_TOKEN)
         index_file = os.path.join(dense_path, "dataset_embeddings.index")
         meta_file = os.path.join(dense_path, "metadata.json")
         
@@ -519,23 +482,15 @@ def load_dense_retriever():
             faiss_index = faiss.read_index(index_file)
             with open(meta_file, "r", encoding="utf-8") as f:
                 faiss_metadata = json.load(f)
-            print(f"✅ True Hybrid Enabled! FAISS Index Loaded with {faiss_index.ntotal} vectors.")
-        else:
-            print("⚠️ FAISS index files not found in repo.")
+            print(f"✅ FAISS High-Speed Index Loaded! ({faiss_index.ntotal} vectors)")
     except Exception as e:
         print(f"❌ FAISS Loading Failed: {e}")
 
 def load_and_index_dataset():
-    print("📦 Downloading and Streaming 'web-search-dataset' ...")
+    print("📦 Streaming 'web-search-dataset' ...")
     try:
-        dataset_path = snapshot_download(
-            repo_id="Nebulixlabs/web-search-dataset", 
-            repo_type="dataset", 
-            allow_patterns="data/*.jsonl",
-            token=HF_TOKEN
-        )
+        dataset_path = snapshot_download(repo_id="Nebulixlabs/web-search-dataset", repo_type="dataset", allow_patterns="data/*.jsonl", token=HF_TOKEN)
     except Exception as e:
-        print("⚠️ Direct HF Hub fetch failed, attempting local fallback. Error:", e)
         dataset_path = "."
         
     data_folder = os.path.join(dataset_path, "data")
@@ -544,175 +499,69 @@ def load_and_index_dataset():
     if os.path.exists(data_folder):
         jsonl_files = [f for f in os.listdir(data_folder) if f.endswith(".jsonl")]
         docs_processed = 0
-        
         for file in jsonl_files:
-            file_path = os.path.join(data_folder, file)
-            with open(file_path, "r", encoding="utf-8") as f:
+            with open(os.path.join(data_folder, file), "r", encoding="utf-8") as f:
                 for line in f:
                     if not line.strip(): continue
                     try:
-                        doc = json.loads(line)
-                        search_index.add_document(doc)
+                        search_index.add_document(json.loads(line))
                         docs_processed += 1
-                        
                         if docs_processed % 50000 == 0:
                             gc.collect()
-                            print(f"🔄 Streamed & Indexed {docs_processed} docs so far...")
-                    except Exception: 
-                        pass
-                        
+                            print(f"🔄 Indexed {docs_processed} docs...")
+                    except Exception: pass
     search_index.finalize_build()
 
-# --- AI GENERATION MODULE ---
-def load_ai_models():
-    global ai_generator
-    print("🤖 Loading HuggingFaceTB/SmolLM2-360M-Instruct (Ultra Fast 4-Bit)...")
-    try:
-        model_id = "HuggingFaceTB/SmolLM2-360M-Instruct"
-        tokenizer = AutoTokenizer.from_pretrained(model_id)
-        quant_config = BitsAndBytesConfig(load_in_4bit=True, bnb_4bit_compute_dtype=torch.float16, bnb_4bit_quant_type="nf4")
-        
-        if torch.cuda.is_available():
-            model = AutoModelForCausalLM.from_pretrained(model_id, quantization_config=quant_config, device_map="auto")
-        else:
-            model = AutoModelForCausalLM.from_pretrained(model_id, device_map="cpu", torch_dtype=torch.float32)
-
-        ai_generator = pipeline("text-generation", model=model, tokenizer=tokenizer)
-        print("✅ Fast 4-Bit AI Ready!")
-    except Exception as e:
-        print(f"❌ Model Loading Failed: {e}")
-
-async def run_ai_task(messages, max_tokens: int, query_key: str):
-    if not ai_generator: return "⚠️ AI Model is starting up."
-    if query_key in AI_RESPONSE_CACHE: return AI_RESPONSE_CACHE[query_key]
-    
-    try: await asyncio.wait_for(ai_semaphore.acquire(), timeout=0.1)
-    except asyncio.TimeoutError:
-        return "⚠️ AI Servers are fully occupied right now. Displaying your ultra-fast search results below!"
-
-    try:
-        def _gen():
-            tokenizer = ai_generator.tokenizer
-            try: prompt = tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
-            except: prompt = "\n".join([f"{m['role'].capitalize()}: {m['content']}" for m in messages]) + "\nAssistant: "
-            result = ai_generator(prompt, max_new_tokens=max_tokens, do_sample=False, truncation=True, return_full_text=False)
-            return result[0]['generated_text'].strip()
-
-        response = await asyncio.to_thread(_gen)
-        if len(AI_RESPONSE_CACHE) > MAX_AI_CACHE_SIZE: AI_RESPONSE_CACHE.clear()
-        AI_RESPONSE_CACHE[query_key] = response
-        return response
-    finally:
-        ai_semaphore.release()
-
-
 # --- FASTAPI APP ENDPOINTS ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
-    # Added Dense Retriever Loader here
     asyncio.create_task(asyncio.to_thread(load_dense_retriever))
     asyncio.create_task(asyncio.to_thread(load_and_index_dataset))
-    asyncio.create_task(asyncio.to_thread(load_ai_models))
     yield
 
-app = FastAPI(title="Nebulix Fast Hybrid Search Engine", lifespan=lifespan)
+app = FastAPI(title="Nebulix Ultra-Fast Hybrid Engine", lifespan=lifespan)
 app.add_middleware(CORSMiddleware, allow_origins=["*"], allow_credentials=True, allow_methods=["*"], allow_headers=["*"])
 
 @app.get("/suggest")
 async def get_suggestions(q: str = Query(..., min_length=1)):
     q = normalize_text(q).strip()
-    matches = [word for word, count in search_index.suggestions if word.startswith(q)][:7]
+    matches = [word for word, count in search_index.suggestions if word.startswith(q)][:5]
     return {"query": q, "suggestions": matches}
 
 @app.get("/search")
 async def pure_search(q: str = Query(...), content: bool = Query(False), debug: bool = Query(False)):
     req_id = str(uuid.uuid4())
+    cache_key = f"{normalize_text(q)}_{content}_{debug}"
+
+    # ⚡ Cache Hit: Instant response for concurrent/repeated queries (0.001s)
+    if cache_key in QUERY_CACHE:
+        cached_response = QUERY_CACHE[cache_key]
+        cached_response["request_id"] = req_id 
+        return cached_response
+
+    # ⚡ asyncio.to_thread prevents Event Loop blocking so multiple users can search simultaneously
     results, intent_info, corrected_query = await asyncio.to_thread(search_index.search, q, debug)
-    top_20 = results[:STRICT_RESULT_LIMIT]
     
-    for r in top_20:
+    # ⚡ Strictly Top 5 limits for ultra-fast network transfer
+    top_5 = results[:STRICT_RESULT_LIMIT]
+    
+    for r in top_5:
         if content: r["content"] = r.get("_internal_content", "")
         r.pop("_internal_content", None)
             
-    return {
+    final_response = {
         "request_id": req_id, 
         "query": q, 
         "corrected_query": corrected_query,
-        "results_count": len(top_20), 
-        "results": top_20
-    }
-
-async def process_aimode(q: str, include_content: bool, debug: bool, max_ai_tokens: int):
-    req_id = str(uuid.uuid4())
-    cache_key = f"ai_{normalize_text(q)}_{max_ai_tokens}"
-    
-    results, intent_info, corrected_query = await asyncio.to_thread(search_index.search, q, debug)
-    top_20 = results[:STRICT_RESULT_LIMIT]
-    
-    if cache_key in AI_RESPONSE_CACHE:
-        for r in top_20:
-            if include_content: r["content"] = r.get("_internal_content", "")
-            r.pop("_internal_content", None)
-            
-        return {
-            "request_id": req_id, "query": q, "corrected_query": corrected_query, 
-            "ai_response": AI_RESPONSE_CACHE[cache_key], "results_count": len(top_20), 
-            "results": top_20, "sources": [], "cached": True
-        }
-
-    query_tokens = tokenize(q)
-    rag_context_parts = []
-    used_sources = []
-
-    if top_20:
-        valid_sources_count = 0
-        for r in top_20[:3]:
-            doc_content = r.get("_internal_content", "")
-            if include_content: r["content"] = doc_content
-                
-            if doc_content and valid_sources_count < 3:
-                best_chunks = rank_chunks_for_rag(doc_content, query_tokens)
-                if best_chunks:
-                    rag_context_parts.append(f"[{valid_sources_count+1}]: {' ... '.join(best_chunks)}")
-                    used_sources.append({"id": valid_sources_count+1, "title": r["title"], "url": r["url"]})
-                    valid_sources_count += 1
-        
-        for r in top_20: r.pop("_internal_content", None)
-                    
-    system_prompt = (
-        "You are a helpful AI. Answer directly using the context. "
-        "CRITICAL RULE: You MUST write EXACTLY one short, complete sentence. "
-        "Keep it under 15 words. End your sentence with a full stop (.)."
-    )
-    combined_input = f"Context:\n{chr(10).join(rag_context_parts)}\n\nQuery: {q}"
-    
-    if ai_generator:
-        tokenizer = ai_generator.tokenizer
-        encoded_input = tokenizer.encode(combined_input, add_special_tokens=False)
-        if len(encoded_input) > 90:
-            encoded_input = encoded_input[:90]
-            combined_input = tokenizer.decode(encoded_input, skip_special_tokens=True)
-
-    messages = [
-        {"role": "system", "content": system_prompt},
-        {"role": "user", "content": combined_input}
-    ]
-
-    ai_reply = await run_ai_task(messages, max_tokens=max_ai_tokens, query_key=cache_key)
-    
-    return {
-        "request_id": req_id, "query": q, "corrected_query": corrected_query,
-        "ai_response": ai_reply, "results_count": len(top_20), 
-        "results": top_20, "sources": used_sources, "cached": False
+        "results_count": len(top_5), 
+        "results": top_5
     }
 
-@app.get("/aimode")
-async def ai_mode_get(q: str = Query(...), content: bool = Query(False), debug: bool = Query(False)): 
-    return await process_aimode(q, content, debug, max_ai_tokens=20) 
+    # Save to Cache
+    if len(QUERY_CACHE) > MAX_CACHE_SIZE: QUERY_CACHE.clear()
+    QUERY_CACHE[cache_key] = final_response
 
-@app.post("/aimode")
-async def ai_mode_post(q: str = Form(...), content: bool = Form(False), debug: bool = Form(False)): 
-    return await process_aimode(q, content, debug, max_ai_tokens=20)
+    return final_response
 
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run(app, host="0.0.0.0", port=7860, log_level="warning")