Update app.py

app.py

@@ -1,415 +1,185 @@
 """
-Simplified application file for the GAIA-Ready AI Agent web interface
+Minimal Gradio interface for a simple AI assistant without smolagents
 
-This is a standalone version that doesn't depend on memory_system or reasoning_system modules.
-It creates and launches a Gradio interface for a basic agent using smolagents directly.
+This is a standalone version that uses only Hugging Face Inference API directly.
+It creates a simple Gradio interface for text generation.
 """
 
 import os
 import sys
+import json
+import requests
 import gradio as gr
-from typing import Dict, Any, List, Optional
-
-# Ensure all necessary modules are installed
-try:
-    from smolagents import Agent, InferenceClientModel, Tool
-except ImportError:
-    import subprocess
-    subprocess.check_call(["pip", "install", "smolagents"])
-    from smolagents import Agent, InferenceClientModel, Tool
-
-# Import optimized prompts if available
-try:
-    from optimized_prompts import get_enhanced_system_prompt
-    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
 
-# Define tool functions
-def web_search_function(query: str) -> str:
-    """
-    Search the web for information
-    
-    Args:
-        query: Search query
-        
-    Returns:
-        Search results
-    """
-    return f"Searching for: {query}\n\nThis is a placeholder for web search results. In a real implementation, this would connect to a search API."
-
-def web_page_content_function(url: str) -> str:
-    """
-    Fetch and extract content from a web page
-    
-    Args:
-        url: URL of the web page
-        
-    Returns:
-        Extracted content
-    """
-    return f"Extracting content from: {url}\n\nThis is a placeholder for web page content. In a real implementation, this would fetch and extract content from the URL."
-
-def calculator_function(expression: str) -> str:
-    """
-    Perform mathematical calculations
-    
-    Args:
-        expression: Mathematical expression to evaluate
-        
-    Returns:
-        Result of the calculation
-    """
-    try:
-        result = eval(expression)
-        return f"Expression: {expression}\nResult: {result}"
-    except Exception as e:
-        return f"Error evaluating expression: {str(e)}"
-
-def image_analyzer_function(image_url: str) -> str:
-    """
-    Analyze image content
-    
-    Args:
-        image_url: URL of the image to analyze
-        
-    Returns:
-        Analysis of the image
-    """
-    return f"Analyzing image: {image_url}\n\nThis is a placeholder for image analysis. In a real implementation, this would analyze the image content."
-
-def python_executor_function(code: str) -> str:
-    """
-    Execute Python code
-    
-    Args:
-        code: Python code to execute
-        
-    Returns:
-        Result of the code execution
-    """
-    try:
-        # Create a dictionary to capture output
-        output_capture = {}
-        
-        # Redirect stdout to capture print statements
-        import io
-        from contextlib import redirect_stdout
-        
-        f = io.StringIO()
-        with redirect_stdout(f):
-            # Execute the code in a safe environment
-            exec_globals = {
-                "__builtins__": __builtins__,
-                "print": print,
-                "input": lambda x: x  # Mock input function
-            }
-            exec(code, exec_globals)
-        
-        # Get the captured output
-        output = f.getvalue()
-        
-        return f"Code execution result:\n\n{output}"
-    except Exception as e:
-        return f"Error executing code: {str(e)}"
-
-def text_processor_function(operation: str, text: str) -> str:
-    """
-    Process and analyze text
-    
-    Args:
-        operation: Operation to perform (summarize, analyze_sentiment, extract_keywords)
-        text: Text to process
-        
-    Returns:
-        Processed text
-    """
-    if operation == "summarize":
-        return f"Summary of text: This is a placeholder for text summarization."
-    elif operation == "analyze_sentiment":
-        return f"Sentiment analysis: This is a placeholder for sentiment analysis."
-    elif operation == "extract_keywords":
-        return f"Keywords: This is a placeholder for keyword extraction."
-    else:
-        return f"Unknown operation: {operation}"
-
-def file_manager_function(operation: str, filename: str, content: str = "") -> str:
-    """
-    Save and load data from files
-    
-    Args:
-        operation: Operation to perform (save, load)
-        filename: Name of the file
-        content: Content to save (for save operation)
-        
-    Returns:
-        Operation result
-    """
-    if operation == "save":
-        return f"Saved content to {filename}: This is a placeholder for file saving."
-    elif operation == "load":
-        return f"Loaded content from {filename}: This is a placeholder for file loading."
-    else:
-        return f"Unknown operation: {operation}"
-
-class SimpleGAIAAgent:
+class MinimalAIAssistant:
     """
-    Simplified GAIA-Ready AI Agent without memory and reasoning systems
+    Minimal AI Assistant using Hugging Face Inference API directly
     """
