fixing

app.py

@@ -5,8 +5,7 @@ import pandas as pd
 import json
 import re
 import time
-from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel
-from smolagents.tools import Tool
+from smolagents import CodeAgent, DuckDuckGoSearchTool, HfApiModel, tool
 from typing import Dict, Any, List
 import base64
 from io import BytesIO
@@ -18,237 +17,222 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Custom Tools ---
 
-class SerperSearchTool(Tool):
-    name = "serper_search"
-    description = "Search the web using Serper API for current information and specific queries"
-    inputs = {
-        "query": {
-            "type": "string", 
-            "description": "The search query"
-        }
-    }
-    output_type = "string"
+# --- Custom Tools ---
 
-    def __init__(self):
-        super().__init__()
-        self.api_key = os.getenv("SERPER_API_KEY")
-        if not self.api_key:
-            raise ValueError("SERPER_API_KEY environment variable not found")
+@tool
+def serper_search(query: str) -> str:
+    """Search the web using Serper API for current information and specific queries
+    
+    Args:
+        query: The search query
+        
+    Returns:
+        Search results as formatted string
+    """
+    try:
+        api_key = os.getenv("SERPER_API_KEY")
+        if not api_key:
+            return "SERPER_API_KEY environment variable not found"
+            
+        url = "https://google.serper.dev/search"
+        payload = json.dumps({"q": query, "num": 10})
+        headers = {
+            'X-API-KEY': api_key,
+            'Content-Type': 'application/json'
+        }
+        response = requests.post(url, headers=headers, data=payload, timeout=30)
+        response.raise_for_status()
+        
+        data = response.json()
+        results = []
+        
+        # Process organic results
+        if 'organic' in data:
+            for item in data['organic'][:5]:
+                results.append(f"Title: {item.get('title', '')}\nSnippet: {item.get('snippet', '')}\nURL: {item.get('link', '')}\n")
+        
+        # Add knowledge graph if available
+        if 'knowledgeGraph' in data:
+            kg = data['knowledgeGraph']
+            results.insert(0, f"Knowledge Graph: {kg.get('title', '')} - {kg.get('description', '')}\n")
+        
+        return "\n".join(results) if results else "No results found"
+        
+    except Exception as e:
+        return f"Search error: {str(e)}"
 
-    def forward(self, query: str) -> str:
-        try:
-            url = "https://google.serper.dev/search"
-            payload = json.dumps({"q": query, "num": 10})
-            headers = {
-                'X-API-KEY': self.api_key,
-                'Content-Type': 'application/json'
+@tool
+def wikipedia_search(query: str) -> str:
+    """Search Wikipedia for detailed information on topics
+    
+    Args:
+        query: The Wikipedia search query
+        
+    Returns:
+        Wikipedia search results
+    """
+    try:
+        # Search for pages
+        search_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
+        response = requests.get(search_url, timeout=15)
+        
+        if response.status_code == 200:
+            data = response.json()
+            return f"Title: {data.get('title', '')}\nSummary: {data.get('extract', '')}\nURL: {data.get('content_urls', {}).get('desktop', {}).get('page', '')}"
+        else:
+            # Fallback to search API
+            search_api = "https://en.wikipedia.org/w/api.php"
+            params = {
+                "action": "query",
+                "format": "json",
+                "list": "search",
+                "srsearch": query,
+                "srlimit": 3
             }
-            response = requests.post(url, headers=headers, data=payload, timeout=30)
-            response.raise_for_status()
-            
+            response = requests.get(search_api, params=params, timeout=15)
             data = response.json()
-            results = []
             
-            # Process organic results
-            if 'organic' in data:
-                for item in data['organic'][:5]:
-                    results.append(f"Title: {item.get('title', '')}\nSnippet: {item.get('snippet', '')}\nURL: {item.get('link', '')}\n")
-            
-            # Add knowledge graph if available
-            if 'knowledgeGraph' in data:
-                kg = data['knowledgeGraph']
-                results.insert(0, f"Knowledge Graph: {kg.get('title', '')} - {kg.get('description', '')}\n")
+            results = []
+            for item in data.get('query', {}).get('search', []):
+                results.append(f"Title: {item['title']}\nSnippet: {item['snippet']}")
             
-            return "\n".join(results) if results else "No results found"
+            return "\n\n".join(results) if results else "No Wikipedia results found"
             
-        except Exception as e:
-            return f"Search error: {str(e)}"
-
-class WikipediaSearchTool(Tool):
-    name = "wikipedia_search"
-    description = "Search Wikipedia for detailed information on topics"
-    inputs = {
-        "query": {
-            "type": "string",
-            "description": "The Wikipedia search query"
-        }
-    }
-    output_type = "string"
+    except Exception as e:
+        return f"Wikipedia search error: {str(e)}"
 
-    def forward(self, query: str) -> str:
-        try:
-            # Search for pages
-            search_url = "https://en.wikipedia.org/api/rest_v1/page/summary/" + query.replace(" ", "_")
-            response = requests.get(search_url, timeout=15)
+@tool
+def youtube_analyzer(url: str) -> str:
+    """Analyze YouTube videos to extract information from titles, descriptions, and comments
+    
+    Args:
+        url: YouTube video URL
+        
+    Returns:
+        Video information and analysis
+    """
+    try:
+        # Extract video ID
+        video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11}).*', url)
+        if not video_id_match:
+            return "Invalid YouTube URL"
+        
+        video_id = video_id_match.group(1)
+        
+        # Use oEmbed API to get basic info
+        oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
+        response = requests.get(oembed_url, timeout=15)
+        
+        if response.status_code == 200:
+            data = response.json()
+            result = f"Title: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}\n"
             
