Enhanced agent with web search, Wikipedia, and multi-step reasoning capabilities

.python-version

@@ -0,0 +1 @@
+3.12.4

app.py

@@ -3,21 +3,156 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import re
+import wikipedia
+from duckduckgo_search import DDGS
+from urllib.parse import urlparse
+import json
+from datetime import datetime
+from bs4 import BeautifulSoup
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
+# --- Enhanced Agent Definition ---
 class BasicAgent:
     def __init__(self):
-        print("BasicAgent initialized.")
+        print("Enhanced BasicAgent initialized with tools.")
+        self.ddgs = DDGS()
+    
+    def search_web(self, query, max_results=3):
+        """Search the web using DuckDuckGo"""
+        try:
+            results = list(self.ddgs.text(query, max_results=max_results))
+            return [{"title": r["title"], "body": r["body"], "href": r["href"]} for r in results]
+        except Exception as e:
+            print(f"Web search error: {e}")
+            return []
+    
+    def search_wikipedia(self, query):
+        """Search Wikipedia for information"""
+        try:
+            # Search for pages
+            search_results = wikipedia.search(query, results=3)
+            if not search_results:
+                return None
+            
+            # Get the first result
+            page = wikipedia.page(search_results[0])
+            return {
+                "title": page.title,
+                "summary": wikipedia.summary(search_results[0], sentences=3),
+                "content": page.content[:2000],  # First 2000 chars
+                "url": page.url
+            }
+        except Exception as e:
+            print(f"Wikipedia search error: {e}")
+            return None
+    
+    def extract_numbers(self, text):
+        """Extract numbers from text"""
+        numbers = re.findall(r'\d+\.?\d*', text)
+        return [float(n) if '.' in n else int(n) for n in numbers]
+    
+    def extract_years(self, text):
+        """Extract years from text (4-digit numbers between 1000-2100)"""
+        years = re.findall(r'\b(1[0-9]{3}|20[0-9]{2}|2100)\b', text)
+        return [int(year) for year in years]
+    
+    def calculate_basic_math(self, expression):
+        """Safely evaluate basic math expressions"""
+        try:
+            # Only allow basic math operations for safety
+            allowed_chars = set('0123456789+-*/.() ')
+            if all(c in allowed_chars for c in expression):
+                return eval(expression)
+        except:
+            pass
+        return None
+    
+    def process_question(self, question):
+        """Main reasoning engine"""
+        question_lower = question.lower()
+        
+        # Check if it's a math question
+        if any(word in question_lower for word in ['calculate', 'add', 'subtract', 'multiply', 'divide', '+', '-', '*', '/']):
+            numbers = self.extract_numbers(question)
+            if len(numbers) >= 2:
+                if '+' in question or 'add' in question_lower:
+                    return str(sum(numbers))
+                elif '-' in question or 'subtract' in question_lower:
+                    return str(numbers[0] - numbers[1])
+                elif '*' in question or 'multiply' in question_lower:
+                    return str(numbers[0] * numbers[1])
+                elif '/' in question or 'divide' in question_lower:
+                    if numbers[1] != 0:
+                        return str(numbers[0] / numbers[1])
+        
+        # Check if it's asking for a year or date
+        if any(word in question_lower for word in ['year', 'when', 'date']):
+            # Search for the answer
+            search_results = self.search_web(question, max_results=2)
+            wiki_result = self.search_wikipedia(question)
+            
+            # Extract years from results
+            all_text = question
+            if search_results:
+                all_text += " " + " ".join([r["body"] for r in search_results])
+            if wiki_result:
+                all_text += " " + wiki_result["summary"]
+            
+            years = self.extract_years(all_text)
+            if years:
+                # Return the most frequently mentioned year, or the first one
+                return str(max(set(years), key=years.count))
+        
+        # Check if it's asking for a specific fact or entity
+        if any(word in question_lower for word in ['what', 'who', 'where', 'which', 'how many']):
+            # Try Wikipedia first for factual questions
+            wiki_result = self.search_wikipedia(question)
+            if wiki_result:
+                # Look for numbers in the summary that might be the answer
+                numbers = self.extract_numbers(wiki_result["summary"])
+                if numbers and 'how many' in question_lower:
+                    return str(numbers[0])
+                
+                # For other questions, try to extract a short answer
+                summary = wiki_result["summary"]
+                sentences = summary.split('.')
+                if sentences:
+                    return sentences[0].strip()
+            
+            # Fall back to web search
+            search_results = self.search_web(question, max_results=3)
+            if search_results:
+                # Try to find a concise answer in the search results
+                for result in search_results:
+                    body = result["body"]
+                    if len(body) < 200:  # Prefer shorter, more direct answers
+                        return body.strip()
+                
+                # Return first result if no short answer found
+                return search_results[0]["body"][:200].strip()
+        
+        # If no specific pattern matches, try a general web search
+        search_results = self.search_web(question, max_results=2)
+        if search_results:
+            return search_results[0]["body"][:100].strip()
+        
+        # Fallback
+        return "Unable to determine answer"
+    
     def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        print(f"Agent processing question: {question[:100]}...")