-    def __init__(self, api_key: str = None):
+    def __init__(self, api_key=None, model_id="mistralai/Mixtral-8x7B-Instruct-v0.1"):
         """
-        Initialize the simplified GAIA agent
+        Initialize the minimal AI assistant
         
         Args:
-            api_key: API key for Hugging Face Inference API
+            api_key: Hugging Face API key
+            model_id: Model ID to use
         """
-        # Initialize the LLM model
         self.api_key = api_key or os.environ.get("HF_API_KEY", "")
-        self.model = InferenceClientModel(
-            model_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
-            api_key=self.api_key
-        )
-        
-        # Define tools
-        self.tools = [
-            Tool(
-                name="web_search",
-                description="Search the web for information",
-                function=web_search_function
-            ),
-            Tool(
-                name="web_page_content",
-                description="Fetch and extract content from a web page",
-                function=web_page_content_function
-            ),
-            Tool(
-                name="calculator",
-                description="Perform mathematical calculations",
-                function=calculator_function
-            ),
-            Tool(
-                name="image_analyzer",
-                description="Analyze image content",
-                function=image_analyzer_function
-            ),
-            Tool(
-                name="python_executor",
-                description="Execute Python code",
-                function=python_executor_function
-            ),
-            Tool(
-                name="text_processor",
-                description="Process and analyze text",
-                function=text_processor_function
-            ),
-            Tool(
-                name="file_manager",
-                description="Save and load data from files",
-                function=file_manager_function
-            )
-        ]
+        self.model_id = model_id
+        self.api_url = f"https://api-inference.huggingface.co/models/{model_id}"
+        self.headers = {"Authorization": f"Bearer {self.api_key}"}
         
         # System prompt
-        if USING_OPTIMIZED_PROMPTS:
-            self.system_prompt = get_enhanced_system_prompt("general query")
-        else:
-            self.system_prompt = """
-You are an advanced AI assistant designed to solve complex tasks from the GAIA benchmark.
-You have access to various tools that can help you solve these tasks.
-
-Always follow the Think-Act-Observe workflow:
-1. Think: Carefully analyze the task and plan your approach
-2. Act: Use appropriate tools to gather information or perform actions
-3. Observe: Analyze the results of your actions and adjust your approach
-
-Available tools:
-- web_search: Search the web for information
-- web_page_content: Extract content from specific web pages
-- calculator: Perform mathematical calculations
-- image_analyzer: Analyze image content
-- python_executor: Run Python code for complex operations
-- text_processor: Process and analyze text (summarize, analyze_sentiment, extract_keywords)
-- file_manager: Save and load data from files (save, load)
-
-For complex tasks:
-- Break them down into smaller, manageable steps
-- Keep track of your progress and intermediate results
-- Verify each step before moving to the next
-- Always double-check your final answer
-
-Always verify your answers before submitting them.
+        self.system_prompt = """
+You are an advanced AI assistant designed to help with various tasks.
+You can answer questions, provide information, and assist with problem-solving.
+Always be helpful, accurate, and concise in your responses.
 """
-        
-        # Initialize the agent
-        self.agent = Agent(
-            model=self.model,
-            tools=self.tools,
-            system_prompt=self.system_prompt
-        )
-    
-    def solve(self, query: str) -> str:
+
+    def query(self, prompt):
         """
-        Solve a task using the agent
+        Query the model with a prompt
         
         Args:
-            query: The user's query or task
+            prompt: User prompt
             
         Returns:
-            Agent's response
+            Model response
         """
         try:
-            # Process the query
-            response = self.agent.chat(query)
-            return response
+            # Format the prompt with system message
+            formatted_prompt = f"{self.system_prompt}\n\nUser: {prompt}\n\nAssistant:"
+            
+            # Prepare the payload
+            payload = {
+                "inputs": formatted_prompt,
+                "parameters": {
+                    "max_new_tokens": 1024,
+                    "temperature": 0.7,
+                    "top_p": 0.95,
+                    "do_sample": True
+                }
+            }
+            
+            # Make the API request
+            response = requests.post(self.api_url, headers=self.headers, json=payload)
+            
+            # Check for errors
+            if response.status_code != 200:
+                return f"Error: API returned status code {response.status_code}. {response.text}"
+            
+            # Parse the response
+            result = response.json()
+            
+            # Extract the generated text
+            if isinstance(result, list) and len(result) > 0:
+                generated_text = result[0].get("generated_text", "")
+                # Remove the prompt from the response
+                if generated_text.startswith(formatted_prompt):
+                    generated_text = generated_text[len(formatted_prompt):].strip()
+                return generated_text
+            else:
+                return "Error: Unexpected response format from API"
+        
         except Exception as e:
-            error_msg = f"Error solving task: {str(e)}"
-            print(error_msg)
-            return f"I'm sorry, I encountered an error while solving this task: {str(e)}"
+            return f"Error querying model: {str(e)}"
 
 
-class AgentApp:
+def create_gradio_interface():
     """
