Update app.py

app.py

@@ -6,13 +6,13 @@ import logging
 import io
 import json
 import requests
+import urllib.parse
 from flask import Flask, request, jsonify, Response
 from flask_cors import CORS
 from datetime import datetime
 from dotenv import load_dotenv
 from llama_cpp import Llama
 from huggingface_hub import hf_hub_download
-from duckduckgo_search import DDGS
 import pdfplumber
 import docx
 from PIL import Image
@@ -31,11 +31,11 @@ app = Flask(__name__)
 CORS(app)
 
 # --- Configuration & Model Selection ---
-OLLAMA_URL = "http://localhost:11434" # Default for local/colab
+OLLAMA_URL = "http://localhost:11434"
 HF_FALLBACK_REPO = "TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF"
 HF_FALLBACK_FILE = "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf"
 
-# Load Fallback Local Model (Hugging Face)
+# Load Fallback Local Model
 llm_fallback = None
 try:
     logger.info("Loading Hugging Face fallback model...")
@@ -78,151 +78,251 @@ Maintain a helpful, modern, and production-ready chat style (like ChatGPT).
 Current Date: {date}
 """
 
-# --- Tool Brain Logic ---
+# ============ BULLETPROOF SEARCH SYSTEM ============
+
+class SearchManager:
+    """Multi-engine search with automatic fallback. Never fails completely."""
+
+    def __init__(self):
+        self.last_search_time = 0
+        self.min_delay = 2  # seconds between searches
+        self.user_agents = [
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.0",
+            "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.0",
+            "Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.0",
+            "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:120.0) Gecko/20100101 Firefox/120.0"
+        ]
+
+    def _get_headers(self):
+        return {"User-Agent": random.choice(self.user_agents)}
+
+    def _rate_limit(self):
+        """Ensure minimum delay between searches to avoid blocking."""
+        elapsed = time.time() - self.last_search_time
+        if elapsed < self.min_delay:
+            time.sleep(self.min_delay - elapsed)
+        self.last_search_time = time.time()
+
+    def search_duckduckgo(self, query: str, max_results: int = 5) -> list:
+        """Primary search: DuckDuckGo (fastest, most reliable)."""
+        try:
+            self._rate_limit()
+            from duckduckgo_search import DDGS
+
+            # Try with custom headers and timeout
+            with DDGS(headers=self._get_headers(), timeout=15) as ddgs:
+                results = list(ddgs.text(query, max_results=max_results))
+                if results:
+                    logger.info(f"✅ DuckDuckGo: {len(results)} results")
+                    return [{"title": r["title"], "href": r["href"], "body": r["body"]} 
+                            for r in results]
+        except Exception as e:
+            logger.warning(f"DuckDuckGo failed: {e}")
+        return []
+
+    def search_bing(self, query: str, max_results: int = 5) -> list:
+        """Fallback 1: Bing HTML scraping."""
+        try:
+            self._rate_limit()
+            encoded_query = urllib.parse.quote(query)
+            url = f"https://www.bing.com/search?q={encoded_query}"
+
+            response = requests.get(url, headers=self._get_headers(), timeout=10)
+            response.raise_for_status()
+
+            # Extract results using regex patterns
+            html = response.text
+            results = []
+
+            # Pattern 1: Standard Bing results
+            import re
+
+            # Find all result blocks
+            result_blocks = re.findall(
+                r'<li class="b_algo"[^>]*>(.*?)</li>',
+                html,
+                re.DOTALL
+            )
+
+            for block in result_blocks[:max_results]:
+                # Extract title and URL
+                title_match = re.search(r'<a[^>]*href="([^"]*)"[^>]*>(.*?)</a>', block, re.DOTALL)
+                if title_match:
+                    href = title_match.group(1)
+                    title = re.sub(r'<[^>]+>', '', title_match.group(2)).strip()
+
+                    # Extract snippet
+                    snippet_match = re.search(r'<p[^>]*>(.*?)</p>', block, re.DOTALL)
+                    body = re.sub(r'<[^>]+>', '', snippet_match.group(1)).strip() if snippet_match else ""
+
+                    # Clean up URL
+                    if href.startswith('/'):
+                        href = 'https://www.bing.com' + href
+
+                    results.append({"title": title, "href": href, "body": body})
+
+            if results:
+                logger.info(f"✅ Bing: {len(results)} results")
+                return results
+
+        except Exception as e:
+            logger.warning(f"Bing failed: {e}")
+        return []
+
+    def search_wikipedia(self, query: str, max_results: int = 3) -> list:
+        """Fallback 2: Wikipedia API (never blocks, always free)."""
+        try:
+            self._rate_limit()
+            url = "https://en.wikipedia.org/w/api.php"
+            params = {
+                "action": "query",
+                "list": "search",
+                "srsearch": query,
+                "format": "json",
+                "srlimit": max_results
+            }
+            response = requests.get(url, params=params, headers=self._get_headers(), timeout=10)
+            data = response.json()
+
+            results = []
+            for item in data.get("query", {}).get("search", []):
+                title = item["title"]
+                page_url = f"https://en.wikipedia.org/wiki/{title.replace(' ', '_')}"
+                snippet = re.sub(r'<span class="searchmatch">|</span>', '', item["snippet"])
+                results.append({"title": title, "href": page_url, "body": snippet})
+
+            if results:
+                logger.info(f"✅ Wikipedia: {len(results)} results")
+                return results
+
+        except Exception as e:
+            logger.warning(f"Wikipedia failed: {e}")
+        return []
+
+    def search(self, query: str, max_results: int = 5) -> dict:
+        """
+        Master search function. Tries engines in order until one succeeds.
+        Returns: {"engine": str, "results": list, "success": bool}
+        """
+        if not query or not query.strip():
+            return {"engine": "None", "results": [], "success": False, "error": "Empty query"}
+
+        logger.info(f"🔍 Searching: {query}")
+
+        # Engine 1: DuckDuckGo
+        results = self.search_duckduckgo(query, max_results)
+        if results:
+            return {"engine": "DuckDuckGo", "results": results, "success": True, "error": None}
+
+        # Engine 2: Bing
+        results = self.search_bing(query, max_results)
+        if results:
+            return {"engine": "Bing", "results": results, "success": True, "error": None}
+
+        # Engine 3: Wikipedia
+        results = self.search_wikipedia(query, max_results)
+        if results:
+            return {"engine": "Wikipedia", "results": results, "success": True, "error": None}
+
+        # All failed
+        logger.error("❌ All search engines failed")
+        return {
+            "engine": "None", 
+            "results": [], 
+            "success": False, 
+            "error": "All search engines are temporarily unavailable. Please try again in a few minutes."
+        }
+
+# Initialize search manager
+search_manager = SearchManager()
+
+# ============ TOOL DETECTION ============
+
 def detect_tools(message):
-    """
-    Improved intent detection for tool routing.
-    """
-    message = message.lower()
+    """Improved intent detection for tool routing."""
+    message = message.lower().strip()
     tools = []
-    
-    # Search Intent
+
+    # Search Intent - comprehensive keyword list
     search_keywords = [
         "search", "latest", "news", "find out", "who is", "what is the current", 
         "research", "browse", "today", "current", "facts", "data", "tell me about",
-        "what happened", "weather", "stock", "price", "how many", "who won"
+        "what happened", "weather", "stock", "price", "how many", "who won",
+        "temperature", "forecast", "update", "recent", "now", "happening",
+        "look up", "check", "get info", "information about", "details on",
+        "what's", "whats", "how's", "hows", "where is", "when did", "why did",
+        "did ", "does ", "is ", "are ", "was ", "were ", "will ", "can ", "could ",
+        "2024", "2025", "2026", "yesterday", "tomorrow", "this week", "this month"
     ]
+
+    # Check for search keywords
     if any(kw in message for kw in search_keywords):
         tools.append("search")
-    
+
+    # Question patterns that likely need search (who, what, when, where, why, how)
+    question_starters = ["who ", "what ", "when ", "where ", "why ", "how "]
+    if any(message.startswith(kw) for kw in question_starters):
+        # Only add if not already added
+        if "search" not in tools:
+            # Check if it's a factual question (not personal/opinion)
+            personal_words = ["you", "your", "we", "our", "i ", "my ", "me "]
+            if not any(pw in message for pw in personal_words):
+                tools.append("search")
+
     # Image Intent
-    if any(kw in message for kw in ["image", "draw", "visualize", "photo", "paint"]) or \
-       ("create" in message and "image" in message) or \
-       ("make" in message and "image" in message):
+    image_keywords = ["image", "draw", "visualize", "photo", "paint", "picture", "generate image"]
+    if any(kw in message for kw in image_keywords) or        ("create" in message and "image" in message) or        ("make" in message and "image" in message):
         tools.append("image")
-        
+
+    # File analysis intent
+    file_keywords = ["pdf", "document", "file", "analyze file", "read file", "upload"]
+    if any(kw in message for kw in file_keywords):
+        tools.append("file")
+
     return tools
 
-# --- Internet Search Feature ---
-def web_search(query: str, max_results: int = 5) -> list:
-    """Search the web using DuckDuckGo v7.5.0 syntax. No API key required."""
-    try:
-        from duckduckgo_search import DDGS
-        with DDGS() as ddgs:
-            results = list(ddgs.text(query, max_results=max_results))
-            return results
-    except Exception as e:
-        logger.error(f"Search failed: {str(e)}")
-        return [{"error": f"Search failed: {str(e)}"}]
+# ============ FORMATTING ============
 
-def format_results(data: dict) -> str:
+def format_search_results(data: dict) -> str:
     """Format search results with markdown citations."""
-    if not data or not data.get("results"):
-        return "No results found."
-    
-    results = data["results"]
-    if isinstance(results[0], dict) and "error" in results[0]:
-        return results[0]["error"]
-    
-    formatted = [f"Source: {data.get('engine', 'Unknown')}\n"]
+    if not data.get("success"):
+        error = data.get("error", "Search failed")
+        return f"⚠️ {error}"
+
+    results = data.get("results", [])
+    if not results:
+        return "No results found for this query."
+
+    formatted = [f"📡 Source: {data['engine']}
+"]
     for i, r in enumerate(results, 1):
         title = r.get("title", "No title")
         url = r.get("href", "#")
-        body = r.get("body", "No description")[:300]
-        formatted.append(f"{i}. [{title}]({url})\n   {body}")
-    return "\n\n".join(formatted)
-
-def perform_search(query):
-    try:
-        # Clean query for better search results
-        search_query = query.lower().replace('search for', '').replace('find out about', '').replace('/search', '').strip()
-        logger.info(f"🔍 Searching for: {search_query}")
-        
-        results = web_search(search_query)
-        
-        if results and not (isinstance(results[0], dict) and "error" in results[0]):
-            logger.info(f"✅ Found {len(results)} results")
-            return {"engine": "DuckDuckGo", "results": results}, None
-        else:
-            error_msg = results[0]["error"] if results and "error" in results[0] else "No results found."
-            logger.warning(f"❌ Search failed: {error_msg}")
-            return None, error_msg
-            
-    except Exception as e:
-        logger.error(f"⚠️ Global Search Error: {str(e)}")
-        return None, str(e)
-
-# --- Image Generation Feature ---
-@app.route('/api/image', methods=['POST'])
-def generate_image():
-    data = request.json or {}
-    prompt = data.get("prompt", "").strip()
-    if not prompt:
-        return jsonify({"error": "No prompt provided"}), 400
-    
-    try:
-        seed = int(time.time())
-        width = data.get("width", 1024)
-        height = data.get("height", 1024)
-        image_url = f"https://image.pollinations.ai/prompt/{requests.utils.quote(prompt)}?width={width}&height={height}&seed={seed}&nologo=true"
-        
-        return jsonify({
-            "status": "success",
-            "image_url": image_url,
-            "prompt": prompt
-        })
-    except Exception as e:
-        logger.error(f"Image generation failed: {e}")
-        return jsonify({"error": "Image generation failed"}), 500
-
-# --- File Analysis Feature ---
-@app.route('/api/analyze-file', methods=['POST'])
-def analyze_file():
-    if 'file' not in request.files:
-        return jsonify({"error": "No file uploaded"}), 400
-    
-    file = request.files['file']
-    filename = file.filename
-    ext = filename.split('.')[-1].lower()
-    
-    try:
-        text_content = ""
-        if ext == 'pdf':
-            with pdfplumber.open(file) as pdf:
-                text_content = "\n".join([page.extract_text() for page in pdf.pages if page.extract_text()])
-        elif ext == 'docx':
-            doc = docx.Document(file)
-            text_content = "\n".join([para.text for para in doc.paragraphs])
-        elif ext == 'txt':
-            text_content = file.read().decode('utf-8', errors='ignore')
-        elif ext in ['png', 'jpg', 'jpeg', 'webp']:
-            img = Image.open(file)
-            text_content = pytesseract.image_to_string(img)
-        else:
-            return jsonify({"error": f"Unsupported file type: {ext}"}), 400
-
-        if not text_content.strip():
-            return jsonify({"error": "Could not extract text from the file."}), 400
-
-        truncated_text = text_content[:4000]
-        return jsonify({
-            "filename": filename,
-            "content": truncated_text,
-            "full_length": len(text_content),
-            "status": "success"
-        })
-    except Exception as e:
-        logger.error(f"File analysis failed: {e}")
-        return jsonify({"error": f"Failed to process file: {str(e)}"}), 500
+        body = r.get("body", "No description")
+        # Clean up body text
+        body = re.sub(r'\s+', ' ', body).strip()[:300]
+        formatted.append(f"{i}. [{title}]({url})
+   {body}")
+
+    return "
+
+".join(formatted)
+
+def clean_search_query(query: str) -> str:
+    """Clean and optimize query for better search results."""
+    # Remove common prefixes
+    prefixes = [
+        "search for", "find out about", "look up", "check", 
+        "tell me about", "what is", "who is", "where is",
+        "/search", "search:", "find:"
+    ]
+    query = query.lower().strip()
+    for prefix in prefixes:
+        if query.startswith(prefix):
+            query = query[len(prefix):].strip()
+    return query
 
-# --- Time Bot Logic ---
-def get_time_response(message):
-    message = message.lower()
-    time_keywords = ["time", "date", "today", "now", "clock", "day"]
-    if any(re.search(rf"\b{word}\b", message) for word in time_keywords):
-        now = datetime.now()
-        return f"🕒 The current time is **{now.strftime('%H:%M:%S')}**.\n📅 Today is **{now.strftime('%A, %Y-%m-%d')}**."
-    return None
+# ============ API ROUTES ============
 
 @app.route('/')
 def home():
@@ -243,6 +343,37 @@ def login():
     data = request.json or {}
     return jsonify({"user": {"username": data.get("username", "Guest"), "messages_used": 0}}), 200
 
+@app.route('/api/search', methods=['POST'])
+def search_api():
+    """Dedicated search endpoint with bulletproof fallback."""
+    try:
+        data = request.json or {}
+        query = data.get("query", "").strip()
+        max_results = data.get("max_results", 5)
+
+        if not query:
+            return jsonify({"error": "No query provided", "success": False}), 400
+
+        # Perform search with fallback
+        search_data = search_manager.search(query, max_results)
+
+        return jsonify({
+            "success": search_data["success"],
+            "query": query,
+            "engine": search_data["engine"],
+            "results": search_data["results"],
+            "formatted": format_search_results(search_data),
+            "result_count": len(search_data["results"])
+        })
+
+    except Exception as e:
+        logger.error(f"Search API error: {e}")
+        return jsonify({
+            "error": "Search service temporarily unavailable",
+            "success": False,
+            "query": data.get("query", "") if 'data' in dir() else ""
+        }), 500
+
 @app.route('/api/chat', methods=['POST'])
 def chat():
     data = request.json or {}
@@ -251,7 +382,7 @@ def chat():
     memory = data.get("memory", {})
     mode = data.get("mode", "instant")
     is_deep_research = data.get("deep_research", False)
-    
+
     if not message:
         return jsonify({"error": "No message"}), 400
 
@@ -263,15 +394,20 @@ def chat():
     # 2. Tool Detection
     tools_needed = detect_tools(message)
     tool_context = ""
-    
+
     if "search" in tools_needed:
-        search_results, search_error = perform_search(message)
-        if search_results:
-            tool_context += f"\n\n[Web Search Results]:\n{format_results(search_results)}"
-        elif search_error:
-            tool_context += f"\n\n[Search Error]: {search_error}"
+        search_query = clean_search_query(message)
+        search_data = search_manager.search(search_query, max_results=5)
+
+        if search_data["success"]:
+            tool_context += f"
+
+[Web Search Results from {search_data['engine']}]:
+{format_search_results(search_data)}"
         else:
-            tool_context += "\n\n[Search Results]: No relevant information found on the web."
+            tool_context += f"
+
+[Search Status]: {search_data.get('error', 'Search temporarily unavailable')}"
 
     # 3. Dynamic Prompting
     current_date = datetime.now().strftime("%Y-%m-%d")
@@ -282,16 +418,19 @@ def chat():
         "research": "Act as a professional researcher. Provide deep, structured answers with logical sections.",
         "creative": "Act as a creative writer. Use evocative language and focus on ideation."
     }
-    
+
     selected_mode_instruction = mode_instructions.get(mode, mode_instructions["instant"])
     dynamic_system_prompt = SYSTEM_PROMPT.format(date=current_date)
-    dynamic_system_prompt += f"\n[Active Mode]: {mode.upper()} - {selected_mode_instruction}"
-    
+    dynamic_system_prompt += f"
+[Active Mode]: {mode.upper()} - {selected_mode_instruction}"
+
     if is_deep_research:
-        dynamic_system_prompt += "\n[DEEP RESEARCH ACTIVE]: Use a multi-step reasoning approach. Analyze thoroughly."
+        dynamic_system_prompt += "
+[DEEP RESEARCH ACTIVE]: Use a multi-step reasoning approach. Analyze thoroughly."
 
     if memory:
-        dynamic_system_prompt += f"\n[User Memory]: {json.dumps(memory)}"
+        dynamic_system_prompt += f"
+[User Memory]: {json.dumps(memory)}"
 
     full_prompt = f"{message}{tool_context}"
 
@@ -305,7 +444,7 @@ def chat():
                 ollama_role = "assistant" if role == "ai" else "user"
                 messages.append({"role": ollama_role, "content": h.get('content', '')})
             messages.append({"role": "user", "content": full_prompt})
-            
+
             response = requests.post(
                 f"{OLLAMA_URL}/api/chat",
                 json={
@@ -317,7 +456,7 @@ def chat():
                 timeout=5,
                 stream=True
             )
-            
+
             if response.status_code == 200:
                 for line in response.iter_lines():
                     if line:
@@ -328,7 +467,8 @@ def chat():
                                 "source": "colab",
                                 "provider": "Ollama (Phi-3)",
                                 "tools_used": tools_needed
-                            }) + "\n"
+                            }) + "
+"
                 return
 
         except Exception as colab_err:
@@ -337,19 +477,26 @@ def chat():
         # Step B: Fallback to Local HF Model
         if llm_fallback:
             try:
-                llama_prompt = f"<|system|>\n{dynamic_system_prompt}</s>\n"
+                llama_prompt = f"<|system|>
+{dynamic_system_prompt}</s>
+"
                 for h in history:
                     role = h.get('role', 'user')
-                    llama_prompt += f"<|{role}|>\n{h.get('content', '')}</s>\n"
-                llama_prompt += f"<|user|>\n{full_prompt}</s>\n<|assistant|>\n"
-                
+                    llama_prompt += f"<|{role}|>
+{h.get('content', '')}</s>
+"
+                llama_prompt += f"<|user|>
+{full_prompt}</s>
+<|assistant|>
+"
+
                 output = llm_fallback(
                     llama_prompt,
                     max_tokens=512,
                     stop=["</s>", "<|user|>"],
                     stream=True
                 )
-                
+
                 for chunk in output:
                     token = chunk["choices"][0]["text"]
                     if token:
@@ -358,48 +505,101 @@ def chat():
                             "source": "hf",
                             "provider": "Nexa Local (HF Fallback)",
                             "tools_used": tools_needed
-                        }) + "\n"
+                        }) + "
+"
             except Exception as hf_err:
                 logger.error(f"HF Fallback failed: {hf_err}")
-                yield json.dumps({"error": "All backends failed"}) + "\n"
+                yield json.dumps({"error": "All backends failed"}) + "
+"
         else:
-            yield json.dumps({"error": "No backend available"}) + "\n"
+            yield json.dumps({"error": "No backend available"}) + "
+"
 
     return Response(generate(), mimetype='application/x-ndjson')
 
+# --- Time Bot Logic ---
+def get_time_response(message):
+    message = message.lower()
+    time_keywords = ["time", "date", "today", "now", "clock", "day"]
+    if any(re.search(rf"\b{word}\b", message) for word in time_keywords):
+        now = datetime.now()
+        return f"🕒 The current time is **{now.strftime('%H:%M:%S')}**.
+📅 Today is **{now.strftime('%A, %Y-%m-%d')}**."
+    return None
+
+# --- Image Generation Feature ---
+@app.route('/api/image', methods=['POST'])
+def generate_image():
+    data = request.json or {}
+    prompt = data.get("prompt", "").strip()
+    if not prompt:
+        return jsonify({"error": "No prompt provided"}), 400
+
+    try:
+        seed = int(time.time())
+        width = data.get("width", 1024)
+        height = data.get("height", 1024)
+        image_url = f"https://image.pollinations.ai/prompt/{requests.utils.quote(prompt)}?width={width}&height={height}&seed={seed}&nologo=true"
+
+        return jsonify({
+            "status": "success",
+            "image_url": image_url,
+            "prompt": prompt
+        })
+    except Exception as e:
+        logger.error(f"Image generation failed: {e}")
+        return jsonify({"error": "Image generation failed"}), 500
+
+# --- File Analysis Feature ---
+@app.route('/api/analyze-file', methods=['POST'])
+def analyze_file():
+    if 'file' not in request.files:
+        return jsonify({"error": "No file uploaded"}), 400
+
+    file = request.files['file']
+    filename = file.filename
+    ext = filename.split('.')[-1].lower()
+
+    try:
+        text_content = ""
+        if ext == 'pdf':
+            with pdfplumber.open(file) as pdf:
+                text_content = "\n".join([page.extract_text() for page in pdf.pages if page.extract_text()])
+        elif ext == 'docx':
+            doc = docx.Document(file)
+            text_content = "\n".join([para.text for para in doc.paragraphs])
+        elif ext == 'txt':
+            text_content = file.read().decode('utf-8', errors='ignore')
+        elif ext in ['png', 'jpg', 'jpeg', 'webp']:
+            img = Image.open(file)
+            text_content = pytesseract.image_to_string(img)
+        else:
+            return jsonify({"error": f"Unsupported file type: {ext}"}), 400
+
+        if not text_content.strip():
+            return jsonify({"error": "Could not extract text from the file."}), 400
+
+        truncated_text = text_content[:4000]
+        return jsonify({
+            "filename": filename,
+            "content": truncated_text,
+            "full_length": len(text_content),
+            "status": "success"
+        })
+    except Exception as e:
+        logger.error(f"File analysis failed: {e}")
+        return jsonify({"error": f"Failed to process file: {str(e)}"}), 500
+
 @app.route('/api/status', methods=['GET'])
 def status_check():
     return jsonify({
         "status": "online",
         "backend": "Nexa AI Unified",
         "timestamp": time.ctime(),
-        "fallback_loaded": llm_fallback is not None
+        "fallback_loaded": llm_fallback is not None,
+        "search_engines": ["DuckDuckGo", "Bing", "Wikipedia"]
     })
 
-@app.route('/api/search', methods=['POST'])
-def search_api():
-    try:
-        data = request.json or {}
-        query = data.get("query", "").strip()
-        if not query:
-            return jsonify({"error": "No query provided"}), 400
-        
-        search_data, error = perform_search(query)
-        if error and not search_data:
-            return jsonify({"response": error, "results": []})
-        if not search_data:
-            return jsonify({"response": "No results found.", "results": []})
-            
-        return jsonify({
-            "response": format_results(search_data),
-            "results": search_data["results"],
-            "engine": search_data["engine"],
-            "status": "success"
-        })
-    except Exception as e:
-        logger.error(f"Search API crashed: {e}")
-        return jsonify({"error": "Search API internal error", "response": f"Internal error: {str(e)}"}), 500
-
 @app.errorhandler(500)
 def internal_error(error):
     return jsonify({"error": "Internal Server Error", "message": "An unexpected error occurred on the server."}), 500