Update app.py

app.py

@@ -7,58 +7,80 @@ import re
 import time
 import multiprocessing
 import urllib.parse
-from datetime import datetime
 from contextlib import asynccontextmanager
-from fastapi import FastAPI, Query, Request, UploadFile, File, Form
+from fastapi import FastAPI, Query, Request, Form
 from fastapi.responses import JSONResponse
 from fastapi.middleware.cors import CORSMiddleware
 from huggingface_hub import hf_hub_download
 from rank_bm25 import BM25Okapi
 import torch
-from PIL import Image
-import io
+import aiohttp
+from bs4 import BeautifulSoup
+from langdetect import detect
 
-# DIRECT IMPORTS TO FIX THE PIPELINE BUG
-from transformers import pipeline, BlipProcessor, BlipForConditionalGeneration
+# DIRECT IMPORTS
+from transformers import pipeline
 
-# --- 1. SETUP & CPU ALLOCATION (40% for AI) ---
+# --- 1. SETUP & CPU ALLOCATION ---
 TOTAL_CORES = multiprocessing.cpu_count()
 AI_CORES = max(1, int(TOTAL_CORES * 0.4))
 torch.set_num_threads(AI_CORES)
 print(f"🖥️ Total Cores: {TOTAL_CORES} | Allocating {AI_CORES} cores strictly to AI.")
 
 raw_data = []
+suggestion_list = []
 bm25_index = None
 MAX_CONCURRENT_AI = max(1, AI_CORES)
 ai_semaphore = asyncio.Semaphore(MAX_CONCURRENT_AI)
 ai_generator = None
-vision_processor = None
-vision_model = None
+
+# --- TRACKING & TRUST SYSTEM ---
+URL_STATS = {} # Format: { "https://example.com": {"user_visits": 0, "ai_visits": 0, "is_trusted": False} }
 
 # --- AI CACHING SYSTEM ---
 AI_RESPONSE_CACHE = {}
 MAX_CACHE_SIZE = 5000
-ADULT_KEYWORDS = {"porn", "sex", "nude", "nsfw", "xxx", "adult", "erotic", "onlyfans"}
 STOP_WORDS = {"the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for", "of", "with", "is", "are"}
 HF_TOKEN = os.getenv("HF_TOKEN")
 BANNED_IPS = set()
 IP_TRACKER = {}
 
-# --- 2. ADVANCED NLP & IN-MEMORY INDEXING ---
+# 🔥 MASSIVE DESI & MODERN ADULT KEYWORDS LIST
+ADULT_KEYWORDS = {
+    "porn", "sex", "nude", "nsfw", "xxx", "adult", "erotic", "onlyfans", 
+    "mms", "chudai", "bhabhi", "devar", "savita bhabhi", "xvideos", "pornhub", 
+    "brazzers", "mia khalifa", "bf video", "blue film", "kamasutra", "nude",
+    "boobs", "tits", "ass", "booty", "naked", "desi porn", "hot desi", "xnxx",
+    "kacha badam", "ullu", "kooku", "mastram", "gandi baat", "nangi", "nanga",
+    "sex tape", "milf", "stepmom", "incest", "playboy", "scandal", "leaked"
+}
+
+# 🔥 MASSIVE LANGUAGE MAPPER (50+ Languages)
+LANG_MAP = {
+    "en": "English", "hi": "Hindi", "mr": "Marathi", "bn": "Bengali", "ta": "Tamil", 
+    "te": "Telugu", "gu": "Gujarati", "ur": "Urdu", "kn": "Kannada", "ml": "Malayalam", 
+    "pa": "Punjabi", "or": "Odia", "ne": "Nepali", "fr": "French", "es": "Spanish", 
+    "de": "German", "ru": "Russian", "ja": "Japanese", "zh-cn": "Chinese (Simplified)", 
+    "zh-tw": "Chinese (Traditional)", "ar": "Arabic", "pt": "Portuguese", "it": "Italian", 
+    "ko": "Korean", "id": "Indonesian", "tr": "Turkish", "nl": "Dutch", "vi": "Vietnamese"
+}
+
+# --- 2. ADVANCED NLP, INDEXING & LANGUAGE ---
 def tokenize(text):
     if not text: return []
     tokens = re.findall(r'[a-z0-9]+', str(text).lower())
     return [t for t in tokens if t not in STOP_WORDS]
 
