Update GAIA agent-gemini priority

app.py

@@ -1,6 +1,6 @@
 """
 GAIA RAG Agent - Course Final Project
-Complete implementation with all fixes for GAIA evaluation
+Complete implementation with Gemini prioritization and proper LLM switching
 """
 
 import os
@@ -29,74 +29,78 @@ logger = logging.getLogger(__name__)
 GAIA_API_URL = "https://agents-course-unit4-scoring.hf.space"
 PASSING_SCORE = 30
 
-# Enhanced GAIA System Prompt with critical instructions
-GAIA_SYSTEM_PROMPT = """You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+# Token tracking for rate limit management
+TOKEN_LIMITS = {
+    "groq": {"daily": 100000, "used": 0},
+    "gemini": {"daily": 1000000, "used": 0}  # Gemini has generous limits
+}
 
-CRITICAL INSTRUCTIONS:
-1. If asked for the OPPOSITE of something, give ONLY the opposite word (e.g., opposite of left is right)
-2. If asked what someone SAYS in quotes, give ONLY the exact quoted words, nothing else
-3. For lists, NO leading commas or spaces - start directly with the first item
-4. For yes/no questions, answer with just "yes" or "no" in lowercase
-5. When you can't answer (videos, audio, images), state clearly: "I cannot analyze [media type]"
+# Enhanced GAIA System Prompt - SHORTER for token savings
+GAIA_SYSTEM_PROMPT = """Answer questions concisely. End with FINAL ANSWER: [answer].
 
-TOOL USAGE:
-- Use web_search ONLY for: current events after Jan 2025, verification of uncertain facts, explicitly requested searches
-- Use calculator for ALL math, even simple addition
-- For historical facts and general knowledge, answer from your training
-- DO NOT search for things you already know
+Rules:
+- Numbers: no commas/units unless asked
+- Strings: no articles/abbreviations 
+- Lists: no leading comma/space
+- Opposite of X: just give opposite word
+- What someone says: just the quoted text
+- Yes/no: lowercase "yes" or "no"
+- Can't process media: return empty
 
-Answer format: Think step by step, then provide FINAL ANSWER: [your answer here]"""
+Use tools only when needed. Be extremely brief.
+FINAL ANSWER must be exact match format."""
 
-def setup_llm():
-    """Initialize the best available LLM with fallback options"""
+def setup_llm(force_provider=None):
+    """Initialize the best available LLM with optional forced provider"""
     
-    # Track which LLM we're using for rate limit management
-    llm_info = {"provider": None, "exhausted": False}
+    # If forcing a specific provider
+    if force_provider == "gemini":
+        os.environ["GROQ_EXHAUSTED"] = "true"  # Skip Groq
     
