Upload 3 files

main.py

@@ -0,0 +1,242 @@
+import os
+import gradio as gr
+import requests
+import inspect
+import pandas as pd
+from smolagents_agent import SmolagentsGAIAgent
+from   huggingface_hub import login
+
+# --- Constants ---
+
+login(os.getenv("HF_TOKEN"))
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the AdvancedAgent on them, submits all answers,
+    and displays the results.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID")
+
+    if profile:
+        username = f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
+
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 1. Instantiate Smolagents GAIA Agent
+    try:
+        agent = SmolagentsGAIAgent()
+        print("Smolagents GAIA Agent initialized successfully!")
+    except Exception as e:
+        print(f"Error instantiating smolagents agent: {e}")
+        return f"Error initializing smolagents agent: {e}", None
+    
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"Agent code link: {agent_code}")
+
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             print("Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         return f"Error decoding server response for questions: {e}", None
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run Advanced Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running multi-agent system 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
+            
+        try:
+            print(f"\n--- Processing Question {i+1}/{len(questions_data)} ---")
+            print(f"Task ID: {task_id}")
+            print(f"Question: {question_text[:100]}...")
+            
+            # Run the smolagents agent
+            submitted_answer = agent.process_question(question_text)
+            
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text, 
+                "Submitted Answer": submitted_answer
+            })
+            
+            print(f"Answer: {submitted_answer[:100]}...")
+            
+        except Exception as e:
+             print(f"Error running agent on task {task_id}: {e}")
+             error_answer = f"AGENT ERROR: {e}"
+             answers_payload.append({"task_id": task_id, "submitted_answer": error_answer})
+             results_log.append({
+                 "Task ID": task_id, 
+                 "Question": question_text, 
+                 "Submitted Answer": error_answer
+             })
+
+    if not answers_payload:
+        print("Smolagents agent did not produce any answers to submit.")
+        return "Smolagents agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Prepare Submission 
+    submission_data = {
+        "username": username.strip(), 
+        "agent_code": agent_code, 
+        "answers": answers_payload
+    }
+    
+    status_update = f"Smolagents agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"Message: {result_data.get('message', 'No message received.')}"
+        )
+        
+        print("Submission successful!")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
+        
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        
+        status_message = f"Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+        
+    except requests.exceptions.Timeout:
+        status_message = "Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+    except requests.exceptions.RequestException as e:
+        status_message = f"Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+    except Exception as e:
+        status_message = f"An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks(title="Multi-Agent System - GAIA Benchmark") as demo:
+    gr.Markdown("# Smolagents GAIA Agent Evaluation")
+    gr.Markdown(
+        """
+        ## Your Smolagents Agent Features:
+        - **Calculator Tool**: Mathematical calculations and equation solving
+        - **Web Search Tool**: Real-time information retrieval from the web
+        - **Wikipedia Tool**: Access to structured knowledge and facts
+        - **File Processing Tools**: PDF and CSV document analysis
+        - **Reasoning Tool**: Logical analysis and problem decomposition
+        - **Visit Webpage Tool**: Direct webpage content extraction
+
+        ## Instructions:
+        1. **Login** to Hugging Face using the button below
+        2. **Click** 'Run Evaluation & Submit All Answers'
+        3. **Wait** for your smolagents agent to process all questions (this may take time)
+        4. **View** your score and detailed results
+
+        ## How the Smolagents Agent Works:
+        - **Question Classification**: Automatically routes questions to appropriate tools
+        - **Tool Integration**: Seamlessly uses multiple tools for comprehensive answers
+        - **Code Generation**: Leverages Python code execution for complex tasks
+        - **Iterative Refinement**: Improves answers through multiple reasoning steps
+
+        **Note**: This evaluation may take several minutes as the agent processes questions using the GAIA benchmark.
+        """
+    )
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Smolagents GAIA Evaluation & Submit All Answers", variant="primary")
+
+    status_output = gr.Textbox(
+        label="📊 Run Status / Submission Result", 
+        lines=8, 
+        interactive=False
+    )
+    
+    results_table = gr.DataFrame(
+        label="📋 Questions and Agent Answers",
+        wrap=True
+    )
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+
+if __name__ == "__main__":
+    print("\n" + "="*50 + " Smolagents GAIA Agent App Starting " + "="*50)
+
+    # Check environment variables
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+
+    if space_host_startup:
+        print(f"[OK] SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL: https://{space_host_startup}.hf.space")
+    else:
+        print("[INFO] SPACE_HOST not found (running locally)")
+
+    if space_id_startup:
+        print(f"[OK] SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   Code URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("[INFO] SPACE_ID not found (running locally)")
+
+    print("="*(100 + len(" Smolagents GAIA Agent App Starting ")) + "\n")
+
+    print("Launching Smolagents GAIA Agent Evaluation Interface...")
+    demo.launch(debug=True, share=False)

requirements.txt

@@ -0,0 +1,12 @@
+gradio[oauth]
+requests
+pandas
+numpy
+duckduckgo-search
+wikipedia
+PyPDF2
+python-docx
+beautifulsoup4
+sympy
+smolagents[litellm]
+python-dotenv

smolagents_agent.py

@@ -0,0 +1,304 @@
+from smolagents import Tool, CodeAgent, InferenceClientModel, LiteLLMModel
+from smolagents import DuckDuckGoSearchTool, VisitWebpageTool
+import os
+import re
+import math
+import ast
+import pandas as pd
+from typing import Optional
+from dotenv import load_dotenv
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Custom Calculator Tool
+class CalculatorTool(Tool):
+    name = "calculator"
+    description = "A tool to perform mathematical calculations and solve equations"
+    inputs = {
+        "expression": {
+            "type": "string",
+            "description": "The mathematical expression to evaluate (e.g., '2 + 3 * 4', 'sqrt(16)', 'pi * r**2')"
+        }
+    }
+    output_type = "string"
+
+    def forward(self, expression: str) -> str:
+        try:
+            # Clean and preprocess expression
+            expression = expression.strip()
+
+            # Replace common math functions
+            replacements = {
+                'sin': 'math.sin',
+                'cos': 'math.cos',
+                'tan': 'math.tan',
+                'log': 'math.log',
+                'sqrt': 'math.sqrt',
+                'pi': 'math.pi',
+                'e': 'math.e',
+                '^': '**'
+            }
+
+            for old, new in replacements.items():
+                expression = expression.replace(old, new)
+
+            # Safe evaluation
+            allowed_names = {
+                'math': math,
+                'abs': abs,
+                'min': min,
+                'max': max,
+                'round': round,
+                'sum': sum
+            }
+
+            result = eval(expression, {"__builtins__": {}}, allowed_names)
+            return str(result)
+
+        except Exception as e:
+            return f"Calculation error: {str(e)}"
+
+# Custom Wikipedia Search Tool (since WikipediaSearchTool might not be available)
+class WikipediaTool(Tool):
+    name = "wikipedia_search"
+    description = "Search Wikipedia for information about a topic"
+    inputs = {
+        "topic": {
+            "type": "string",
+            "description": "The topic to search for on Wikipedia"
+        }
+    }
+    output_type = "string"
+
+    def forward(self, topic: str) -> str:
+        try:
+            import wikipedia
+            summary = wikipedia.summary(topic, sentences=3)
+            return summary
+        except wikipedia.exceptions.DisambiguationError as e:
+            options = e.options[:3]
+            return f"Multiple options found: {', '.join(options)}. Please be more specific."
+        except Exception as e:
+            return f"Wikipedia search error: {str(e)}"
+
+# File Processing Tools
+class PDFReaderTool(Tool):
+    name = "pdf_reader"
+    description = "Extract text content from a PDF file"
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Path to the PDF file to read"
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        try:
+            import PyPDF2
+            with open(file_path, 'rb') as file:
+                pdf_reader = PyPDF2.PdfReader(file)
+                text = ""
+                for page in pdf_reader.pages:
+                    text += page.extract_text()
+                return text.strip()
+        except Exception as e:
+            return f"PDF reading error: {str(e)}"
+
+class CSVAnalyzerTool(Tool):
+    name = "csv_analyzer"
+    description = "Analyze and summarize CSV file data"
+    inputs = {
+        "file_path": {
+            "type": "string",
+            "description": "Path to the CSV file to analyze"
+        }
+    }
+    output_type = "string"
+
+    def forward(self, file_path: str) -> str:
+        try:
+            df = pd.read_csv(file_path)
+            summary = f"Shape: {df.shape}\n"
+            summary += f"Columns: {list(df.columns)}\n"
+            summary += f"Sample data:\n{df.head().to_string()}\n"
+
+            if df.select_dtypes(include=[float, int]).shape[1] > 0:
+                summary += f"Statistics:\n{df.describe().to_string()}"
+
+            return summary
+        except Exception as e:
+            return f"CSV analysis error: {str(e)}"
+
+# Reasoning Tool
+class ReasoningTool(Tool):
+    name = "reasoning_helper"
+    description = "Help with logical reasoning and problem decomposition"
+    inputs = {
+        "question": {
+            "type": "string",
+            "description": "The reasoning question or problem to analyze"
+        }
+    }
+    output_type = "string"
+
+    def forward(self, question: str) -> str:
+        # Simple reasoning helper - decompose questions
+        sub_questions = []
+
+        # Look for multi-part questions
+        if any(word in question.lower() for word in ['and', 'also', 'additionally', 'furthermore']):
+            parts = re.split(r'\band\b|\balso\b|\badditionally\b|\bfurthermore\b', question, flags=re.IGNORECASE)
+            sub_questions = [part.strip() for part in parts if part.strip()]
+
+        # Look for numbered questions
+        numbered_pattern = r'(\d+)\.\s*(.+?)(?=\d+\.|$)'
+        matches = re.findall(numbered_pattern, question)
+        if matches:
+            sub_questions = [match[1].strip() for match in matches]
+
+        if sub_questions:
+            return f"This appears to be a multi-part question. Breaking it down:\n" + "\n".join(f"- {q}" for q in sub_questions)
+        else:
+            return "This appears to be a single reasoning question. Consider breaking it down into smaller steps or gathering more information."
+
+# Main Smolagents Agent
+class SmolagentsGAIAgent:
+    def __init__(self):
+        # Initialize tools
+        self.calculator = CalculatorTool()
+        self.wikipedia = WikipediaTool()
+        self.pdf_reader = PDFReaderTool()
+        self.csv_analyzer = CSVAnalyzerTool()
+        self.reasoning = ReasoningTool()
+
+        # Use built-in search tools
+        self.web_search = DuckDuckGoSearchTool()
+        self.visit_webpage = VisitWebpageTool()
+
+        # Collect all tools
+        self.tools = [
+            self.calculator,
+            self.wikipedia,
+            self.pdf_reader,
+            self.csv_analyzer,
+            self.reasoning,
+            self.web_search,
+            self.visit_webpage
+        ]
+
+        # Initialize model
+        self.model = self._initialize_model()
+
+        # Create the agent
+        self.agent = CodeAgent(
+            tools=self.tools,
+            model=self.model,
+            max_steps=10,  # Limit steps for GAIA efficiency
+            verbosity_level=1
+        )
+
+    def _initialize_model(self):
+        """Initialize the language model"""
+        hf_token = os.getenv("HF_TOKEN")
+
+        # First try local Ollama (recommended by course)
+        try:
+            model = LiteLLMModel(
+                model_id="ollama_chat/qwen2:7b",
+                api_base="http://127.0.0.1:11434"
+            )
+            print("Using local Ollama model (qwen2:7b)")
+            return model
+        except Exception as e:
+            print(f"Local Ollama not available: {e}")
+
+        # Fallback to HF Inference API if token available
+        if hf_token:
+            try:
+                model = InferenceClientModel(
+                    model_id="Qwen/Qwen2.5-7B-Instruct",
+                    token=hf_token
+                )
+                print("Using Hugging Face Inference API")
+                return model
+            except Exception as e:
+                print(f"HF Inference API failed: {e}")
+
+        print("No language model available. Please:")
+        print("   1. Install Ollama: https://ollama.ai/")
+        print("   2. Run: ollama pull qwen2:7b")
+        print("   3. Run: ollama serve")
+        print("   Or ensure HF_TOKEN has proper permissions")
+        return None
+
+    def classify_question(self, question: str) -> str:
+        """Classify question type for routing"""
+        question_lower = question.lower()
+
+        # Mathematical questions
+        math_keywords = ['calculate', 'compute', 'solve', 'equation', 'formula', 'sum', 'product', 'area', 'radius', 'sqrt']
+        has_math = any(keyword in question_lower for keyword in math_keywords)
+        has_arithmetic = bool(re.search(r'\d+[\s\+\-\*\/x]\d+', question))
+
+        if has_math or has_arithmetic or (re.search(r'\d+', question) and ('what' in question_lower or 'how' in question_lower)):
+            return "mathematical"
+
+        # File processing
+        file_keywords = ['pdf', 'document', 'file', 'csv', 'excel', 'text', 'read']
+        if any(keyword in question_lower for keyword in file_keywords):
+            return "file_processing"
+
+        # Reasoning
+        reasoning_keywords = ['why', 'explain', 'reason', 'logic', 'conclusion', 'infer', 'deduce']
+        if any(keyword in question_lower for keyword in reasoning_keywords):
+            return "reasoning"
+
+        # Factual (default)
+        return "factual"
+
+    def process_question(self, question: str) -> str:
+        """Process a GAIA question using the smolagents framework"""
+        if not self.model:
+            return "Error: No language model available. Please set HF_TOKEN or run local Ollama."
+
+        try:
+            # Classify and route the question
+            question_type = self.classify_question(question)
+
+            # Create a focused prompt based on question type
+            if question_type == "mathematical":
+                prompt = f"Solve this mathematical problem step by step: {question}"
+            elif question_type == "factual":
+                prompt = f"Find accurate information for this question: {question}"
+            elif question_type == "reasoning":
+                prompt = f"Reason step by step to answer this question: {question}"
+            elif question_type == "file_processing":
+                prompt = f"Process this file-related question: {question}"
+            else:
+                prompt = question
+
+            # Run the agent
+            result = self.agent.run(prompt)
+            return str(result)
+
+        except Exception as e:
+            return f"Agent processing error: {str(e)}"
+
+# Test the agent
+if __name__ == "__main__":
+    agent = SmolagentsGAIAgent()
+
+    test_questions = [
+        "What is the capital of France?",
+        "Calculate 15 + 27 * 3",
+        "Who wrote Romeo and Juliet?",
+        "What is the square root of 144?",
+        "Explain why the sky is blue"
+    ]
+
+    for question in test_questions:
+        print(f"\nQ: {question}")
+        answer = agent.process_question(question)
+        print(f"A: {answer[:200]}...")