-    Gradio application for the GAIA-Ready AI Agent
+    Create a Gradio interface for the minimal AI assistant
+    
+    Returns:
+        Gradio interface
     """
-    def __init__(self):
-        """
-        Initialize the agent application
-        """
-        self.agent = None
-        self.api_key = os.environ.get("HF_API_KEY", "")
-        
-        # Initialize the interface
-        self.interface = self._create_interface()
+    # Initialize the assistant
+    assistant = MinimalAIAssistant()
     
-    def _initialize_agent(self, api_key: str = "") -> str:
+    def process_query(query, api_key=""):
         """
-        Initialize the agent with the provided API key
+        Process a user query
         
         Args:
-            api_key: Hugging Face API key
-        
+            query: User query
+            api_key: Hugging Face API key (optional)
+            
         Returns:
-            Initialization status message
+            Assistant's response
         """
+        # Update API key if provided
         if api_key:
-            self.api_key = api_key
+            assistant.api_key = api_key
+            assistant.headers = {"Authorization": f"Bearer {api_key}"}
         
-        try:
-            self.agent = SimpleGAIAAgent(api_key=self.api_key)
-            return "Agent initialized successfully!"
-        except Exception as e:
-            return f"Error initializing agent: {str(e)}"
+        # Check if API key is set
+        if not assistant.api_key:
+            return "Error: No API key provided. Please enter your Hugging Face API key."
+        
+        # Process the query
+        return assistant.query(query)
     
-    def _process_query(self, query: str, api_key: str = "") -> str:
-        """
-        Process a user query with the agent
+    # Create the interface
+    with gr.Blocks(title="Minimal AI Assistant") as interface:
+        gr.Markdown("# Minimal AI Assistant")
+        gr.Markdown("""
+        This is a minimal AI assistant using the Hugging Face Inference API.
+        Enter your query below and the assistant will respond.
+        """)
+        
+        api_key_input = gr.Textbox(
+            label="Hugging Face API Key",
+            placeholder="Enter your Hugging Face API key here...",
+            type="password"
+        )
         
-        Args:
-            query: The user's query
-            api_key: Hugging Face API key (optional)
-            
-        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
+        query_input = gr.Textbox(
+            label="Your Query",
+            placeholder="Enter your query here...",
+            lines=3
+        )
         
-        try:
-            # Process the query
-            return self.agent.solve(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
+        submit_button = gr.Button("Submit")
         
-        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.
-            """)
-            
-            api_key_input = gr.Textbox(
-                label="Hugging Face API Key (optional)",
-                placeholder="Enter your Hugging Face API key here...",
-                type="password"
-            )
-            
-            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],
-                outputs=response_output
-            )
-            
-            # Add examples
-            gr.Examples(
-                examples=sample_queries,
-                inputs=query_input
+        response_output = gr.Textbox(
+            label="Assistant Response",
+            lines=15
+        )
+        
+        # Sample queries
+        gr.Markdown("### Sample Queries")
+        sample_queries = [
+            "What is the capital of France?",
+            "Explain the concept of machine learning in simple terms.",
+            "Write a short poem about artificial intelligence."
+        ]
+        
+        for query in sample_queries:
+            sample_button = gr.Button(f"Try: {query}")
+            sample_button.click(
+                fn=lambda q=query: q,
+                outputs=query_input
             )
         
-        return interface
-    
-    def launch(self, share: bool = False) -> None:
-        """
-        Launch the Gradio interface
+        # Set up event handlers
+        submit_button.click(
+            fn=process_query,
+            inputs=[query_input, api_key_input],
+            outputs=response_output
+        )
         
-        Args:
-            share: Whether to create a public link
-        """
-        self.interface.launch(share=share)
+        # Add examples
+        gr.Examples(
+            examples=sample_queries,
+            inputs=query_input
+        )
+    
+    return interface
 
 
-# Create and launch the agent app
-app = AgentApp()
-interface = app.interface
+# Create and launch the interface
+interface = create_gradio_interface()
 
 # For Hugging Face Spaces
 if __name__ == "__main__":