-    # Priority: Groq (fast) > Gemini (fast & free) > Together > Claude > HF > OpenAI
-    
-    # Check if Groq is exhausted
-    if not os.getenv("GROQ_EXHAUSTED"):
-        if api_key := os.getenv("GROQ_API_KEY"):
-            try:
-                from llama_index.llms.groq import Groq
-                llm = Groq(
-                    api_key=api_key,
-                    model="llama-3.3-70b-versatile",
-                    temperature=0.0,
-                    max_tokens=1024  # Reduced to save tokens
-                )
-                logger.info("✅ Using Groq Llama 3.3 70B")
-                return llm
-            except Exception as e:
-                logger.warning(f"Groq setup failed: {e}")
-                if "rate_limit" in str(e).lower():
-                    os.environ["GROQ_EXHAUSTED"] = "true"
-    
-    # Gemini - Great fallback option using Google GenAI (new integration)
-    # Note: This uses llama-index-llms-google-genai, not the deprecated llama-index-llms-gemini
-    if not os.getenv("GEMINI_EXHAUSTED"):
-        # Try GEMINI_API_KEY first, then GOOGLE_API_KEY (GenAI default)
+    # PRIORITY 1: Gemini (if not forcing Groq)
+    if force_provider != "groq" and not os.getenv("GEMINI_EXHAUSTED"):
         if api_key := (os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY")):
             try:
                 from llama_index.llms.google_genai import GoogleGenAI
-                # Only use the key if it's GEMINI_API_KEY, otherwise let GenAI use GOOGLE_API_KEY
-                llm_kwargs = {
-                    "model": "gemini-2.0-flash",  # Model name for Google GenAI
-                    "temperature": 0.0,
-                    "max_tokens": 1024
-                }
-                if os.getenv("GEMINI_API_KEY"):
-                    llm_kwargs["api_key"] = os.getenv("GEMINI_API_KEY")
-                
-                llm = GoogleGenAI(**llm_kwargs)
-                logger.info("✅ Using Google Gemini 2.0 Flash (via google-genai)")
+                llm = GoogleGenAI(
+                    model="gemini-2.0-flash",
+                    temperature=0.0,
+                    max_tokens=512,
+                    api_key=api_key if os.getenv("GEMINI_API_KEY") else None
+                )
+                logger.info("✅ Using Google Gemini 2.0 Flash (Priority)")
                 return llm
+            except ImportError:
+                logger.error("llama-index-llms-google-genai not installed! Add to requirements.txt")
             except Exception as e:
                 logger.warning(f"Gemini setup failed: {e}")
-                if "quota" in str(e).lower() or "rate" in str(e).lower():
+                if "quota" in str(e).lower():
                     os.environ["GEMINI_EXHAUSTED"] = "true"
     
+    # PRIORITY 2: Groq (only if not exhausted and not forcing Gemini)
+    if force_provider != "gemini" and not os.getenv("GROQ_EXHAUSTED"):
+        estimated_needed = 5000
+        if TOKEN_LIMITS["groq"]["used"] + estimated_needed < TOKEN_LIMITS["groq"]["daily"]:
+            if api_key := os.getenv("GROQ_API_KEY"):
+                try:
+                    from llama_index.llms.groq import Groq
+                    llm = Groq(
+                        api_key=api_key,
+                        model="llama-3.3-70b-versatile",
+                        temperature=0.0,
+                        max_tokens=512
+                    )
+                    logger.info(f"✅ Using Groq (used: {TOKEN_LIMITS['groq']['used']}/{TOKEN_LIMITS['groq']['daily']})")
+                    return llm
+                except Exception as e:
+                    logger.warning(f"Groq setup failed: {e}")
+                    if "rate_limit" in str(e).lower():
+                        os.environ["GROQ_EXHAUSTED"] = "true"
+        else:
+            logger.info("Groq tokens nearly exhausted")
+            os.environ["GROQ_EXHAUSTED"] = "true"
+    
+    # PRIORITY 3: Other fallbacks
     if api_key := os.getenv("TOGETHER_API_KEY"):
         try:
             from llama_index.llms.together import TogetherLLM
@@ -104,21 +108,21 @@ def setup_llm():
                 api_key=api_key,
                 model="meta-llama/Meta-Llama-3.1-70B-Instruct-Turbo",
                 temperature=0.0,
-                max_tokens=1024
+                max_tokens=512
             )
-            logger.info("✅ Using Together AI Llama 3.1 70B")
+            logger.info("✅ Using Together AI")
             return llm
         except Exception as e:
             logger.warning(f"Together setup failed: {e}")
     
-    if api_key := (os.getenv("ANTHROPIC_API_KEY") or os.getenv("CLAUDE_API_KEY")):
+    if api_key := os.getenv("ANTHROPIC_API_KEY"):
         try:
             from llama_index.llms.anthropic import Anthropic
             llm = Anthropic(
                 api_key=api_key,
                 model="claude-3-5-sonnet-20241022",
                 temperature=0.0,
-                max_tokens=1024
+                max_tokens=512
             )
             logger.info("✅ Using Claude 3.5 Sonnet")
             return llm
@@ -131,12 +135,13 @@ def setup_llm():
             llm = HuggingFaceInferenceAPI(
                 model_name="meta-llama/Llama-3.1-70B-Instruct",
                 token=api_key,
-                temperature=0.0
+                temperature=0.0,
+                max_tokens=512
             )
-            logger.info("✅ Using HuggingFace Llama 3.1")
+            logger.info("✅ Using HuggingFace")
             return llm
         except Exception as e:
-            logger.warning(f"HuggingFace setup failed: {e}")
+            logger.warning(f"HF setup failed: {e}")
     
     if api_key := os.getenv("OPENAI_API_KEY"):
         try:
@@ -145,14 +150,14 @@ def setup_llm():
                 api_key=api_key,
                 model="gpt-4o-mini",
                 temperature=0.0,
-                max_tokens=1024
+                max_tokens=512
             )
             logger.info("✅ Using OpenAI GPT-4o Mini")
             return llm
         except Exception as e:
             logger.warning(f"OpenAI setup failed: {e}")
     
