Update app.py

app.py

@@ -1,9 +1,16 @@
 import os
 import json
 import requests
-from fastapi import FastAPI, Request
+from datetime import datetime
+from typing import List, Dict, Optional
+from fastapi import FastAPI, Request, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
 from openai import OpenAI
+import logging
+
+# --- Configure Logging ---
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
 
 # --- Load API Keys from Environment Variables ---
 GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
@@ -11,119 +18,343 @@ GOOGLE_CX = os.getenv("GOOGLE_CX")
 LLM_API_KEY = os.getenv("LLM_API_KEY")
 LLM_BASE_URL = os.getenv("LLM_BASE_URL", "https://api-15i2e8ze256bvfn6.aistudio-app.com/v1")
 
-# --- Web Search Tool Implementation ---
-def Google_Search_tool(queries: list) -> list:
+# --- Enhanced System Prompt ---
+SYSTEM_PROMPT = """You are an intelligent AI assistant with access to real-time web search capabilities. When answering questions:
+
+1. **Search Strategy**: Use web search when you need current information, recent events, or specific facts that may have changed.
+
+2. **Source Integration**: When using search results, synthesize information from multiple sources and clearly indicate when information comes from your search results.
+
+3. **Quality Response Guidelines**:
+   - Provide comprehensive, well-structured answers
+   - Cite sources when using search results
+   - If search results are contradictory, mention the discrepancy
+   - Prioritize recent and authoritative sources
+   - If search results are insufficient, acknowledge limitations
+
+4. **Response Format**:
+   - Start with a direct answer to the user's question
+   - Provide supporting details and context
+   - Include relevant examples when helpful
+   - End with additional insights or related information if relevant
+
+5. **Current Context**: Today's date is {current_date}. Use this for time-sensitive queries.
+
+Remember to be helpful, accurate, and transparent about your information sources."""
+
+# --- Enhanced Web Search Tool Implementation ---
+def google_search_tool(queries: List[str], num_results: int = 5) -> List[Dict]:
+    """
+    Enhanced Google Custom Search with better error handling and result formatting
+    """
     if not GOOGLE_API_KEY or not GOOGLE_CX:
-        print("ERROR: GOOGLE_API_KEY or GOOGLE_CX environment variables not set.")
+        logger.error("GOOGLE_API_KEY or GOOGLE_CX environment variables not set.")
         return []
 
-    query = queries[0]
-    print(f"Executing Google Custom Search for: '{query}'")
+    if not queries or not queries[0].strip():
+        logger.warning("Empty search query provided")
+        return []
+
+    query = queries[0].strip()
+    logger.info(f"Executing Google Custom Search for: '{query}'")
     
     search_url = "https://www.googleapis.com/customsearch/v1"
-    params = {"key": GOOGLE_API_KEY, "cx": GOOGLE_CX, "q": query, "num": 3}
+    params = {
+        "key": GOOGLE_API_KEY, 
+        "cx": GOOGLE_CX, 
+        "q": query, 
+        "num": min(num_results, 10),  # Google API max is 10
+        "dateRestrict": "m6"  # Prioritize results from last 6 months for freshness
+    }
     
     try:
-        response = requests.get(search_url, params=params, timeout=10)
+        response = requests.get(search_url, params=params, timeout=15)
         response.raise_for_status()
         search_results = response.json()
         
-        # Structure the results for internal use
+        if "items" not in search_results:
+            logger.warning(f"No search results found for query: '{query}'")
+            return []
+        
+        # Enhanced result parsing with better data validation
         parsed_results = []
         for item in search_results.get("items", []):
+            title = item.get("title", "").strip()
+            url = item.get("link", "").strip()
+            snippet = item.get("snippet", "").strip()
+            
+            # Skip results with missing essential information
+            if not title or not url or not snippet:
+                continue
+                
+            # Extract publication date if available
+            pub_date = None
+            if "pagemap" in item and "metatags" in item["pagemap"]:
+                for meta in item["pagemap"]["metatags"]:
+                    if "article:published_time" in meta:
+                        pub_date = meta["article:published_time"]
+                        break
+            
             parsed_results.append({
-                "source_title": item.get("title"),
-                "url": item.get("link"),
-                "snippet": item.get("snippet")
+                "source_title": title,
+                "url": url,
+                "snippet": snippet,
+                "published_date": pub_date,
+                "domain": url.split('/')[2] if '/' in url else url
             })
