Update app.py

app.py

@@ -3,15 +3,20 @@ import gradio as gr
 import requests
 import pandas as pd
 import google.generativeai as genai
+import time
+import re
+from bs4 import BeautifulSoup
+from urllib.parse import quote_plus
+import json
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 MODEL_TO_USE = "gemini-1.5-flash"
 
 # --- Enhanced Agent Definition ---
-class BasicAgent:
+class EnhancedAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("EnhancedAgent initialized.")
         # Get API key from environment (set in HF Space secrets)
         api_key = os.getenv("GOOGLE_API_KEY")
         if not api_key:
@@ -19,29 +24,239 @@ class BasicAgent:
         
         genai.configure(api_key=api_key)
         self.model = genai.GenerativeModel(MODEL_TO_USE)
+        self.request_count = 0
+        self.last_request_time = 0
+        self.min_request_interval = 2  # Minimum seconds between requests
         
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
+    def _rate_limit(self):
+        """Simple rate limiting to avoid API restrictions"""
+        current_time = time.time()
+        time_since_last = current_time - self.last_request_time
+        
+        if time_since_last < self.min_request_interval:
+            sleep_time = self.min_request_interval - time_since_last
+            print(f"Rate limiting: sleeping for {sleep_time:.2f} seconds")
+            time.sleep(sleep_time)
+        
+        self.last_request_time = time.time()
+        self.request_count += 1
+        
+        # Additional throttling after many requests
+        if self.request_count > 10:
+            time.sleep(1)
+        if self.request_count > 20:
+            time.sleep(2)
+    
+    def _search_web(self, query, max_results=5):
+        """Simple web search using Google search results"""
+        try:
+            search_url = f"https://www.google.com/search?q={quote_plus(query)}"
+            headers = {
+                'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+            }
+            
+            response = requests.get(search_url, headers=headers, timeout=10)
+            response.raise_for_status()
+            
+            soup = BeautifulSoup(response.content, 'html.parser')
+            results = []
+            
+            # Extract search result snippets
+            for result in soup.find_all('div', class_='BNeawe s3v9rd AP7Wnd')[:max_results]:
+                if result.text:
+                    results.append(result.text)
+            
+            # Also try different class names for search results
+            if not results:
+                for result in soup.find_all('span', class_='aCOpRe')[:max_results]:
+                    if result.text:
+                        results.append(result.text)
+            
+            return results[:max_results]
+            
+        except Exception as e:
+            print(f"Web search error: {e}")
+            return []
+    
+    def _search_wikipedia(self, query):
+        """Search Wikipedia specifically"""
+        try:
+            search_url = f"https://en.wikipedia.org/w/api.php"
+            params = {
+                'action': 'query',
+                'format': 'json',
+                'list': 'search',
+                'srsearch': query,
+                'srlimit': 3
+            }
+            
+            response = requests.get(search_url, params=params, timeout=10)
+            response.raise_for_status()
+            data = response.json()
+            
+            results = []
+            if 'query' in data and 'search' in data['query']:
+                for item in data['query']['search']:
+                    results.append({
+                        'title': item['title'],
+                        'snippet': item['snippet']
+                    })
+            
+            return results
+            
+        except Exception as e:
+            print(f"Wikipedia search error: {e}")
+            return []
+    
+    def _classify_question(self, question):
+        """Classify question type to determine search strategy"""
+        question_lower = question.lower()
+        
+        # Wikipedia-specific questions
+        if 'wikipedia' in question_lower or 'featured article' in question_lower:
+            return 'wikipedia'
+        
+        # Historical/factual questions that benefit from web search
+        if any(keyword in question_lower for keyword in [
+            'olympics', 'competition', 'award', 'published', 'album', 'season',
+            'year', 'when', 'who', 'where', 'how many', 'what country'
+        ]):
+            return 'factual'
+        
+        # Academic/scientific questions
+        if any(keyword in question_lower for keyword in [
+            'paper', 'study', 'research', 'journal', 'university', 'professor'
+        ]):
+            return 'academic'
         
-        # Add some basic prompt engineering to improve accuracy
-        prompt = f"""Please answer this question directly and concisely. Provide only the final answer without explanation unless specifically asked for reasoning.
+        # Mathematical/logical questions
+        if any(keyword in question_lower for keyword in [
+            'table', 'set', 'commutative', 'algebraic', 'notation'
+        ]):
+            return 'mathematical'
+        
+        # Text manipulation questions
+        if 'sentence' in question_lower and 'understand' in question_lower:
+            return 'text_manipulation'
+        
+        # Classification questions
+        if 'grocery' in question_lower or 'vegetables' in question_lower or 'fruits' in question_lower:
+            return 'classification'
+        
+        return 'general'
+    
+    def _create_specialized_prompt(self, question, question_type, search_results=None):
+        """Create specialized prompts based on question type"""
+        
+        base_context = ""
+        if search_results:
+            base_context = f"\nRelevant information from search:\n" + "\n".join([f"- {result}" for result in search_results[:3]])
+        
+        if question_type == 'wikipedia':
+            return f"""You are answering a question about Wikipedia. Be precise and factual.
+{base_context}
+
+Question: {question}
+
+Provide only the exact answer requested, no explanations:"""
+        
+        elif question_type == 'factual':
+            return f"""You are answering a factual question. Use the search results to provide an accurate answer.
+{base_context}
+
+Question: {question}
+
+Provide only the exact answer requested (name, number, or short phrase):"""
+        
+        elif question_type == 'mathematical':
+            return f"""You are solving a mathematical/logical problem. Work through it step by step but only provide the final answer.
+
+Question: {question}
+
+Analyze the problem carefully and provide only the final answer in the requested format:"""
+        
+        elif question_type == 'text_manipulation':
+            return f"""You are working with text manipulation. Read the question carefully and follow the instructions exactly.
+
+Question: {question}
+
+Provide only the exact answer requested:"""
+        
+        elif question_type == 'classification':
+            return f"""You are categorizing items. Be very precise about botanical vs. culinary classifications.
+
+Question: {question}
+
+Provide only the requested list in the exact format specified:"""
+        
+        elif question_type == 'academic':
+            return f"""You are answering an academic question. Use the search results to find specific details.
+{base_context}
+
+Question: {question}
+
+Provide only the exact answer requested (name, number, or specific detail):"""
+        
+        else:  # general
+            return f"""Answer this question directly and concisely. Provide only the final answer without explanation.
+{base_context}
 
 Question: {question}
 
 Answer:"""
+    
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question (first 100 chars): {question[:100]}...")
+        
+        # Rate limiting
+        self._rate_limit()
+        
+        # Classify question type
+        question_type = self._classify_question(question)
+        print(f"Question classified as: {question_type}")
+        
+        # Perform web search for certain question types
+        search_results = []
+        if question_type in ['wikipedia', 'factual', 'academic']:
+            if question_type == 'wikipedia':
+                wiki_results = self._search_wikipedia(question)
+                search_results = [f"{r['title']}: {r['snippet']}" for r in wiki_results]
+            else:
+                search_results = self._search_web(question)
+            
+            if search_results:
+                print(f"Found {len(search_results)} search results")
+        
+        # Create specialized prompt
+        prompt = self._create_specialized_prompt(question, question_type, search_results)
         
         try:
             response = self.model.generate_content(prompt)
             answer = response.text.strip()
+            
+            # Clean up answer for specific question types
+            if question_type == 'classification' and ',' in answer:
+                # Ensure comma-separated lists are properly formatted
+                items = [item.strip() for item in answer.split(',')]
+                answer = ', '.join(items)
+            
             print(f"Agent returning answer: {answer[:100]}...")
             return answer
+            
         except Exception as e:
             print(f"Error calling Gemini API: {e}")
-            return f"Error: Could not generate answer - {str(e)}"
+            # Fallback to basic prompt if specialized approach fails
+            try:
+                basic_prompt = f"Answer this question directly and concisely: {question}"
+                response = self.model.generate_content(basic_prompt)
+                return response.text.strip()
+            except Exception as e2:
+                print(f"Fallback also failed: {e2}")
+                return f"Error: Could not generate answer - {str(e)}"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    Fetches all questions, runs the EnhancedAgent on them, submits all answers,
     and displays the results.
     """
     # --- Determine HF Space Runtime URL and Repo URL ---
@@ -60,7 +275,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent (modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = EnhancedAgent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -93,13 +308,17 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     # 3. Run your Agent
     results_log = []
     answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
+    print(f"Running enhanced agent on {len(questions_data)} questions...")
+    
+    for i, item in enumerate(questions_data):
         task_id = item.get("task_id")
         question_text = item.get("question")
         if not task_id or question_text is None:
             print(f"Skipping item with missing task_id or question: {item}")
             continue
+        
+        print(f"Processing question {i+1}/{len(questions_data)}: {task_id}")
+        
         try:
             submitted_answer = agent(question_text)
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
@@ -114,7 +333,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     # 4. Prepare Submission 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    status_update = f"Enhanced agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
     # 5. Submit
@@ -163,20 +382,25 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Gemini-Powered Agent Evaluation Runner")
+    gr.Markdown("# Enhanced Gemini Agent with Web Search")
     gr.Markdown(
         """
         **Instructions:**
 
         1. Make sure you've set your `GOOGLE_API_KEY` in the Space secrets (Settings tab)
         2. Log in to your Hugging Face account using the button below
-        3. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, and submit answers
+        3. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your enhanced agent, and submit answers
 
-        **Note:** This agent uses Google's Gemini 1.5 Flash model to answer questions.
+        **Enhanced Features:**
+        - Intelligent question classification
+        - Web search integration for factual questions
+        - Specialized prompting strategies
+        - Rate limiting to avoid API restrictions
+        - Wikipedia search for specific queries
         
         ---
         **Disclaimers:**
-        Once clicking on the submit button, it can take quite some time (this is the time for the agent to go through all the questions).
+        This process can take some time as the agent searches the web and processes each question carefully.
         """
     )
 
@@ -193,7 +417,7 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    print("\n" + "-"*30 + " Enhanced App Starting " + "-"*30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
     space_host_startup = os.getenv("SPACE_HOST")
     space_id_startup = os.getenv("SPACE_ID")
@@ -211,7 +435,7 @@ if __name__ == "__main__":
     else:
         print("ℹ️  SPACE_ID environment variable not found (running locally?). Repo URL cannot be determined.")
 
-    print("-"*(60 + len(" App Starting ")) + "\n")
+    print("-"*(60 + len(" Enhanced App Starting ")) + "\n")
 
-    print("Launching Gradio Interface for Gemini Agent Evaluation...")
+    print("Launching Enhanced Gradio Interface for Gemini Agent Evaluation...")
     demo.launch(debug=True, share=False)