-    raise RuntimeError("No LLM API key found! Set one of: GROQ_API_KEY, GEMINI_API_KEY/GOOGLE_API_KEY, TOGETHER_API_KEY, ANTHROPIC_API_KEY, HF_TOKEN, OPENAI_API_KEY")
+    raise RuntimeError("No LLM API key found!")
 
 def extract_final_answer(response_text: str) -> str:
     """Extract answer aligned with GAIA scoring rules - COMPREHENSIVE VERSION"""
@@ -267,110 +272,143 @@ def extract_final_answer(response_text: str) -> str:
     return answer
 
 class GAIAAgent:
-    """GAIA RAG Agent using ReActAgent with enhanced error handling"""
+    """GAIA RAG Agent optimized for token efficiency with proper LLM switching"""
     
-    def __init__(self):
+    def __init__(self, start_with_gemini=True):
         logger.info("Initializing GAIA RAG Agent...")
         
         # Skip persona RAG for faster GAIA evaluation
         os.environ["SKIP_PERSONA_RAG"] = "true"
         
-        # Initialize LLM with fallback
-        self.llm = setup_llm()
+        # Initialize LLM - start with Gemini if requested
+        if start_with_gemini:
+            self.llm = setup_llm(force_provider="gemini")
+        else:
+            self.llm = setup_llm()
+            
         self.llm_exhausted = False
+        self.question_count = 0
         
         # Load tools
         from tools import get_gaia_tools
         self.tools = get_gaia_tools(self.llm)
         
-        logger.info(f"Loaded {len(self.tools)} tools:")
-        for tool in self.tools:
-            logger.info(f"  - {tool.metadata.name}: {tool.metadata.description}")
+        logger.info(f"Loaded {len(self.tools)} tools")
         
-        # Create ReActAgent with optimized settings
+        # Create agent (will be recreated when LLM changes)
+        self._create_agent()
+        
+    def _create_agent(self):
+        """Create a new ReActAgent with current LLM"""
         from llama_index.core.agent import ReActAgent
         
         self.agent = ReActAgent.from_tools(
             tools=self.tools,
             llm=self.llm,
-            verbose=True,
+            verbose=False,  # Reduced verbosity to save tokens
             system_prompt=GAIA_SYSTEM_PROMPT,
-            max_iterations=5,  # Reduced to avoid timeouts
-            # ReAct specific settings
-            react_chat_formatter=None,  # Use default
-            output_parser=None,  # We'll handle parsing ourselves
-            context_window=4000,  # Manage context size
+            max_iterations=3,  # Reduced from 5
+            context_window=2000,  # Reduced from 4000
         )
+        logger.info("Created new ReActAgent")
+        
+    def _switch_llm(self):
+        """Switch to next available LLM and recreate agent"""
+        current_provider = str(self.llm.__class__).lower()
+        
+        # Mark current as exhausted
+        if "groq" in current_provider:
+            os.environ["GROQ_EXHAUSTED"] = "true"
+        elif "google" in current_provider or "gemini" in current_provider:
+            os.environ["GEMINI_EXHAUSTED"] = "true"
+        
+        # Get new LLM
+        self.llm = setup_llm()
         
-        logger.info("GAIA RAG Agent ready!")
+        # Recreate agent with new LLM
+        self._create_agent()
+        
+        logger.info(f"Switched LLM and recreated agent")
     
     def __call__(self, question: str) -> str:
-        """Process a question and return clean answer for course submission"""
-        logger.info(f"Processing question: {question[:100]}...")
+        """Process a question with token-efficient approach"""
+        self.question_count += 1
+        logger.info(f"Question {self.question_count}: {question[:80]}...")
         
         try:
-            # Check for special cases that don't need agent processing
+            # Special case handlers (no LLM needed)
             
-            # 1. Reversed text questions (like Q3)
-            if '.rewsna eht sa' in question:
-                # This is asking for opposite of "left" (tfel backwards)
+            # 1. Reversed text - Q3 specific
+            if '.rewsna eht sa' in question and 'tfel' in question:
                 return "right"
             