+            
+        logger.info(f"Successfully parsed {len(parsed_results)} search results")
         return parsed_results
         
+    except requests.exceptions.Timeout:
+        logger.error("Google search request timed out")
+        return []
     except requests.exceptions.RequestException as e:
-        print(f"Error during Google search request: {e}")
+        logger.error(f"Error during Google search request: {e}")
+        return []
+    except Exception as e:
+        logger.error(f"Unexpected error in google_search_tool: {e}")
         return []
 
+def format_search_results_for_llm(search_results: List[Dict]) -> str:
+    """
+    Format search results with enhanced context for better LLM understanding
+    """
+    if not search_results:
+        return "No relevant search results were found for this query."
+    
+    current_date = datetime.now().strftime("%Y-%m-%d")
+    formatted_results = [f"Search Results (Retrieved on {current_date}):\n"]
+    
+    for i, result in enumerate(search_results, 1):
+        formatted_result = f"\n--- Result {i} ---"
+        formatted_result += f"\nTitle: {result['source_title']}"
+        formatted_result += f"\nSource: {result['domain']}"
+        formatted_result += f"\nURL: {result['url']}"
+        
+        if result.get('published_date'):
+            formatted_result += f"\nPublished: {result['published_date']}"
+        
+        formatted_result += f"\nContent: {result['snippet']}"
+        formatted_results.append(formatted_result)
+    
+    formatted_results.append(f"\n--- End of Search Results ---\n")
+    formatted_results.append("Please synthesize this information to provide a comprehensive answer to the user's question. If the search results contain conflicting information, please note the discrepancy. Always cite your sources when using information from the search results.")
+    
+    return "\n".join(formatted_results)
+
 # --- FastAPI Application Setup ---
-app = FastAPI()
+app = FastAPI(title="AI Chatbot with Enhanced Search", version="2.0.0")
+
 app.add_middleware(
     CORSMiddleware,
-    allow_origins=["*"],
+    allow_origins=["*"],  # In production, specify actual origins
     allow_credentials=True,
     allow_methods=["*"],
     allow_headers=["*"],
 )
 
 # --- OpenAI Client Initialization ---
-client = OpenAI(api_key=LLM_API_KEY, base_url=LLM_BASE_URL) if LLM_API_KEY and LLM_BASE_URL else None
+if not LLM_API_KEY or not LLM_BASE_URL:
+    logger.error("LLM_API_KEY or LLM_BASE_URL not configured")
+    client = None
+else:
+    client = OpenAI(api_key=LLM_API_KEY, base_url=LLM_BASE_URL)
+    logger.info("OpenAI client initialized successfully")
 
-# --- LLM Tool Definition ---
-available_tools = [{"type": "function", "function": {"name": "Google Search", "description": "Performs a Google search for up-to-date information.", "parameters": {"type": "object", "properties": {"query": {"type": "string", "description": "The search query."}}, "required": ["query"]}}}]
+# --- Enhanced Tool Definition ---
+available_tools = [
+    {
+        "type": "function", 
+        "function": {
+            "name": "google_search", 
+            "description": "Performs a Google search for current information, recent events, specific facts, or when you need to verify or update your knowledge. Use this when the user asks about recent events, current statistics, latest news, or specific factual information that may have changed recently.",
+            "parameters": {
+                "type": "object", 
+                "properties": {
+                    "query": {
+                        "type": "string", 
+                        "description": "The search query. Be specific and include relevant keywords. For recent events, include time-related terms like 'latest', '2024', 'recent', etc."
+                    }
+                }, 
+                "required": ["query"]
+            }
+        }
+    }
+]
 