-            if response.status_code == 200:
-                data = response.json()
-                return f"Title: {data.get('title', '')}\nSummary: {data.get('extract', '')}\nURL: {data.get('content_urls', {}).get('desktop', {}).get('page', '')}"
-            else:
-                # Fallback to search API
-                search_api = "https://en.wikipedia.org/w/api.php"
-                params = {
-                    "action": "query",
-                    "format": "json",
-                    "list": "search",
-                    "srsearch": query,
-                    "srlimit": 3
-                }
-                response = requests.get(search_api, params=params, timeout=15)
-                data = response.json()
-                
-                results = []
-                for item in data.get('query', {}).get('search', []):
-                    results.append(f"Title: {item['title']}\nSnippet: {item['snippet']}")
-                
-                return "\n\n".join(results) if results else "No Wikipedia results found"
+            # Try to get additional info by scraping (basic)
+            try:
+                video_url = f"https://www.youtube.com/watch?v={video_id}"
+                headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
+                page_response = requests.get(video_url, headers=headers, timeout=15)
                 
-        except Exception as e:
-            return f"Wikipedia search error: {str(e)}"
-
-class YouTubeAnalyzerTool(Tool):
-    name = "youtube_analyzer"
-    description = "Analyze YouTube videos to extract information from titles, descriptions, and comments"
-    inputs = {
-        "url": {
-            "type": "string",
-            "description": "YouTube video URL"
-        }
-    }
-    output_type = "string"
-
-    def forward(self, url: str) -> str:
-        try:
-            # Extract video ID
-            video_id_match = re.search(r'(?:v=|\/)([0-9A-Za-z_-]{11}).*', url)
-            if not video_id_match:
-                return "Invalid YouTube URL"
+                if page_response.status_code == 200:
+                    content = page_response.text
+                    # Extract description from meta tags
+                    desc_match = re.search(r'"description":{"simpleText":"([^"]+)"', content)
+                    if desc_match:
+                        result += f"Description: {desc_match.group(1)}\n"
+                        
+                    # Look for bird-related content
+                    if "bird" in content.lower():
+                        bird_matches = re.findall(r'\b\d+\s+bird', content.lower())
+                        if bird_matches:
+                            result += f"Bird mentions found: {bird_matches}\n"
             