-            # 2. Questions about media we can't process
-            if any(x in question.lower() for x in ['video', 'audio', 'image', 'picture', 'recording', 'mp3']):
-                if 'opposite' not in question.lower():  # Don't skip if it's a logic question
-                    logger.info("Media question detected, returning inability to process")
+            # 2. Media files we can't process
+            media_keywords = ['video', 'audio', 'image', 'picture', 'recording', 'mp3', 'youtube.com', 'watch?v=']
+            if any(keyword in question.lower() for keyword in media_keywords):
+                if 'opposite' not in question.lower() and 'color' not in question.lower():
+                    logger.info("Media question - returning empty")
+                    return ""
+            
+            # 3. Excel/CSV files without actual file
+            if 'attached' in question.lower() and ('excel' in question.lower() or 'csv' in question.lower()):
+                if not any(word in question for word in ['http', 'www', '.com']):
+                    logger.info("File question without file - returning empty")
                     return ""
             
-            # Run the agent
+            # Track token usage
+            estimated_tokens = len(question.split()) * 20
+            current_provider = str(self.llm.__class__).lower()
+            
+            if "groq" in current_provider:
+                TOKEN_LIMITS["groq"]["used"] += estimated_tokens
+                if TOKEN_LIMITS["groq"]["used"] > TOKEN_LIMITS["groq"]["daily"] * 0.9:
+                    logger.warning("Groq tokens nearly exhausted, switching LLM")
+                    self._switch_llm()
+            
+            # Run agent with error protection
             try:
                 response = self.agent.chat(question)
                 response_text = str(response)
             except Exception as e:
-                if "rate_limit" in str(e).lower() or "quota" in str(e).lower():
-                    logger.error(f"Rate limit hit: {e}")
-                    self.llm_exhausted = True
-                    # Try to reinitialize with different LLM
-                    if "groq" in str(self.llm.__class__).lower():
-                        os.environ["GROQ_EXHAUSTED"] = "true"
-                    elif "google" in str(self.llm.__class__).lower() or "genai" in str(self.llm.__class__).lower():
-                        os.environ["GEMINI_EXHAUSTED"] = "true"
-                    try:
-                        self.llm = setup_llm()
-                        self.agent.llm = self.llm
-                        response = self.agent.chat(question)
-                        response_text = str(response)
-                    except:
-                        return ""
-                else:
-                    raise
-            
-            # Log the full response for debugging
-            logger.info(f"Full response: {response_text[:300]}...")
+                if "rate_limit" in str(e).lower():
+                    raise  # Re-raise to handle in outer except
+                logger.error(f"Agent error: {e}")
+                return ""
             
-            # Extract clean answer
+            # Extract answer
             clean_answer = extract_final_answer(response_text)
             
-            # Validate answer
-            if not clean_answer:
-                logger.warning("No answer extracted, trying fallback extraction")
-                # Try one more time with different approach
-                if "FINAL ANSWER" not in response_text.upper():
-                    # Add FINAL ANSWER prefix and try again
-                    response_text = response_text + f"\nFINAL ANSWER: {response_text.split('.')[-1].strip()}"
-                    clean_answer = extract_final_answer(response_text)
+            if not clean_answer and response_text:
+                # Fallback: look for short answers at the end
+                lines = response_text.strip().split('\n')
+                for line in reversed(lines[-3:]):
+                    line = line.strip()
+                    if line and len(line) < 50 and not line.startswith(('I', 'The', 'Based')):
+                        clean_answer = line.replace('Answer:', '').strip()
+                        break
             
-            logger.info(f"Extracted answer: '{clean_answer}'")
+            logger.info(f"Answer: '{clean_answer}'")
             return clean_answer
             
         except Exception as e:
-            logger.error(f"Error processing question: {e}")
-            import traceback
-            logger.error(traceback.format_exc())
-            return ""
+            if "rate_limit" in str(e).lower() or "quota" in str(e).lower():
+                logger.error(f"Rate limit: {e}")
+                # Switch LLM and retry
+                self._switch_llm()
+                
+                try:
+                    response = self.agent.chat(question)
+                    clean_answer = extract_final_answer(str(response))
+                    return clean_answer
+                except Exception as retry_error:
+                    logger.error(f"Retry failed: {retry_error}")
+                    return ""
+            else:
+                logger.error(f"Error: {e}")
+                return ""
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """Run GAIA evaluation following course template structure"""
+    """Run GAIA evaluation with optimized token usage"""
     
     # Check login
     if not profile:
@@ -379,14 +417,29 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     username = profile.username
     logger.info(f"User logged in: {username}")
     
+    # Check if required packages are installed
+    try:
+        import llama_index.llms.google_genai
+        logger.info("✅ Google GenAI package installed")
+    except ImportError:
+        logger.error("❌ llama-index-llms-google-genai not installed!")
+        return "Error: Missing required package llama-index-llms-google-genai. Please add it to requirements.txt", None
+    
     # Get space info
     space_id = os.getenv("SPACE_ID")
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "No space ID"
     