-# --- Chatbot Endpoint ---
+def should_use_search(message: str) -> bool:
+    """
+    Intelligent decision making for when to enable search based on message content
+    """
+    search_indicators = [
+        "latest", "recent", "current", "now", "today", "this year", "2024", "2025",
+        "news", "update", "what's happening", "status", "price", "stock",
+        "weather", "score", "results", "announcement", "release"
+    ]
+    
+    factual_indicators = [
+        "who is", "what is", "where is", "when did", "how many", "statistics",
+        "data", "information about", "tell me about", "facts about"
+    ]
+    
+    message_lower = message.lower()
+    
+    # Strong indicators for search
+    if any(indicator in message_lower for indicator in search_indicators):
+        return True
+    
+    # Moderate indicators for search (factual queries)
+    if any(indicator in message_lower for indicator in factual_indicators):
+        return True
+        
+    return False
+
+# --- Enhanced Chatbot Endpoint ---
 @app.post("/chat")
 async def chat_endpoint(request: Request):
     if not client:
-        return {"response": "Error: LLM client not configured.", "sources": []}
+        raise HTTPException(status_code=500, detail="LLM client not configured")
         
     try:
         data = await request.json()
-        user_message = data.get("message")
-        use_search = data.get("use_search", True)
+        user_message = data.get("message", "").strip()
+        use_search = data.get("use_search")  # None means auto-decide
+        conversation_history = data.get("history", [])
         
         if not user_message:
-            return {"response": "Error: No message provided.", "sources": []}
+            raise HTTPException(status_code=400, detail="No message provided")
 
-        messages = data.get("history", []) + [{"role": "user", "content": user_message}]
+        # Auto-decide search usage if not specified
+        if use_search is None:
+            use_search = should_use_search(user_message)
+            logger.info(f"Auto-decided search usage: {use_search}")
+
+        # Prepare messages with enhanced system prompt
+        current_date = datetime.now().strftime("%Y-%m-%d")
+        system_message = {"role": "system", "content": SYSTEM_PROMPT.format(current_date=current_date)}
+        messages = [system_message] + conversation_history + [{"role": "user", "content": user_message}]
+        
+        llm_kwargs = {
+            "model": "unsloth/Qwen3-30B-A3B-GGUF", 
+            "temperature": 0.7,  # Slightly higher for more creative responses
+            "messages": messages,
+            "max_tokens": 2000  # Ensure comprehensive responses
+        }
         
-        llm_kwargs = {"model": "unsloth/Qwen3-30B-A3B-GGUF", "temperature": 0.6, "messages": messages}
         if use_search:
-            print("INFO: Search is ENABLED.")
+            logger.info("Search is ENABLED")
             llm_kwargs["tools"] = available_tools
             llm_kwargs["tool_choice"] = "auto"
         else:
-            print("INFO: Search is DISABLED.")
+            logger.info("Search is DISABLED")
 
+        # First LLM call
         llm_response = client.chat.completions.create(**llm_kwargs)
-        
         tool_calls = llm_response.choices[0].message.tool_calls
-        source_links = [] # Initialize source links list
+        source_links = []
 
         if tool_calls:
+            logger.info(f"Processing {len(tool_calls)} tool calls")
             tool_outputs = []
+            
             for tool_call in tool_calls:
-                if tool_call.function.name == "Google Search":
-                    function_args = json.loads(tool_call.function.arguments)
-                    search_query = function_args.get("query")
-                    
-                    if search_query:
-                        search_results = Google_Search_tool(queries=[search_query])
-                        
-                        formatted_snippets = []
-                        for res in search_results:
-                            # Store title and URL for the final response
-                            source_links.append({"title": res["source_title"], "url": res["url"]})
-                            # Format snippet for the LLM context
-                            formatted_snippets.append(f"Source: {res['source_title']}\nSnippet: {res['snippet']}")
+                if tool_call.function.name == "google_search":
+                    try:
+                        function_args = json.loads(tool_call.function.arguments)
+                        search_query = function_args.get("query", "").strip()
                         