-def extract_nested_data(obj):
-    if isinstance(obj, dict):
-        return " ".join(extract_nested_data(v) for v in obj.values())
-    elif isinstance(obj, list):
-        return " ".join(extract_nested_data(v) for v in obj)
-    return str(obj)
+def detect_language_name(text):
+    try:
+        if not text or len(text.strip()) < 10: return "Unknown"
+        code = detect(text)
+        return LANG_MAP.get(code, code.upper()) # Agar list me nahi mila toh code return karega
+    except:
+        return "Unknown"
 
 def load_and_index_dataset():
-    global bm25_index, raw_data
+    global bm25_index, raw_data, suggestion_list
     print("📥 Loading Dataset & Building Deep Index...")
     dataset_path = "dataset.jsonl"
     
@@ -81,98 +103,140 @@ def load_and_index_dataset():
                 if line.strip():
                     try:
                         doc = json.loads(line)
+                        url = doc.get("url", "")
+                        
+                        if url not in URL_STATS:
+                            URL_STATS[url] = {"user_visits": 0, "ai_visits": 0, "is_trusted": False}
+                            
+                        # Extract language and append to document
+                        combined_text = str(doc.get("title", "")) + " " + str(doc.get("description", ""))
+                        doc["language"] = detect_language_name(combined_text)
+                        
                         raw_data.append(doc)
                         
-                        title_tokens = tokenize(doc.get("title", ""))
+                        title_str = doc.get("title", "")
+                        if title_str and len(title_str) < 60:
+                            suggestion_list.append(title_str.lower())
+                        
+                        title_tokens = tokenize(title_str)
                         desc_tokens = tokenize(doc.get("description", ""))
-                        meta_tokens = tokenize(doc.get("meta_tags", {}).get("description", ""))
-                        url_tokens = tokenize(doc.get("url", ""))
-                        specific_tokens = tokenize(extract_nested_data(doc.get("specific_data", {})))
+                        url_tokens = tokenize(url)
                         
-                        boosted_tokens = (title_tokens * 5) + (desc_tokens * 3) + meta_tokens + url_tokens + (specific_tokens * 2)
+                        boosted_tokens = (title_tokens * 5) + (desc_tokens * 3) + url_tokens
                         tokenized_corpus.append(boosted_tokens)
                     except: 
                         pass
                     
         if tokenized_corpus:
             print("⚡ Building High-Speed BM25 Okapi Index...")
+            suggestion_list = sorted(list(set(suggestion_list)))
             bm25_index = BM25Okapi(tokenized_corpus)
             print(f"🚀 Indexing Complete! {len(raw_data)} records ready.")
     else:
         print("❌ Dataset file not found!")
 
 def load_ai_models():
-    global ai_generator, vision_processor, vision_model
-    print("🤖 Loading Lightweight AI Models (Text & Vision)...")
+    global ai_generator
+    print("🤖 Loading Modern Fast Text AI Model...")
     try:
-        # 1. Text AI
-        ai_generator = pipeline("text-generation", model="Qwen/Qwen2.5-0.5B-Instruct", device=-1, dtype=torch.float32)
-        
-        # 2. Vision AI
-        print("👁️ Loading Vision AI...")
-        vision_processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
-        vision_model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")
-        
-        print("✅ All AI Models Loaded! System ready.")
+        # Chota, modern aur tezz model
+        ai_generator = pipeline("text-generation", model="Qwen/Qwen2.5-0.5B-Instruct", device=-1, torch_dtype=torch.float32)
+        print("✅ AI Model Loaded! System ready.")
     except Exception as e:
         print(f"❌ Model Loading Failed: {e}")
 