-            video_id = video_id_match.group(1)
+            except:
+                pass
             
-            # Use oEmbed API to get basic info
-            oembed_url = f"https://www.youtube.com/oembed?url=https://www.youtube.com/watch?v={video_id}&format=json"
-            response = requests.get(oembed_url, timeout=15)
+            return result
+        else:
+            return "Could not retrieve video information"
             
-            if response.status_code == 200:
-                data = response.json()
-                result = f"Title: {data.get('title', '')}\nAuthor: {data.get('author_name', '')}\n"
-                
-                # Try to get additional info by scraping (basic)
-                try:
-                    video_url = f"https://www.youtube.com/watch?v={video_id}"
-                    headers = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36'}
-                    page_response = requests.get(video_url, headers=headers, timeout=15)
-                    
-                    if page_response.status_code == 200:
-                        content = page_response.text
-                        # Extract description from meta tags
-                        desc_match = re.search(r'"description":{"simpleText":"([^"]+)"', content)
-                        if desc_match:
-                            result += f"Description: {desc_match.group(1)}\n"
-                
-                except:
-                    pass
-                
-                return result
-            else:
-                return "Could not retrieve video information"
-                
-        except Exception as e:
-            return f"YouTube analysis error: {str(e)}"
-
-class TextProcessorTool(Tool):
-    name = "text_processor"
-    description = "Process text for various operations like reversing, parsing, and analyzing"
-    inputs = {
-        "text": {
-            "type": "string",
-            "description": "Text to process"
-        },
-        "operation": {
-            "type": "string",
-            "description": "Operation to perform: reverse, parse, analyze"
-        }
-    }
-    output_type = "string"
-
-    def forward(self, text: str, operation: str = "analyze") -> str:
-        try:
-            if operation == "reverse":
-                return text[::-1]
-            elif operation == "parse":
-                # Extract meaningful information
-                words = text.split()
-                return f"Word count: {len(words)}\nFirst word: {words[0] if words else 'None'}\nLast word: {words[-1] if words else 'None'}"
-            else:
-                # General analysis
-                return f"Text length: {len(text)}\nWord count: {len(text.split())}\nText: {text[:200]}..."
-        except Exception as e:
-            return f"Text processing error: {str(e)}"
-
-class MathSolverTool(Tool):
-    name = "math_solver"
-    description = "Solve mathematical problems and analyze mathematical structures"
-    inputs = {
-        "problem": {
-            "type": "string",
-            "description": "Mathematical problem or structure to analyze"
-        }
-    }
-    output_type = "string"
+    except Exception as e:
+        return f"YouTube analysis error: {str(e)}"
 
-    def forward(self, problem: str) -> str:
-        try:
-            # Basic math operations and analysis
-            if "commutative" in problem.lower():
-                return "To check commutativity, verify if a*b = b*a for all elements. Find counter-examples where this fails."
-            elif "chess" in problem.lower():
-                return "For chess problems, analyze the position systematically: check for checks, captures, tactical motifs like pins, forks, or checkmate patterns."
-            else:
-                return f"Mathematical analysis needed for: {problem[:100]}..."
-        except Exception as e:
-            return f"Math solver error: {str(e)}"
+@tool
+def text_processor(text: str, operation: str = "analyze") -> str:
+    """Process text for various operations like reversing, parsing, and analyzing
+    
+    Args:
+        text: Text to process
+        operation: Operation to perform (reverse, parse, analyze)
+        
+    Returns:
+        Processed text result
+    """
+    try:
+        if operation == "reverse":
+            return text[::-1]
+        elif operation == "parse":
+            # Extract meaningful information
+            words = text.split()
+            return f"Word count: {len(words)}\nFirst word: {words[0] if words else 'None'}\nLast word: {words[-1] if words else 'None'}"
+        else:
+            # General analysis
+            return f"Text length: {len(text)}\nWord count: {len(text.split())}\nText: {text[:200]}..."
+    except Exception as e:
+        return f"Text processing error: {str(e)}"
 