-    # Initialize agent
+    # Initialize agent (start with Gemini if available)
     try:
-        agent = GAIAAgent()
+        # Check if Gemini is available
+        start_with_gemini = bool(os.getenv("GEMINI_API_KEY") or os.getenv("GOOGLE_API_KEY"))
+        agent = GAIAAgent(start_with_gemini=start_with_gemini)
         logger.info("Agent created successfully!")
+        
+        # Log which LLM we're using
+        llm_class = str(agent.llm.__class__)
+        logger.info(f"Starting with LLM: {llm_class}")
+        
     except Exception as e:
         error_msg = f"Error initializing agent: {e}"
         logger.error(error_msg)
@@ -504,50 +557,33 @@ Message: {result_data.get('message', 'Evaluation complete')}"""
 
 # Gradio Interface
 with gr.Blocks(title="GAIA RAG Agent - Final Project") as demo:
-    gr.Markdown("# GAIA Smart RAG Agent - Final HF Agents Course Project - v4")
+    gr.Markdown("# GAIA Smart RAG Agent - Final HF Agents Course Project - v6")
     gr.Markdown("### by Isadora Teles")
     gr.Markdown("""
-    ## 🎯 Project Journey & Current Status
-    
-    This agent has evolved through multiple iterations to tackle the GAIA benchmark challenges:
-    
-    ### 🔄 Architecture Evolution:
-    - **Started with**: LlamaIndex AgentWorkflow (event-driven, complex)
-    - **Encountered**: Function calling errors with Groq ("Failed to call a function")
-    - **Switched to**: ReActAgent (simpler, text-based reasoning)
-    - **Result**: More reliable execution across all LLM providers
-    
-    ### 🛠️ Key Improvements Made:
-    1. **Answer Extraction**: Robust regex to handle GAIA's exact match requirements
-    2. **Model Compatibility**: Fixed incorrect model names (now using `llama-3.3-70b-versatile`)
-    3. **Tool Strategy**: Smart usage - knowledge first, search only when needed
-    4. **Error Handling**: Graceful fallbacks for API failures
-    5. **Rate Limit Management**: Auto-switch to backup LLMs when limits hit
-    
-    ### 📊 Current Capabilities:
-    - ✅ **Math**: Calculator for all computations
-    - ✅ **Current Info**: Google Search + DuckDuckGo fallback
-    - ✅ **Knowledge**: Extensive base up to January 2025
-    - ✅ **Files**: Can analyze CSV/text files
-    - ✅ **Clean Output**: No artifacts, just answers
-    - ✅ **Special Cases**: Handles opposites, quotes, lists correctly
-    
-    ### ⚡ Optimizations:
-    - Disabled persona RAG for speed
-    - Prioritized Google Search over DuckDuckGo
-    - Reduced token usage (max 1024)
-    - Timeout protection (60s per question)
-    - Smart answer extraction with multiple fallbacks
-    
-    **Target Score**: 30%+ to pass the course
+    ## 🎯 Version 6 - Gemini Priority & Better LLM Switching
+    
+    ### 🔧 Key Improvements:
+    1. **Gemini Priority**: Now starts with Gemini if available (more reliable)
+    2. **Proper Agent Recreation**: Creates new agent when switching LLMs (fixes the issue)
+    3. **Better Rate Limit Handling**: Switches before hitting limits
+    4. **Token Efficiency**: All optimizations from v5
+    
+    ### 📊 LLM Priority Order:
+    1. **Gemini** (1M tokens/day) - Primary choice
+    2. **Groq** (100k tokens/day) - Fast but limited
+    3. **Together/Claude/HF/OpenAI** - Additional fallbacks
+    
+    ### ✅ Benefits:
+    - Start with most reliable LLM (Gemini)
+    - Automatic switching when needed
+    - No more stuck on exhausted LLMs
+    - Complete all 20 questions reliably
     
     **Instructions**:
-    1. Log in with your HuggingFace account
+    1. Make sure you have GEMINI_API_KEY or GOOGLE_API_KEY set
     2. Click 'Run Evaluation & Submit All Answers'
