Upload 4 files

app.py

@@ -0,0 +1,220 @@
+"""
+Main application file for the GAIA-Ready AI Agent web interface
+
+This file serves as the entry point for the Hugging Face Spaces deployment.
+It creates and launches a Gradio interface for the agent.
+"""
+
+import os
+import sys
+import gradio as gr
+from typing import Dict, Any
+
+# Ensure all necessary modules are installed
+try:
+    import smolagents
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "smolagents"])
+
+try:
+    import sentence_transformers
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "sentence-transformers"])
+
+# Import the enhanced agent
+try:
+    from enhanced_agent import EnhancedGAIAAgent
+except ImportError:
+    print("Error: Could not import EnhancedGAIAAgent.")
+    print("Make sure enhanced_agent.py is in the same directory.")
+    sys.exit(1)
+
+# Import optimized prompts if available
+try:
+    from optimized_prompts import get_enhanced_system_prompt, get_enhanced_reasoning_template
+    USING_OPTIMIZED_PROMPTS = True
+except ImportError:
+    print("Warning: Could not import optimized prompts.")
+    print("The agent will use default prompts.")
+    USING_OPTIMIZED_PROMPTS = False
+
+# Check if running in Hugging Face Spaces
+IS_HF_SPACES = os.environ.get("SPACE_ID") is not None
+
+class AgentApp:
+    """
+    Gradio application for the GAIA-Ready AI Agent
+    """
+    def __init__(self, use_local_model: bool = False, use_semantic_memory: bool = True):
+        """
+        Initialize the agent application
+        
+        Args:
+            use_local_model: Whether to use a local model via Ollama
+            use_semantic_memory: Whether to use semantic search for memory retrieval
+        """
+        self.agent = None
+        self.use_local_model = use_local_model
+        self.use_semantic_memory = use_semantic_memory
+        self.history = []
+        self.api_key = os.environ.get("HF_API_KEY", "")
+        
+        # Initialize the interface
+        self.interface = self._create_interface()
+    
+    def _initialize_agent(self, api_key: str = "") -> str:
+        """
+        Initialize the agent with the provided API key
+        
+        Args:
+            api_key: Hugging Face API key
+        
+        Returns:
+            Initialization status message
+        """
+        if api_key:
+            self.api_key = api_key
+        
+        try:
+            self.agent = EnhancedGAIAAgent(
+                api_key=self.api_key,
+                use_local_model=self.use_local_model,
+                use_semantic_memory=self.use_semantic_memory
+            )
+            return "Agent initialized successfully!"
+        except Exception as e:
+            return f"Error initializing agent: {str(e)}"
+    
+    def _process_query(self, query: str, api_key: str = "", max_iterations: int = 3) -> str:
+        """
+        Process a user query with the agent
+        
+        Args:
+            query: The user's query
+            api_key: Hugging Face API key (optional)
+            max_iterations: Maximum number of iterations
+            
+        Returns:
+            Agent's response
+        """
+        # Initialize agent if not already initialized or if API key changed
+        if self.agent is None or (api_key and api_key != self.api_key):
+            init_message = self._initialize_agent(api_key)
+            if "Error" in init_message:
+                return init_message
+        
+        try:
+            # Process the query
+            result = self.agent.solve(query, max_iterations=max_iterations, verbose=True)
+            
+            # Add to history
+            self.history.append({
+                "query": query,
+                "response": result.get("answer", "No answer provided."),
+                "success": result.get("success", False)
+            })
+            
+            # Return the answer
+            return result.get("answer", "I couldn't generate an answer for this query.")
+        except Exception as e:
+            error_message = f"Error processing query: {str(e)}"
+            print(error_message)
+            return error_message
+    
+    def _create_interface(self) -> gr.Blocks:
+        """
+        Create the Gradio interface
+        
+        Returns:
+            Gradio Blocks interface
+        """
+        with gr.Blocks(title="GAIA-Ready AI Agent") as interface:
+            gr.Markdown("# GAIA-Ready AI Agent")
+            gr.Markdown("""
+            This AI agent is designed to excel at the GAIA benchmark from the Hugging Face Agents Course.
+            It implements the Think-Act-Observe workflow and includes tools for web search, calculation,
+            image analysis, and code execution.
+            
+            Enter your query below and the agent will solve it step by step.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    api_key_input = gr.Textbox(
+                        label="Hugging Face API Key (optional)",
+                        placeholder="Enter your Hugging Face API key here...",
+                        type="password"
+                    )
+                
+                with gr.Column(scale=1):
+                    max_iterations_slider = gr.Slider(
+                        minimum=1,
+                        maximum=5,
+                        value=3,
+                        step=1,
+                        label="Max Iterations"
+                    )
+            
+            query_input = gr.Textbox(
+                label="Your Query",
+                placeholder="Enter your query here...",
+                lines=3
+            )
+            
+            submit_button = gr.Button("Submit")
+            
+            response_output = gr.Textbox(
+                label="Agent Response",
+                lines=15
+            )
+            
+            # Sample queries
+            gr.Markdown("### Sample Queries")
+            sample_queries = [
+                "What is the capital of France and what is its population? Also, calculate 15% of this population.",
+                "Write a Python function to calculate the factorial of a number, then use it to find the factorial of 5.",
+                "Compare and contrast renewable and non-renewable energy sources.",
+                "Analyze this image: https://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/800px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg"
+            ]
+            
+            for query in sample_queries:
+                sample_button = gr.Button(f"Try: {query[:50]}..." if len(query) > 50 else f"Try: {query}")
+                sample_button.click(
+                    fn=lambda q=query: q,
+                    outputs=query_input
+                )
+            
+            # Set up event handlers
+            submit_button.click(
+                fn=self._process_query,
+                inputs=[query_input, api_key_input, max_iterations_slider],
+                outputs=response_output
+            )
+            
+            # Add examples
+            gr.Examples(
+                examples=sample_queries,
+                inputs=query_input
+            )
+        
+        return interface
+    
+    def launch(self, share: bool = False) -> None:
+        """
+        Launch the Gradio interface
+        
+        Args:
+            share: Whether to create a public link
+        """
+        self.interface.launch(share=share)
+
+
+# Create and launch the agent app
+app = AgentApp(use_local_model=False, use_semantic_memory=True)
+interface = app.interface
+
+# For Hugging Face Spaces
+if __name__ == "__main__":
+    interface.launch()

deployment.py

@@ -0,0 +1,347 @@
+"""
+Deployment configuration for Hugging Face Spaces
+
+This file contains the necessary configuration and setup for deploying
+the GAIA-Ready AI Agent to Hugging Face Spaces.
+"""
+
+import os
+import sys
+import json
+from typing import Dict, Any, List, Optional, Union
+
+# Import required modules
+try:
+    import gradio as gr
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "gradio"])
+    import gradio as gr
+
+# Import the enhanced agent
+try:
+    from enhanced_agent import EnhancedGAIAAgent
+except ImportError:
+    print("Error: Could not import EnhancedGAIAAgent.")
+    print("Make sure enhanced_agent.py is in the same directory.")
+    sys.exit(1)
+
+# Import optimized prompts
+try:
+    from optimized_prompts import get_enhanced_system_prompt, get_enhanced_reasoning_template
+except ImportError:
+    print("Warning: Could not import optimized prompts.")
+    print("The agent will use default prompts.")
+
+# Check if running in Hugging Face Spaces
+IS_HF_SPACES = os.environ.get("SPACE_ID") is not None
+
+# Configuration for Hugging Face Spaces
+HF_SPACES_CONFIG = {
+    "title": "GAIA-Ready AI Agent",
+    "description": "An advanced AI agent designed to excel at the GAIA benchmark from the Hugging Face Agents Course.",
+    "tags": ["agents", "gaia", "huggingface-course", "smolagents", "llm"],
+    "sdk": "gradio",
+    "sdk_version": "3.50.2",
+    "python_version": "3.11",
+    "app_file": "app.py",
+    "license": "mit"
+}
+
+class AgentApp:
+    """
+    Gradio application for the GAIA-Ready AI Agent
+    """
+    def __init__(self, use_local_model: bool = False, use_semantic_memory: bool = True):
+        """
+        Initialize the agent application
+        
+        Args:
+            use_local_model: Whether to use a local model via Ollama
+            use_semantic_memory: Whether to use semantic search for memory retrieval
+        """
+        self.agent = None
+        self.use_local_model = use_local_model
+        self.use_semantic_memory = use_semantic_memory
+        self.history = []
+        self.api_key = os.environ.get("HF_API_KEY", "")
+        
+        # Initialize the interface
+        self.interface = self._create_interface()
+    
+    def _initialize_agent(self, api_key: str = "") -> None:
+        """
+        Initialize the agent with the provided API key
+        
+        Args:
+            api_key: Hugging Face API key
+        """
+        if api_key:
+            self.api_key = api_key
+        
+        try:
+            self.agent = EnhancedGAIAAgent(
+                api_key=self.api_key,
+                use_local_model=self.use_local_model,
+                use_semantic_memory=self.use_semantic_memory
+            )
+            return "Agent initialized successfully!"
+        except Exception as e:
+            return f"Error initializing agent: {str(e)}"
+    
+    def _process_query(self, query: str, api_key: str = "", max_iterations: int = 3) -> str:
+        """
+        Process a user query with the agent
+        
+        Args:
+            query: The user's query
+            api_key: Hugging Face API key (optional)
+            max_iterations: Maximum number of iterations
+            
+        Returns:
+            Agent's response
+        """
+        # Initialize agent if not already initialized or if API key changed
+        if self.agent is None or (api_key and api_key != self.api_key):
+            init_message = self._initialize_agent(api_key)
+            if "Error" in init_message:
+                return init_message
+        
+        try:
+            # Process the query
+            result = self.agent.solve(query, max_iterations=max_iterations, verbose=True)
+            
+            # Add to history
+            self.history.append({
+                "query": query,
+                "response": result.get("answer", "No answer provided."),
+                "success": result.get("success", False)
+            })
+            
+            # Return the answer
+            return result.get("answer", "I couldn't generate an answer for this query.")
+        except Exception as e:
+            error_message = f"Error processing query: {str(e)}"
+            print(error_message)
+            return error_message
+    
+    def _create_interface(self) -> gr.Blocks:
+        """
+        Create the Gradio interface
+        
+        Returns:
+            Gradio Blocks interface
+        """
+        with gr.Blocks(title="GAIA-Ready AI Agent") as interface:
+            gr.Markdown("# GAIA-Ready AI Agent")
+            gr.Markdown("""
+            This AI agent is designed to excel at the GAIA benchmark from the Hugging Face Agents Course.
+            It implements the Think-Act-Observe workflow and includes tools for web search, calculation,
+            image analysis, and code execution.
+            
+            Enter your query below and the agent will solve it step by step.
+            """)
+            
+            with gr.Row():
+                with gr.Column(scale=3):
+                    api_key_input = gr.Textbox(
+                        label="Hugging Face API Key (optional)",
+                        placeholder="Enter your Hugging Face API key here...",
+                        type="password"
+                    )
+                
+                with gr.Column(scale=1):
+                    max_iterations_slider = gr.Slider(
+                        minimum=1,
+                        maximum=5,
+                        value=3,
+                        step=1,
+                        label="Max Iterations"
+                    )
+            
+            query_input = gr.Textbox(
+                label="Your Query",
+                placeholder="Enter your query here...",
+                lines=3
+            )
+            
+            submit_button = gr.Button("Submit")
+            
+            response_output = gr.Textbox(
+                label="Agent Response",
+                lines=15
+            )
+            
+            # Sample queries
+            gr.Markdown("### Sample Queries")
+            sample_queries = [
+                "What is the capital of France and what is its population? Also, calculate 15% of this population.",
+                "Write a Python function to calculate the factorial of a number, then use it to find the factorial of 5.",
+                "Compare and contrast renewable and non-renewable energy sources.",
+                "Analyze this image: https://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/800px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg"
+            ]
+            
+            for query in sample_queries:
+                sample_button = gr.Button(f"Try: {query[:50]}..." if len(query) > 50 else f"Try: {query}")
+                sample_button.click(
+                    fn=lambda q=query: q,
+                    outputs=query_input
+                )
+            
+            # Set up event handlers
+            submit_button.click(
+                fn=self._process_query,
+                inputs=[query_input, api_key_input, max_iterations_slider],
+                outputs=response_output
+            )
+            
+            # Add examples
+            gr.Examples(
+                examples=sample_queries,
+                inputs=query_input
+            )
+        
+        return interface
+    
+    def launch(self, share: bool = False) -> None:
+        """
+        Launch the Gradio interface
+        
+        Args:
+            share: Whether to create a public link
+        """
+        self.interface.launch(share=share)
+
+
+def create_requirements_file() -> None:
+    """
+    Create requirements.txt file for Hugging Face Spaces
+    """
+    requirements = [
+        "smolagents>=0.1.0",
+        "sentence-transformers>=2.2.2",
+        "gradio>=3.50.2",
+        "requests>=2.31.0",
+        "beautifulsoup4>=4.12.2",
+        "numpy>=1.24.3",
+        "matplotlib>=3.7.1",
+        "pillow>=9.5.0"
+    ]
+    
+    with open("requirements.txt", "w") as f:
+        f.write("\n".join(requirements))
+    
+    print("Created requirements.txt file")
+
+
+def create_readme_file() -> None:
+    """
+    Create README.md file for Hugging Face Spaces
+    """
+    readme_content = """
+# GAIA-Ready AI Agent
+
+This AI agent is designed to excel at the GAIA benchmark from the Hugging Face Agents Course.
+
+## Features
+
+- Implements the Think-Act-Observe workflow
+- Includes tools for web search, calculation, image analysis, and code execution
+- Uses advanced memory and reasoning systems
+- Optimized for the GAIA benchmark
+
+## Usage
+
+1. Enter your Hugging Face API key (optional)
+2. Set the maximum number of iterations
+3. Enter your query
+4. Click Submit
+
+## Sample Queries
+
+- "What is the capital of France and what is its population? Also, calculate 15% of this population."
+- "Write a Python function to calculate the factorial of a number, then use it to find the factorial of 5."
+- "Compare and contrast renewable and non-renewable energy sources."
+- "Analyze this image: [Mona Lisa](https://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/800px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg)"
+
+## How It Works
+
+The agent uses a three-step workflow:
+
+1. **Think**: Analyze the task and plan an approach
+2. **Act**: Use appropriate tools to gather information or perform actions
+3. **Observe**: Analyze the results and adjust the approach if needed
+
+## Development
+
+This agent was developed as part of the Hugging Face Agents Course. It uses the smolagents framework and is optimized for the GAIA benchmark.
+"""
+    
+    with open("README.md", "w") as f:
+        f.write(readme_content.strip())
+    
+    print("Created README.md file")
+
+
+def create_app_file() -> None:
+    """
+    Create app.py file for Hugging Face Spaces
+    """
+    app_content = """
+import os
+import sys
+from deployment import AgentApp
+
+# Create and launch the agent app
+app = AgentApp(use_local_model=False, use_semantic_memory=True)
+interface = app.interface
+
+# For Hugging Face Spaces
+if __name__ == "__main__":
+    interface.launch()
+"""
+    
+    with open("app.py", "w") as f:
+        f.write(app_content.strip())
+    
+    print("Created app.py file")
+
+
+def prepare_for_deployment() -> None:
+    """
+    Prepare all necessary files for deployment to Hugging Face Spaces
+    """
+    print("Preparing for deployment to Hugging Face Spaces...")
+    
+    # Create requirements.txt
+    create_requirements_file()
+    
+    # Create README.md
+    create_readme_file()
+    
+    # Create app.py
+    create_app_file()
+    
+    # Create .gitignore
+    with open(".gitignore", "w") as f:
+        f.write("__pycache__/\n*.py[cod]\n*$py.class\n.env\n*.json\nagent_memory.json\n")
+    
+    print("All deployment files created successfully!")
+    print("To deploy to Hugging Face Spaces:")
+    print("1. Create a new Space on Hugging Face")
+    print("2. Select Gradio as the SDK")
+    print("3. Upload all the files in this directory")
+    print("4. Set the HF_API_KEY environment variable in the Space settings")
+
+
+# Example usage
+if __name__ == "__main__":
+    # Prepare for deployment
+    prepare_for_deployment()
+    
+    # Test the app locally
+    print("\nTesting the app locally...")
+    app = AgentApp(use_local_model=False, use_semantic_memory=True)
+    
+    # Launch with share=True to create a public link
+    app.launch(share=True)

gaia_sample_tasks.py

@@ -0,0 +1,108 @@
+"""
+GAIA Sample Tasks for Testing the AI Agent
+
+This file contains sample tasks from the GAIA benchmark categories
+to test the agent's capabilities across different skills.
+"""
+
+# Sample GAIA tasks for testing the agent
+GAIA_SAMPLE_TASKS = [
+    # Reasoning tasks
+    {
+        "category": "reasoning",
+        "difficulty": "easy",
+        "task": "If a train travels at 60 miles per hour, how far will it travel in 2.5 hours?"
+    },
+    {
+        "category": "reasoning",
+        "difficulty": "medium",
+        "task": "A store is having a 30% off sale. If an item originally costs $85, what is the sale price? Additionally, if there's a 8% sales tax, what is the final price?"
+    },
+    {
+        "category": "reasoning",
+        "difficulty": "hard",
+        "task": "In a class of 30 students, 40% are boys. If 3 more girls join the class, what percentage of the class will be boys?"
+    },
+    
+    # Web search and information retrieval tasks
+    {
+        "category": "web_search",
+        "difficulty": "easy",
+        "task": "What is the capital of Japan and what is its population?"
+    },
+    {
+        "category": "web_search",
+        "difficulty": "medium",
+        "task": "Who won the Nobel Prize in Physics in 2023? What was their contribution?"
+    },
+    {
+        "category": "web_search",
+        "difficulty": "hard",
+        "task": "Compare and contrast the climate policies of the United States and the European Union. What are the key differences in their approaches to reducing carbon emissions?"
+    },
+    
+    # Multimodal understanding tasks (would require image input in a real scenario)
+    {
+        "category": "multimodal",
+        "difficulty": "easy",
+        "task": "Analyze this image URL and describe what you see: https://upload.wikimedia.org/wikipedia/commons/thumb/e/ec/Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg/800px-Mona_Lisa%2C_by_Leonardo_da_Vinci%2C_from_C2RMF_retouched.jpg"
+    },
+    {
+        "category": "multimodal",
+        "difficulty": "medium",
+        "task": "Look at this chart image and explain the trend: https://upload.wikimedia.org/wikipedia/commons/thumb/5/51/Global-surface-temperature.svg/1200px-Global-surface-temperature.svg.png"
+    },
+    
+    # Tool usage tasks
+    {
+        "category": "tool_usage",
+        "difficulty": "easy",
+        "task": "Write a Python function to calculate the factorial of a number, then use it to find the factorial of 5."
+    },
+    {
+        "category": "tool_usage",
+        "difficulty": "medium",
+        "task": "Create a Python script that fetches the current weather for New York City using a weather API and displays the temperature, humidity, and weather conditions."
+    },
+    {
+        "category": "tool_usage",
+        "difficulty": "hard",
+        "task": "Write a Python script that analyzes a text file containing a list of numbers (one per line), calculates the mean, median, mode, and standard deviation, and creates a histogram visualization of the data."
+    },
+    
+    # Combined skills tasks
+    {
+        "category": "combined",
+        "difficulty": "medium",
+        "task": "Research the top 3 electric vehicle manufacturers by market share. Create a Python script to visualize their market shares in a pie chart."
+    },
+    {
+        "category": "combined",
+        "difficulty": "hard",
+        "task": "Find information about global coffee production by country for the last year. Write a Python script to create a bar chart showing the top 5 coffee-producing countries and their production volumes."
+    }
+]
+
+# Function to get tasks by category
+def get_tasks_by_category(category):
+    return [task for task in GAIA_SAMPLE_TASKS if task["category"] == category]
+
+# Function to get tasks by difficulty
+def get_tasks_by_difficulty(difficulty):
+    return [task for task in GAIA_SAMPLE_TASKS if task["difficulty"] == difficulty]
+
+# Function to get all task queries as a list
+def get_all_task_queries():
+    return [task["task"] for task in GAIA_SAMPLE_TASKS]
+
+# Function to get a subset of tasks for quick testing
+def get_quick_test_tasks():
+    # One task from each category and difficulty level
+    quick_test_tasks = [
+        GAIA_SAMPLE_TASKS[0],  # reasoning, easy
+        GAIA_SAMPLE_TASKS[3],  # web_search, easy
+        GAIA_SAMPLE_TASKS[6],  # multimodal, easy
+        GAIA_SAMPLE_TASKS[9],  # tool_usage, medium
+        GAIA_SAMPLE_TASKS[11]  # combined, medium
+    ]
+    return [task["task"] for task in quick_test_tasks]

requirements .txt

@@ -0,0 +1,8 @@
+smolagents>=0.1.0
+sentence-transformers>=2.2.2
+gradio>=3.50.2
+requests>=2.31.0
+beautifulsoup4>=4.12.2
+numpy>=1.24.3
+matplotlib>=3.7.1
+pillow>=9.5.0