-class DataExtractorTool(Tool):
-    name = "data_extractor"
-    description = "Extract structured data from various sources"
-    inputs = {
-        "source": {
-            "type": "string",
-            "description": "Data source or content to extract from"
-        },
-        "target": {
-            "type": "string", 
-            "description": "What to extract"
-        }
-    }
-    output_type = "string"
+@tool
+def math_solver(problem: str) -> str:
+    """Solve mathematical problems and analyze mathematical structures
+    
+    Args:
+        problem: Mathematical problem or structure to analyze
+        
+    Returns:
+        Mathematical analysis and solution
+    """
+    try:
+        # Basic math operations and analysis
+        if "commutative" in problem.lower():
+            return "To check commutativity, verify if a*b = b*a for all elements. Find counter-examples where this fails."
+        elif "chess" in problem.lower():
+            return "For chess problems, analyze the position systematically: check for checks, captures, tactical motifs like pins, forks, or checkmate patterns."
+        else:
+            return f"Mathematical analysis needed for: {problem[:100]}..."
+    except Exception as e:
+        return f"Math solver error: {str(e)}"
 
-    def forward(self, source: str, target: str) -> str:
-        try:
-            # Botanical classification helper
-            if "botanical" in target.lower() or "vegetable" in target.lower():
-                vegetables = []
-                fruits = []
-                
-                # Common botanical classifications
-                botanical_fruits = ["bell pepper", "corn", "green beans", "plums", "zucchini", "acorns", "peanuts"]
-                botanical_vegetables = ["sweet potatoes", "fresh basil", "broccoli", "celery", "lettuce"]
-                
-                items = [item.strip() for item in source.split(",")]
-                
-                for item in items:
-                    item_lower = item.lower()
-                    if any(veg in item_lower for veg in ["potato", "basil", "broccoli", "celery", "lettuce"]):
-                        vegetables.append(item)
-                
-                vegetables.sort()
-                return ", ".join(vegetables)
+@tool
+def data_extractor(source: str, target: str) -> str:
+    """Extract structured data from various sources
+    
+    Args:
+        source: Data source or content to extract from
+        target: What to extract
+        
+    Returns:
+        Extracted data
+    """
+    try:
+        # Botanical classification helper
+        if "botanical" in target.lower() or "vegetable" in target.lower():
+            vegetables = []
             
-            return f"Data extraction for {target} from {source[:100]}..."
+            # Common botanical classifications - only true vegetables
+            items = [item.strip() for item in source.split(",")]
             
-        except Exception as e:
-            return f"Data extraction error: {str(e)}"
+            for item in items:
+                item_lower = item.lower()
+                # Only include botanically true vegetables (not fruits used as vegetables)
+                if any(veg in item_lower for veg in ["sweet potato", "basil", "broccoli", "celery", "lettuce"]):
+                    vegetables.append(item)
+            
+            vegetables.sort()
+            return ", ".join(vegetables)
+        
+        return f"Data extraction for {target} from {source[:100]}..."
+        
+    except Exception as e:
+        return f"Data extraction error: {str(e)}"
 
 # --- Enhanced Agent Definition ---
 class GAIAAgent:
@@ -261,22 +245,26 @@ class GAIAAgent:
             token=os.getenv("HUGGINGFACE_INFERENCE_TOKEN")
         )
         
-        # Initialize tools
-        self.tools = [
-            SerperSearchTool(),
-            DuckDuckGoSearchTool(),
-            WikipediaSearchTool(),
-            YouTubeAnalyzerTool(),
-            TextProcessorTool(),
-            MathSolverTool(),
-            DataExtractorTool()
+        # Custom tools list
+        custom_tools = [
+            serper_search,
+            wikipedia_search, 
+            youtube_analyzer,
+            text_processor,
+            math_solver,
+            data_extractor
         ]
         
-        # Create agent
+        # Add DuckDuckGo search tool
+        ddg_tool = DuckDuckGoSearchTool()
+        
+        # Create agent with all tools
+        all_tools = custom_tools + [ddg_tool]
+        
         self.agent = CodeAgent(
-            tools=self.tools,
+            tools=all_tools,
             model=self.model,
-            max_iterations=5
+            max_iterations=3
         )
         
         print("GAIA Agent initialized successfully.")
@@ -291,60 +279,52 @@ class GAIAAgent:
             # Handle reversed text question
             if "ecnetnes siht dnatsrednu uoy fi" in question.lower():
                 # This is the reversed sentence question
-                processor = TextProcessorTool()
                 reversed_part = question.split("?,")[0]  # Get the reversed part
-                normal_text = processor.forward(reversed_part, "reverse")
+                normal_text = text_processor(reversed_part, "reverse")
                 if "left" in normal_text.lower():
                     return "right"
             
             # Handle YouTube video questions
             elif "youtube.com" in question:
-                youtube_tool = YouTubeAnalyzerTool()
                 # Extract URL
                 url_match = re.search(r'https://www\.youtube\.com/watch\?v=[^\s,?.]+', question)
                 if url_match:
                     url = url_match.group(0)
-                    video_info = youtube_tool.forward(url)
+                    video_info = youtube_analyzer(url)
                     
                     # Use search to get more specific info about the video content
-                    search_tool = SerperSearchTool()
                     search_query = f"site:youtube.com {url} transcript content"
-                    search_results = search_tool.forward(search_query)
+                    search_results = serper_search(search_query)
                     
                     return f"Video Analysis: {video_info}\n\nAdditional Info: {search_results}"
             
             # Handle botanical/grocery list questions
             elif "botanical" in question_lower and "vegetable" in question_lower:
-                extractor = DataExtractorTool()
                 # Extract the list from the question
                 list_match = re.search(r'milk.*?peanuts', question)
                 if list_match:
                     food_list = list_match.group(0)
-                    return extractor.forward(food_list, "botanical vegetables")
+                    return data_extractor(food_list, "botanical vegetables")
             
             # Handle mathematical problems
             elif "commutative" in question_lower or "chess" in question_lower:
-                math_tool = MathSolverTool()
-                math_result = math_tool.forward(question)
+                math_result = math_solver(question)
                 
                 # For commutative question, also search for more specific help
                 if "commutative" in question_lower:
-                    search_tool = SerperSearchTool()
-                    search_result = search_tool.forward("group theory commutative operation counter examples")
+                    search_result = serper_search("group theory commutative operation counter examples")
                     return f"{math_result}\n\nAdditional context: {search_result}"
+                
+                return math_result
             
             # Handle specific factual questions
             else:
                 # Use search tools for factual questions
-                search_tool = SerperSearchTool()
-                wiki_tool = WikipediaSearchTool()
-                
-                # Try Serper search first
-                search_results = search_tool.forward(question)
+                search_results = serper_search(question)
                 
                 # For some questions, also try Wikipedia
                 if any(term in question_lower for term in ["mercedes sosa", "dinosaur", "wikipedia", "olympics"]):
-                    wiki_results = wiki_tool.forward(question)
+                    wiki_results = wikipedia_search(question)
                     return f"Search Results: {search_results}\n\nWikipedia: {wiki_results}"
                 
                 return search_results
@@ -353,8 +333,7 @@ class GAIAAgent:
             print(f"Error in agent processing: {e}")
             # Fallback to basic search
             try:
-                search_tool = SerperSearchTool()
-                return search_tool.forward(question)
+                return serper_search(question)
             except:
                 return f"I encountered an error processing this question: {question}. Please try rephrasing or breaking it into smaller parts."
 

requirements.txt

@@ -2,10 +2,10 @@ gradio==4.44.0
 requests==2.31.0
 pandas==2.0.3
 smolagents==1.19.0
-transformers==4.35.2
+transformers==4.44.2  
+huggingface-hub>=0.31.2
 torch==2.1.0
 Pillow==10.0.1
 numpy==1.24.3
-huggingface-hub==0.19.4
 datasets==2.14.6
 accelerate==0.24.1