+        
+        try:
+            answer = self.process_question(question)
+            print(f"Agent answer: {answer}")
+            return answer
+        except Exception as e:
+            print(f"Error processing question: {e}")
+            return "Error processing question"
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """

main.py

@@ -0,0 +1,6 @@
+def main():
+    print("Hello from final-assignment-template!")
+
+
+if __name__ == "__main__":
+    main()

pyproject.toml

@@ -0,0 +1,16 @@
+[project]
+name = "final-assignment-template"
+version = "0.1.0"
+description = "Add your description here"
+requires-python = ">=3.12.4"
+dependencies = [
+    "beautifulsoup4>=4.13.4",
+    "duckduckgo-search>=8.1.1",
+    "gradio[oauth]>=5.36.2",
+    "pillow>=11.3.0",
+    "python-dateutil>=2.9.0.post0",
+    "requests>=2.32.4",
+    "torch>=2.7.1",
+    "transformers>=4.53.2",
+    "wikipedia>=1.4.0",
+]

requirements.txt

@@ -1,2 +1,9 @@
 gradio
-requests
+requests
+transformers
+torch
+pillow
+wikipedia
+duckduckgo-search
+beautifulsoup4
+python-dateutil

test_agent.py

@@ -0,0 +1,138 @@
+import re
+import wikipedia
+from duckduckgo_search import DDGS
+
+class BasicAgent:
+    def __init__(self):
+        print("Enhanced BasicAgent initialized with tools.")
+        self.ddgs = DDGS()
+    
+    def search_web(self, query, max_results=3):
+        """Search the web using DuckDuckGo"""
+        try:
+            results = list(self.ddgs.text(query, max_results=max_results))
+            return [{"title": r["title"], "body": r["body"], "href": r["href"]} for r in results]
+        except Exception as e:
+            print(f"Web search error: {e}")
+            return []
+    
+    def search_wikipedia(self, query):
+        """Search Wikipedia for information"""
+        try:
+            search_results = wikipedia.search(query, results=3)
+            if not search_results:
+                return None
+            
+            page = wikipedia.page(search_results[0])
+            return {
+                "title": page.title,
+                "summary": wikipedia.summary(search_results[0], sentences=3),
+                "content": page.content[:2000],
+                "url": page.url
+            }
+        except Exception as e:
+            print(f"Wikipedia search error: {e}")
+            return None
+    
+    def extract_numbers(self, text):
+        """Extract numbers from text"""
+        numbers = re.findall(r'\d+\.?\d*', text)
+        return [float(n) if '.' in n else int(n) for n in numbers]
+    
+    def extract_years(self, text):
+        """Extract years from text (4-digit numbers between 1000-2100)"""
+        years = re.findall(r'\b(1[0-9]{3}|20[0-9]{2}|2100)\b', text)
+        return [int(year) for year in years]
+    
+    def process_question(self, question):
+        """Main reasoning engine"""
+        question_lower = question.lower()
+        
+        # Check if it's a math question
+        if any(word in question_lower for word in ['calculate', 'add', 'subtract', 'multiply', 'divide', '+', '-', '*', '/']):
+            numbers = self.extract_numbers(question)
+            if len(numbers) >= 2:
+                if '+' in question or 'add' in question_lower:
+                    return str(sum(numbers))
+                elif '-' in question or 'subtract' in question_lower:
+                    return str(numbers[0] - numbers[1])
+                elif '*' in question or 'multiply' in question_lower:
+                    return str(numbers[0] * numbers[1])
+                elif '/' in question or 'divide' in question_lower:
+                    if numbers[1] != 0:
+                        return str(numbers[0] / numbers[1])
+        
+        # Check if it's asking for a year or date
+        if any(word in question_lower for word in ['year', 'when', 'date']):
+            search_results = self.search_web(question, max_results=2)
+            wiki_result = self.search_wikipedia(question)
+            
+            all_text = question
+            if search_results:
+                all_text += " " + " ".join([r["body"] for r in search_results])
+            if wiki_result:
+                all_text += " " + wiki_result["summary"]
+            
+            years = self.extract_years(all_text)
+            if years:
+                return str(max(set(years), key=years.count))
+        
+        # Check if it's asking for a specific fact or entity
+        if any(word in question_lower for word in ['what', 'who', 'where', 'which', 'how many']):
+            wiki_result = self.search_wikipedia(question)
+            if wiki_result:
+                numbers = self.extract_numbers(wiki_result["summary"])
+                if numbers and 'how many' in question_lower:
+                    return str(numbers[0])
+                
+                summary = wiki_result["summary"]
+                sentences = summary.split('.')
+                if sentences:
+                    return sentences[0].strip()
+            
+            search_results = self.search_web(question, max_results=3)
+            if search_results:
+                for result in search_results:
+                    body = result["body"]
+                    if len(body) < 200:
+                        return body.strip()
+                
+                return search_results[0]["body"][:200].strip()
+        
+        search_results = self.search_web(question, max_results=2)
+        if search_results:
+            return search_results[0]["body"][:100].strip()
+        
+        return "Unable to determine answer"
+    
+    def __call__(self, question: str) -> str:
+        print(f"Agent processing question: {question[:100]}...")
+        
+        try:
+            answer = self.process_question(question)
+            print(f"Agent answer: {answer}")
+            return answer
+        except Exception as e:
+            print(f"Error processing question: {e}")
+            return "Error processing question"
+
+# Test the agent
+if __name__ == "__main__":
+    agent = BasicAgent()
+    
+    # Test questions
+    test_questions = [
+        "What is 15 + 27?",
+        "When was the Eiffel Tower built?",
+        "Who was the first person to walk on the moon?",
+        "What is the capital of France?"
+    ]
+    
+    print("Testing Enhanced Agent:")
+    print("=" * 50)
+    
+    for i, question in enumerate(test_questions, 1):
+        print(f"\n{i}. Question: {question}")
+        answer = agent(question)
+        print(f"   Answer: {answer}")
+        print("-" * 30)