-                        tool_output_content = "Search Results:\n" + "\n---\n".join(formatted_snippets) if formatted_snippets else "No relevant search results found."
-                        tool_outputs.append({"tool_call_id": tool_call.id, "output": tool_output_content})
+                        if search_query:
+                            logger.info(f"Executing search for: {search_query}")
+                            search_results = google_search_tool([search_query], num_results=5)
+                            
+                            # Collect source links for response
+                            for result in search_results:
+                                source_links.append({
+                                    "title": result["source_title"],
+                                    "url": result["url"],
+                                    "domain": result["domain"]
+                                })
+                            
+                            # Format results for LLM
+                            formatted_results = format_search_results_for_llm(search_results)
+                            tool_outputs.append({
+                                "tool_call_id": tool_call.id, 
+                                "output": formatted_results
+                            })
+                        else:
+                            logger.warning("Empty search query in tool call")
+                            tool_outputs.append({
+                                "tool_call_id": tool_call.id,
+                                "output": "Error: Empty search query provided."
+                            })
+                            
+                    except json.JSONDecodeError as e:
+                        logger.error(f"Failed to parse tool call arguments: {e}")
+                        tool_outputs.append({
+                            "tool_call_id": tool_call.id,
+                            "output": "Error: Failed to parse search parameters."
+                        })
 
+            # Continue conversation with search results
             messages.append(llm_response.choices[0].message)
             for output_item in tool_outputs:
-                messages.append({"role": "tool", "tool_call_id": output_item["tool_call_id"], "content": output_item["output"]})
+                messages.append({
+                    "role": "tool", 
+                    "tool_call_id": output_item["tool_call_id"], 
+                    "content": output_item["output"]
+                })
 
-            final_response = client.chat.completions.create(model="unsloth/Qwen3-30B-A3B-GGUF", temperature=0.6, messages=messages)
+            # Final response generation with search context
+            final_response = client.chat.completions.create(
+                model="unsloth/Qwen3-30B-A3B-GGUF",
+                temperature=0.7,
+                messages=messages,
+                max_tokens=2000
+            )
             final_chatbot_response = final_response.choices[0].message.content
         else:
             final_chatbot_response = llm_response.choices[0].message.content
 
-        # Return the structured response
-        return {"response": final_chatbot_response, "sources": source_links}
+        # Enhanced response structure
+        response_data = {
+            "response": final_chatbot_response,
+            "sources": source_links,
+            "search_used": bool(tool_calls),
+            "timestamp": datetime.now().isoformat()
+        }
+        
+        logger.info(f"Chat response generated successfully. Search used: {bool(tool_calls)}")
+        return response_data
 
+    except HTTPException:
+        raise
+    except json.JSONDecodeError:
+        logger.error("Invalid JSON in request body")
+        raise HTTPException(status_code=400, detail="Invalid JSON in request body")
     except Exception as e:
-        print(f"ERROR in /chat: {e}")
-        return {"response": f"An internal error occurred: {str(e)}", "sources": []}
+        logger.error(f"Unexpected error in /chat endpoint: {e}")
+        raise HTTPException(status_code=500, detail=f"Internal server error: {str(e)}")
 
-# --- Health Check / Root Endpoint ---
+# --- Health Check Endpoint ---
 @app.get("/")
 async def root():
-    return {"message": "Chatbot FastAPI is running."}
+    return {
+        "message": "Enhanced AI Chatbot API is running",
+        "version": "2.0.0",
+        "features": ["Google Search Integration", "Intelligent Search Decision", "Enhanced Prompting"],
+        "timestamp": datetime.now().isoformat()
+    }
+
+# --- Health Check Endpoint ---
+@app.get("/health")
+async def health_check():
+    health_status = {
+        "status": "healthy",
+        "timestamp": datetime.now().isoformat(),
+        "services": {
+            "llm_client": client is not None,
+            "google_search": bool(GOOGLE_API_KEY and GOOGLE_CX)
+        }
+    }
+    return health_status