-# --- 3. CORE SEARCH ALGORITHM ---
+# --- 3. SMART SCRIPT RAG: EARLY STOPPING CHUNKING ---
+def chunk_text(text, chunk_size=120):
+    words = text.split()
+    return [" ".join(words[i:i+chunk_size]) for i in range(0, len(words), chunk_size)]
+
+async def scrape_and_find_best_chunk(url, query):
+    """Script website visit karegi, sirf Headers & Paragraphs legi, aur best chunk lekar ruk jayegi"""
+    try:
+        async with aiohttp.ClientSession() as session:
+            # Sirf 3 second ka timeout taki endpoint na atke
+            async with session.get(url, timeout=3) as resp:
+                if resp.status == 200:
+                    html = await resp.text()
+                    soup = BeautifulSoup(html, "html.parser")
+                    
+                    # Sirf Paragraphs aur Headers nikal rahe hain kachra avoid karne ke liye
+                    tags_to_extract = ['p', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6']
+                    text = " ".join([tag.get_text(strip=True) for tag in soup.find_all(tags_to_extract)])
+                    
+                    if not text: return ""
+                    
+                    chunks = chunk_text(text)
+                    query_tokens = set(tokenize(query))
+                    
+                    best_chunk = ""
+                    max_score = 0
+                    # Threshold: Agar query ke aade tokens mil gaye chunk mein toh wahi ruk jao
+                    early_stop_threshold = max(1, len(query_tokens) // 2) 
+
+                    for chunk in chunks:
+                        chunk_tokens = set(tokenize(chunk))
+                        score = len(query_tokens.intersection(chunk_tokens))
+                        
+                        if score > max_score:
+                            max_score = score
+                            best_chunk = chunk
+                            
+                        # 🔥 EARLY STOPPING: Jo kaam ka chunk mila wahi liya, aage process nahi kiya
+                        if max_score >= early_stop_threshold and max_score > 0:
+                            break
+                            
+                    return best_chunk
+    except Exception:
+        return "" # Scraping failed (timeout/block), ignore quietly
+    return ""
+
+# --- 4. CORE SEARCH ALGORITHM & RANKING ---
 async def perform_core_search(raw_query: str):
     if not raw_data or not bm25_index:
         return [], "Search index not ready.", 0
 
-    site_filter = None
-    tag_filter = None
-
-    site_match = re.search(r'site:([^\s]+)', raw_query, re.IGNORECASE)
-    if site_match:
-        site_filter = site_match.group(1).lower()
-        raw_query = raw_query.replace(site_match.group(0), "")
-        
-    tag_match = re.search(r'tag:([^\s]+)', raw_query, re.IGNORECASE)
-    if tag_match:
-        tag_filter = tag_match.group(1).lower()
-        raw_query = raw_query.replace(tag_match.group(0), "")
-
-    query = raw_query.strip()
+    query = raw_query.strip().lower()
     query_tokens = tokenize(query)
 
-    if not query_tokens and not site_filter and not tag_filter: 
-        return [], "Invalid Query", 0
-
-    user_wants_adult = any(word in ADULT_KEYWORDS for word in query_tokens)
+    # 🚨 SMART ADULT FILTER (Using 'in' operator to catch hidden adult queries)
+    user_wants_adult = any(adult_word in query for adult_word in ADULT_KEYWORDS)
+    
     scores = bm25_index.get_scores(query_tokens) if query_tokens else [1.0] * len(raw_data)
-
     scored_results = []
     seen_urls = set() 
 
     for index, score in enumerate(scores):
-        if score > 0.5 or not query_tokens:
+        if score > 0.1 or not query_tokens:
             doc = raw_data[index]
             doc_url = doc.get("url", "")
             
             if doc_url in seen_urls: continue
             parsed_url = urllib.parse.urlparse(doc_url)
+            domain = parsed_url.netloc.lower()
             
-            if site_filter and site_filter not in parsed_url.netloc.lower(): continue
-            doc_tag = str(doc.get("tag", "general")).lower()
-            if tag_filter and tag_filter != doc_tag: continue
-            
-            is_adult = doc_tag in ["adult", "nsfw"] or any(w in str(doc).lower() for w in ADULT_KEYWORDS)
-            if not user_wants_adult and is_adult: continue 
+            # Text combine to check adult words in document
+            doc_text = (str(doc.get("title", "")) + " " + str(doc.get("description", "")) + " " + doc_url).lower()
+            is_adult_doc = doc.get("tag", "general").lower() in ["adult", "nsfw"] or any(aw in doc_text for aw in ADULT_KEYWORDS)
             
+            # Agar user ki query normal hai, toh adult result filter ho jayega
+            if not user_wants_adult and is_adult_doc:
+                continue 
+                
             final_score = score
-            exact_phrase = query.lower()
-            doc_title = str(doc.get("title", "")).lower()
             
-            if exact_phrase == doc_title: final_score *= 5.0
-            elif exact_phrase in doc_title: final_score *= 3.0
-            if exact_phrase in str(doc.get("description", "")).lower(): final_score *= 1.8
+            # 🔥 DOMAIN RANKING BOOST
+            if query.replace(" ", "") in domain.replace(" ", ""):
+                final_score *= 10.0 # Huge boost for direct domain match
+            elif query in doc.get("title", "").lower():
+                final_score *= 3.0
                 
-            path = parsed_url.path.strip("/")
-            if not path: final_score *= 1.5 
-            else: final_score *= (0.90 ** path.count("/"))
+            # 🔥 TRUST RANKING BOOST
+            stats = URL_STATS.get(doc_url, {})
+            if stats.get("is_trusted", False):
+                final_score *= 1.5 
+            
+            final_score += (stats.get("user_visits", 0) * 0.05)
             
             seen_urls.add(doc_url)
             scored_results.append((final_score, doc))
@@ -184,16 +248,11 @@ async def perform_core_search(raw_query: str):
     final_results = [{"match_score": round(s, 2), **doc} for s, doc in scored_results[:100]]
     return final_results, prediction, best_score
 
-# --- AI GENERATION & CACHE HELPER ---
+# --- AI GENERATION HELPER ---
 def _generate_text(messages, max_tokens: int):
-    result = ai_generator(messages, max_new_tokens=max_tokens, do_sample=True, temperature=0.3, top_p=0.85)
-    return result[0]['generated_text'][-1]['content']
-
-def _generate_image_review(image: Image):
-    inputs = vision_processor(image, return_tensors="pt")
-    with torch.no_grad():
-        out = vision_model.generate(**inputs, max_new_tokens=50)
-    return vision_processor.decode(out[0], skip_special_tokens=True).capitalize()
+    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=True, temperature=0.3, top_p=0.85)
+    return result[0]['generated_text'].split("Assistant:")[-1].strip()
 
 async def run_ai_task(messages, max_tokens: int, query_key: str):
     if not ai_generator: return "⚠️ AI Model is starting up."
@@ -205,16 +264,15 @@ async def run_ai_task(messages, max_tokens: int, query_key: str):
         AI_RESPONSE_CACHE[query_key] = response
         return response
 
-# --- 4. FASTAPI APP & ENDPOINTS ---
+# --- 5. FASTAPI APP & ENDPOINTS ---
 @asynccontextmanager
 async def lifespan(app: FastAPI):
     asyncio.create_task(asyncio.to_thread(load_and_index_dataset))
     asyncio.create_task(asyncio.to_thread(load_ai_models))
     yield
 
-app = FastAPI(title="Nebulix Advanced SEO & Visual API Engine", lifespan=lifespan)
+app = FastAPI(title="Nebulix Advanced Text AI & RAG Engine", lifespan=lifespan)
 
-# CORS FIX: allow_origins aur allow_methods mein empty sting [""] ki jagah ["*"] chahiye
 app.add_middleware(
     CORSMiddleware, 
     allow_origins=["*"], 
@@ -223,31 +281,25 @@ app.add_middleware(
     allow_headers=["*"]
 )
 
-@app.middleware("http")
-async def rate_limit_middleware(request: Request, call_next):
-    client_ip = request.client.host if request.client else "127.0.0.1"
-    
-    if client_ip in BANNED_IPS:
-        return JSONResponse(status_code=403, content={"error": "BANNED: Your IP is permanently banned."})
-
-    current_time = int(time.time())
-    if client_ip not in IP_TRACKER:
-        IP_TRACKER[client_ip] = {"time": current_time, "count": 1}
-    else:
-        if IP_TRACKER[client_ip]["time"] == current_time: 
-            IP_TRACKER[client_ip]["count"] += 1
-        else: 
-            IP_TRACKER[client_ip] = {"time": current_time, "count": 1}
-            
-    if IP_TRACKER[client_ip]["count"] >= 6:
-        BANNED_IPS.add(client_ip)
-        return JSONResponse(status_code=403, content={"error": "IP BANNED: Exceeded limit."})
-
-    return await call_next(request)
-
-@app.get("/")
-async def health_check():
-    return {"status": "ok", "message": "Nebulix API Engine is running smoothly."}
+# 🔥 1. AUTO-SUGGESTIONS ENDPOINT
+@app.get("/suggest")
+async def get_suggestions(q: str = Query(..., min_length=1)):
+    q = q.lower()
+    matches = [s for s in suggestion_list if s.startswith(q)][:7]
+    return {"query": q, "suggestions": matches}
+
+# 🔥 2. URL TRACKING & TRUST ENDPOINTS
+@app.post("/track-click")
+async def track_url_click(url: str = Query(...)):
+    if url not in URL_STATS:
+        URL_STATS[url] = {"user_visits": 0, "ai_visits": 0, "is_trusted": False}
+    URL_STATS[url]["user_visits"] += 1
+    return {"status": "success", "url": url, "visits": URL_STATS[url]["user_visits"]}
+
+@app.get("/url-stats")
+async def get_url_stats(url: str = Query(...)):
+    stats = URL_STATS.get(url, {"user_visits": 0, "ai_visits": 0, "is_trusted": False})
+    return {"url": url, "stats": stats}
 
 @app.get("/search")
 async def pure_search(q: str = Query(...)):
@@ -255,113 +307,64 @@ async def pure_search(q: str = Query(...)):
     results, prediction, _ = await perform_core_search(q)
     return {"request_id": req_id, "query": q, "results_count": len(results), "results": results}
 
-@app.get("/aimode")
-async def ai_mode_short(q: str = Query(...)):
-    req_id = str(uuid.uuid4())
-    results, _, _ = await perform_core_search(q)
-    if not results: 
-        return {"request_id": req_id, "ai_response": "I couldn't find any results.", "results": []}
-
-    context = " ".join([f"{r.get('title', '')} - {r.get('description', '')}" for r in results[:3]])
-    messages = [
-        {"role": "system", "content": "Provide a brief 2-3 sentence summary based only on the provided context."},
-        {"role": "user", "content": f"Query: {q}\nContext: {context}"}
-    ]
-
-    ai_reply = await run_ai_task(messages, 150, query_key=f"short_{q}")
-    return {"request_id": req_id, "ai_response": ai_reply, "results": results}
-
-# 1. PURANA CHAT API (Current UI ke liye)
-@app.get("/aimodechat")
-async def ai_mode_chat(q: str = Query(...)):
-    req_id = str(uuid.uuid4())
-    results, _, _ = await perform_core_search(q)
-
-    context_parts = [f"Source [{i+1}]: {r.get('title')} - {r.get('description')}" for i, r in enumerate(results[:5])]
-    messages = [
-        {"role": "system", "content": "You are a Smart AI Search Assistant. Use search sources to answer accurately."},
-        {"role": "user", "content": f"User Query: {q}\n\nContext:\n{chr(10).join(context_parts)}"}
-    ]
-
-    ai_reply = await run_ai_task(messages, 400, query_key=f"chat_{q}") 
-    return {"request_id": req_id, "ai_response": ai_reply, "results": results}
-
-# 2. NAYA CHAT API (Future UI - Image + Text Chat ke liye)
+# 🔥 3. SMART RAG CHAT API (Only Text & Scraped Chunks)
 @app.post("/aimodechat")
-async def ai_mode_chat_vision(q: str = Form(...), file: UploadFile = File(None)):
+async def ai_mode_chat(q: str = Form(...)):
     req_id = str(uuid.uuid4())
-    vision_context = ""
     
-    # Agar user ne chat me image upload ki hai, toh AI image ko decode karega
-    if file and vision_model:
-        try:
-            image_bytes = await file.read()
-            img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-            async with ai_semaphore:
-                ai_review = await asyncio.to_thread(_generate_image_review, img)
-            vision_context = f"\n[User uploaded an image showing: {ai_review}]\n"
-        except Exception:
-            vision_context = "\n[User uploaded an image but it could not be analyzed.]\n"
+    # AI Logic to decide RAG need
+    needs_rag = any(w in q.lower() for w in ["what", "who", "where", "how", "why", "tell me", "explain", "latest"])
+    
+    results, _, _ = await perform_core_search(q)
+    rag_context = ""
+    used_sources = []
 
-    # Search query combining text and vision
-    search_query = f"{q} {vision_context}".strip()
-    results, _, _ = await perform_core_search(search_query)
+    if needs_rag and results:
+        top_urls = results[:10]
+        
+        # Script asynchronously scrapes multiple URLs at once
+        tasks = [scrape_and_find_best_chunk(doc["url"], q) for doc in top_urls]
+        scraped_chunks = await asyncio.gather(*tasks)
+        
+        context_parts = []
+        for i, chunk in enumerate(scraped_chunks):
+            doc = top_urls[i]
+            url = doc["url"]
+            
+            # Trust Tracking: Mark AI visits
+            if url not in URL_STATS: URL_STATS[url] = {"user_visits": 0, "ai_visits": 0, "is_trusted": False}
+            URL_STATS[url]["ai_visits"] += 1
+            if URL_STATS[url]["ai_visits"] >= 100:
+                URL_STATS[url]["is_trusted"] = True
+
+            # Sirf kaam ka chunk (Early stopped chunk) lenge ya fall back pe description
+            if chunk:
+                context_parts.append(f"Source [{i+1}] ({url}): {chunk}")
+                used_sources.append(doc)
+            else:
+                context_parts.append(f"Source [{i+1}] ({url}): {doc.get('description', '')}")
+                used_sources.append(doc)
+                
+        rag_context = "\n".join(context_parts)
 
-    context_parts = [f"Source [{i+1}]: {r.get('title')} - {r.get('description')}" for i, r in enumerate(results[:5])]
+    system_prompt = "You are a Smart AI Search Assistant. Use the provided search chunks to answer. Always mention the Source URL if you use information from it."
+    if not needs_rag:
+        system_prompt = "You are a helpful AI Assistant. Answer the user's query conversationally."
 
     messages = [
-        {"role": "system", "content": "You are a Smart AI Search Assistant capable of understanding text and visual context. Use the provided search sources and image details to answer accurately."},
-        {"role": "user", "content": f"User Query: {q}{vision_context}\n\nContext:\n{chr(10).join(context_parts)}"}
+        {"role": "system", "content": system_prompt},
+        {"role": "user", "content": f"Query: {q}\n\nLive Context Data:\n{rag_context}" if needs_rag else f"Query: {q}"}
     ]
 
-    # Generate Chat response
-    cache_key = f"chat_{q}_{len(vision_context)}"
-    ai_reply = await run_ai_task(messages, 400, query_key=cache_key) 
-
-    return {"request_id": req_id, "ai_response": ai_reply, "results": results}
+    ai_reply = await run_ai_task(messages, 400, query_key=f"chat_{q}_{needs_rag}") 
 
-# IMAGE SEARCH (Fixed: Same JSON structure as normal text search)
-@app.post("/image-search")
-async def reverse_image_search(file: UploadFile = File(...)):
-    if not vision_model:
-        return {"error": "Vision AI Model is still loading."}
-
-    req_id = str(uuid.uuid4())
-
-    try:
-        image_bytes = await file.read()
-        img = Image.open(io.BytesIO(image_bytes)).convert("RGB")
-        
-        # 1. Vision AI process karega
-        async with ai_semaphore:
-            ai_review = await asyncio.to_thread(_generate_image_review, img)
-            
-        # 2. Text Search hoga vision ke basis pe
-        raw_results, _, _ = await perform_core_search(ai_review)
-        visual_results = []
-        
-        # 3. DIRECTLY append the original FULL document
-        for doc in raw_results:
-            is_adult = str(doc.get("tag", "general")).lower() in ["adult", "nsfw"] or any(w in str(doc).lower() for w in ADULT_KEYWORDS)
-            if is_adult: continue 
-            
-            # Pura document direct bhej rahe hain bina modify kiye 
-            # jisse exact text search wala JSON format barkarar rahe
-            visual_results.append(doc)
-            
-            if len(visual_results) >= 40: break
-                
-        # 4. Same structure return karenge
-        return {
-            "request_id": req_id,
-            "query": f"Image Search Analysis: {ai_review}", # Taki UI me ye "query" ki tarah display ho
-            "results_count": len(visual_results),
-            "results": visual_results
-        }
-        
-    except Exception as e:
-        return {"error": f"Image processing failed: {str(e)}"}
+    return {
+        "request_id": req_id, 
+        "ai_response": ai_reply, 
+        "rag_used": needs_rag,
+        "sources": used_sources,
+        "results": results[:15]
+    }
 
-# DUNDAR NAME FIX: name == "main" ki jagah __name__ == "__main__"
 if __name__ == "__main__":
-    uvicorn.run(app, host="0.0.0.0", port=7860)
+    uvicorn.run("main:app", host="0.0.0.0", port=7860, reload=True)