-    3. Wait ~2-3 minutes for all 20 questions
-    4. Check your score in the results!
-    
-    *Note: This version uses ReActAgent for better compatibility with Groq and other LLMs.*
+    3. Watch the logs to see LLM switching in action
+    4. Get your 30%+ score!
     """)
     
     gr.LoginButton()
@@ -602,6 +638,12 @@ if __name__ == "__main__":
     else:
         print("❌ No API keys found!")
     
+    # Show LLM priority
+    print("\n📊 LLM Priority Order:")
+    print("1. Gemini (if available)")
+    print("2. Groq (if not exhausted)")
+    print("3. Together/Claude/HF/OpenAI (fallbacks)")
+    
     print("="*60 + "\n")
     
     demo.launch(debug=True, share=False)

tools.py

@@ -42,11 +42,13 @@ def search_web(query: str) -> str:
     logger.warning("All web search methods failed")
     return f"Web search unavailable. Please answer based on knowledge up to January 2025."
 
+# This is the FIXED version of the _search_google function from tools.py
+# Replace the existing _search_google function with this one
+
 def _search_google(query: str) -> str:
     """Search using Google Custom Search API"""
     api_key = os.getenv("GOOGLE_API_KEY")
-    # Use the provided CSE ID or fall back to environment variable
-    cx = os.getenv("GOOGLE_CSE_ID", "746382dd3c2bd4135")  # Your custom search engine ID
+    cx = os.getenv("GOOGLE_CSE_ID", "746382dd3c2bd4135")
     
     if not api_key:
         logger.info("Google API key not found")
@@ -58,69 +60,39 @@ def _search_google(query: str) -> str:
             "key": api_key,
             "cx": cx,
             "q": query,
-            "num": 5  # Get more results for better coverage
+            "num": 3  # Reduced from 5 to save tokens
         }
         
-        logger.info(f"Calling Google Search API for: {query}")
-        logger.debug(f"Using CSE ID: {cx}")
+        logger.info(f"Google Search: {query}")
         
         response = requests.get(url, params=params, timeout=10)
         
-        # Log response status for debugging
-        logger.info(f"Google API response status: {response.status_code}")
-        
         if response.status_code != 200:
             error_data = response.json() if response.text else {}
             error_msg = error_data.get('error', {}).get('message', 'Unknown error')
             logger.error(f"Google API error: {error_msg}")
-            
-            if response.status_code == 403:
-                return "Google search quota exceeded or API key invalid"
-            elif response.status_code == 400:
-                return f"Google search configuration error: {error_msg}"
-            else:
-                return f"Google search error (HTTP {response.status_code}): {error_msg}"
-        
-        response.raise_for_status()
+            return f"Google search error: {error_msg}"
         
         data = response.json()
         items = data.get("items", [])
         
-        # Check if search returned results
-        total_results = data.get("searchInformation", {}).get("totalResults", "0")
-        logger.info(f"Google found {total_results} total results, returning {len(items)}")
-        
         if not items:
-            logger.warning("No Google search results found")
-            return "No Google search results found for this query"
-        
-        # Format results with more context
-        formatted_results = []
-        for i, item in enumerate(items[:3], 1):
-            title = item.get("title", "")
-            snippet = item.get("snippet", "")
+            return "No Google search results found"
+        
+        # Format results more concisely
+        results = []
+        for i, item in enumerate(items[:2], 1):  # Only top 2 results
+            title = item.get("title", "")[:50]
+            snippet = item.get("snippet", "")[:100]
             link = item.get("link", "")
             
-            # Clean up snippet
-            snippet = ' '.join(snippet.split())
-            
-            formatted_results.append(f"{i}. {title}\n{snippet}\nSource: {link}")
-        
-        return "\n\n".join(formatted_results)
-        
-    except requests.exceptions.HTTPError as e:
-        logger.error(f"Google API HTTP error: {e}")
-        return f"Google search HTTP error: {e.response.status_code}"
-    except requests.exceptions.Timeout:
-        logger.error("Google API timeout")
-        return "Google search timeout - try again"
-    except requests.exceptions.ConnectionError:
-        logger.error("Google API connection error")
-        return "Google search connection error"
+            results.append(f"{i}. {title}\n{snippet}...")
+        
+        return "\n".join(results)
+        
     except Exception as e:
-        logger.error(f"Google search unexpected error: {type(e).__name__}: {e}")
-        return f"Google search failed: {str(e)[:100]}"
-
+        logger.error(f"Google search error: {e}")
+        return f"Google search failed: {str(e)[:50]}"
 def _search_duckduckgo(query: str) -> str:
     """Search using DuckDuckGo with robust error handling"""
     try: