Upload 4 files

agent.py

@@ -0,0 +1,757 @@
+"""
+GAIA-Ready AI Agent using smolagents framework
+
+This agent is designed to meet the requirements of the Hugging Face Agents Course
+and perform well on the GAIA benchmark. It implements the Think-Act-Observe workflow
+and includes tools for web search, calculation, image analysis, and code execution.
+"""
+
+import os
+import json
+import base64
+import requests
+from typing import List, Dict, Any, Optional, Union, Callable
+import re
+import time
+from datetime import datetime
+import traceback
+
+# Install required packages if not already installed
+try:
+    from smolagents import Agent, InferenceClientModel, Tool
+    from smolagents.memory import Memory
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "smolagents"])
+    from smolagents import Agent, InferenceClientModel, Tool
+    from smolagents.memory import Memory
+
+try:
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from PIL import Image
+    import io
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "numpy", "matplotlib", "pillow"])
+    import numpy as np
+    import matplotlib.pyplot as plt
+    from PIL import Image
+    import io
+
+try:
+    import requests
+    from bs4 import BeautifulSoup
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "requests", "beautifulsoup4"])
+    import requests
+    from bs4 import BeautifulSoup
+
+
+class MemoryManager:
+    """
+    Custom memory manager for the agent that maintains short-term, long-term,
+    and working memory.
+    """
+    def __init__(self):
+        self.short_term_memory = []  # Current conversation context
+        self.long_term_memory = []   # Key facts and results
+        self.working_memory = {}     # Temporary storage for complex tasks
+        self.max_short_term_items = 10
+        self.max_long_term_items = 50
+    
+    def add_to_short_term(self, item: Dict[str, Any]) -> None:
+        """Add an item to short-term memory, maintaining size limit"""
+        self.short_term_memory.append(item)
+        if len(self.short_term_memory) > self.max_short_term_items:
+            self.short_term_memory.pop(0)
+    
+    def add_to_long_term(self, item: Dict[str, Any]) -> None:
+        """Add an important item to long-term memory, maintaining size limit"""
+        self.long_term_memory.append(item)
+        if len(self.long_term_memory) > self.max_long_term_items:
+            self.long_term_memory.pop(0)
+    
+    def store_in_working_memory(self, key: str, value: Any) -> None:
+        """Store a value in working memory under the specified key"""
+        self.working_memory[key] = value
+    
+    def get_from_working_memory(self, key: str) -> Optional[Any]:
+        """Retrieve a value from working memory by key"""
+        return self.working_memory.get(key)
+    
+    def clear_working_memory(self) -> None:
+        """Clear the working memory"""
+        self.working_memory = {}
+    
+    def get_relevant_memories(self, query: str) -> List[Dict[str, Any]]:
+        """
+        Retrieve memories relevant to the current query
+        Simple implementation using keyword matching
+        """
+        relevant_memories = []
+        query_keywords = set(query.lower().split())
+        
+        # Check long-term memory first
+        for memory in self.long_term_memory:
+            memory_text = memory.get("content", "").lower()
+            if any(keyword in memory_text for keyword in query_keywords):
+                relevant_memories.append(memory)
+        
+        # Then check short-term memory
+        for memory in self.short_term_memory:
+            memory_text = memory.get("content", "").lower()
+            if any(keyword in memory_text for keyword in query_keywords):
+                relevant_memories.append(memory)
+        
+        return relevant_memories
+    
+    def get_memory_summary(self) -> str:
+        """Get a summary of the current memory state for the agent"""
+        short_term_summary = "\n".join([f"- {m.get('content', '')}" for m in self.short_term_memory[-5:]])
+        long_term_summary = "\n".join([f"- {m.get('content', '')}" for m in self.long_term_memory[-5:]])
+        working_memory_summary = "\n".join([f"- {k}: {v}" for k, v in self.working_memory.items()])
+        
+        return f"""
+MEMORY SUMMARY:
+--------------
+Recent Short-Term Memory:
+{short_term_summary}
+
+Important Long-Term Memory:
+{long_term_summary}
+
+Working Memory:
+{working_memory_summary}
+"""
+
+
+# Tool implementations
+
+def web_search_function(query: str) -> str:
+    """
+    Search the web for information using a search API
+    
+    Args:
+        query: The search query
+        
+    Returns:
+        Search results as a string
+    """
+    try:
+        # Using a public search API (replace with your preferred API)
+        url = f"https://ddg-api.herokuapp.com/search?query={query}"
+        response = requests.get(url)
+        
+        if response.status_code == 200:
+            results = response.json()
+            formatted_results = []
+            
+            for i, result in enumerate(results[:5]):  # Limit to top 5 results
+                title = result.get('title', 'No title')
+                snippet = result.get('snippet', 'No snippet')
+                link = result.get('link', 'No link')
+                formatted_results.append(f"{i+1}. {title}\n   {snippet}\n   URL: {link}\n")
+            
+            return "Search Results:\n" + "\n".join(formatted_results)
+        else:
+            return f"Error: Search request failed with status code {response.status_code}"
+    except Exception as e:
+        return f"Error performing web search: {str(e)}"
+
+
+def web_page_content_function(url: str) -> str:
+    """
+    Fetch and extract content from a web page
+    
+    Args:
+        url: The URL of the web page to fetch
+        
+    Returns:
+        Extracted content as a string
+    """
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        response = requests.get(url, headers=headers)
+        
+        if response.status_code == 200:
+            soup = BeautifulSoup(response.text, 'html.parser')
+            
+            # Remove script and style elements
+            for script in soup(["script", "style"]):
+                script.extract()
+            
+            # Extract text
+            text = soup.get_text()
+            
+            # Clean up text
+            lines = (line.strip() for line in text.splitlines())
+            chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
+            text = '\n'.join(chunk for chunk in chunks if chunk)
+            
+            # Limit length to avoid overwhelming the model
+            if len(text) > 4000:
+                text = text[:4000] + "...\n[Content truncated due to length]"
+            
+            return f"Content from {url}:\n\n{text}"
+        else:
+            return f"Error: Failed to fetch web page with status code {response.status_code}"
+    except Exception as e:
+        return f"Error fetching web page content: {str(e)}"
+
+
+def calculator_function(expression: str) -> str:
+    """
+    Evaluate a mathematical expression
+    
+    Args:
+        expression: The mathematical expression to evaluate
+        
+    Returns:
+        Result of the calculation as a string
+    """
+    try:
+        # Clean the expression to ensure it's safe to evaluate
+        # Remove any characters that aren't digits, operators, or parentheses
+        clean_expr = re.sub(r'[^0-9+\-*/().^ ]', '', expression)
+        
+        # Replace ^ with ** for exponentiation
+        clean_expr = clean_expr.replace('^', '**')
+        
+        # Evaluate the expression
+        result = eval(clean_expr)
+        
+        return f"Expression: {expression}\nResult: {result}"
+    except Exception as e:
+        return f"Error calculating result: {str(e)}"
+
+
+def python_executor_function(code: str) -> str:
+    """
+    Execute Python code and return the result
+    
+    Args:
+        code: The Python code to execute
+        
+    Returns:
+        Output of the code execution as a string
+    """
+    try:
+        # Create a string buffer to capture output
+        from io import StringIO
+        import sys
+        
+        old_stdout = sys.stdout
+        redirected_output = StringIO()
+        sys.stdout = redirected_output
+        
+        # Execute the code
+        exec_globals = {
+            "np": np,
+            "plt": plt,
+            "requests": requests,
+            "BeautifulSoup": BeautifulSoup,
+            "Image": Image,
+            "io": io,
+            "json": json,
+            "base64": base64,
+            "re": re,
+            "time": time,
+            "datetime": datetime
+        }
+        
+        exec(code, exec_globals)
+        
+        # Restore stdout and get the output
+        sys.stdout = old_stdout
+        output = redirected_output.getvalue()
+        
+        return f"Code executed successfully:\n\n{output}"
+    except Exception as e:
+        return f"Error executing Python code: {str(e)}\n{traceback.format_exc()}"
+
+
+def image_analyzer_function(image_url: str) -> str:
+    """
+    Analyze an image and provide a description
+    
+    Args:
+        image_url: URL of the image to analyze
+        
+    Returns:
+        Description of the image as a string
+    """
+    try:
+        # Fetch the image
+        response = requests.get(image_url)
+        
+        if response.status_code == 200:
+            # Convert to base64 for inclusion in the response
+            image_data = base64.b64encode(response.content).decode('utf-8')
+            
+            # In a real implementation, you would use a vision model here
+            # For now, we'll return a placeholder response
+            return f"""
+Image Analysis:
+- Successfully retrieved image from {image_url}
+- Image size: {len(response.content)} bytes
+
+[Note: In a production environment, this would use a vision model to analyze the image content]
+
+To properly analyze this image, please describe what you see in the image.
+"""
+        else:
+            return f"Error: Failed to fetch image with status code {response.status_code}"
+    except Exception as e:
+        return f"Error analyzing image: {str(e)}"
+
+
+def text_processor_function(text: str, operation: str) -> str:
+    """
+    Process and analyze text
+    
+    Args:
+        text: The text to process
+        operation: The operation to perform (summarize, analyze_sentiment, extract_keywords)
+        
+    Returns:
+        Processed text as a string
+    """
+    try:
+        if operation == "summarize":
+            # Simple extractive summarization
+            sentences = text.split('. ')
+            if len(sentences) <= 3:
+                return f"Summary: {text}"
+            
+            # Take first and last sentences, plus one from the middle
+            summary = f"{sentences[0]}. {sentences[len(sentences)//2]}. {sentences[-1]}"
+            return f"Summary: {summary}"
+            
+        elif operation == "analyze_sentiment":
+            # Very simple sentiment analysis
+            positive_words = ['good', 'great', 'excellent', 'positive', 'happy', 'love', 'like']
+            negative_words = ['bad', 'poor', 'negative', 'unhappy', 'hate', 'dislike']
+            
+            text_lower = text.lower()
+            positive_count = sum(1 for word in positive_words if word in text_lower)
+            negative_count = sum(1 for word in negative_words if word in text_lower)
+            
+            if positive_count > negative_count:
+                sentiment = "positive"
+            elif negative_count > positive_count:
+                sentiment = "negative"
+            else:
+                sentiment = "neutral"
+                
+            return f"Sentiment Analysis: {sentiment} (positive words: {positive_count}, negative words: {negative_count})"
+            
+        elif operation == "extract_keywords":
+            # Simple keyword extraction
+            import re
+            from collections import Counter
+            
+            # Remove punctuation and convert to lowercase
+            text_clean = re.sub(r'[^\w\s]', '', text.lower())
+            
+            # Remove common stop words
+            stop_words = ['the', 'a', 'an', 'and', 'in', 'on', 'at', 'to', 'for', 'of', 'with', 'by']
+            words = [word for word in text_clean.split() if word not in stop_words and len(word) > 2]
+            
+            # Count word frequencies
+            word_counts = Counter(words)
+            
+            # Get top 10 keywords
+            keywords = [word for word, count in word_counts.most_common(10)]
+            
+            return f"Keywords: {', '.join(keywords)}"
+        else:
+            return f"Error: Unknown operation '{operation}'. Supported operations: summarize, analyze_sentiment, extract_keywords"
+    except Exception as e:
+        return f"Error processing text: {str(e)}"
+
+
+def file_manager_function(operation: str, filename: str, content: str = None) -> str:
+    """
+    Save and load data from files
+    
+    Args:
+        operation: The operation to perform (save, load)
+        filename: The name of the file
+        content: The content to save (for save operation)
+        
+    Returns:
+        Result of the operation as a string
+    """
+    try:
+        if operation == "save":
+            if content is None:
+                return "Error: Content is required for save operation"
+            
+            with open(filename, 'w') as f:
+                f.write(content)
+            
+            return f"Successfully saved content to {filename}"
+            
+        elif operation == "load":
+            if not os.path.exists(filename):
+                return f"Error: File {filename} does not exist"
+            
+            with open(filename, 'r') as f:
+                content = f.read()
+            
+            return f"Content of {filename}:\n\n{content}"
+        else:
+            return f"Error: Unknown operation '{operation}'. Supported operations: save, load"
+    except Exception as e:
+        return f"Error managing file: {str(e)}"
+
+
+class GAIAAgent:
+    """
+    AI Agent designed to perform well on the GAIA benchmark
+    Implements the Think-Act-Observe workflow
+    """
+    def __init__(self, api_key=None, use_local_model=False):
+        self.memory_manager = MemoryManager()
+        
+        # Initialize the LLM model
+        if use_local_model:
+            # Use Ollama for local model
+            try:
+                from smolagents import LiteLLMModel
+                self.model = LiteLLMModel(
+                    model_id="ollama_chat/qwen2:7b",
+                    api_base="http://127.0.0.1:11434",
+                    num_ctx=8192,
+                )
+            except Exception as e:
+                print(f"Error initializing local model: {str(e)}")
+                print("Falling back to Hugging Face Inference API")
+                self.model = InferenceClientModel(
+                    model_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
+                    api_key=api_key or os.environ.get("HF_API_KEY", "")
+                )
+        else:
+            # Use Hugging Face Inference API
+            self.model = InferenceClientModel(
+                model_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
+                api_key=api_key or os.environ.get("HF_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
+            )
+        ]
+        
+        # System prompt
+        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 if needed
+
+For complex tasks, break them down into smaller steps.
+Always verify your answers before submitting them.
+
+When using tools:
+- web_search: Use to find information online
+- web_page_content: Use to extract content from specific web pages
+- calculator: Use for mathematical calculations
+- image_analyzer: Use to analyze image content
+- python_executor: Use to run Python code for complex operations
+- text_processor: Use to process and analyze text (summarize, analyze_sentiment, extract_keywords)
+- file_manager: Use to save and load data from files (save, load)
+
+Be thorough, methodical, and precise in your reasoning.
+"""
+        
+        # Initialize the agent
+        self.agent = Agent(
+            model=self.model,
+            tools=self.tools,
+            system_prompt=self.system_prompt
+        )
+    
+    def think(self, query):
+        """
+        Analyze the task and plan an approach
+        
+        Args:
+            query: The user's query or task
+            
+        Returns:
+            Dictionary containing analysis and plan
+        """
+        # Retrieve relevant memories
+        relevant_memories = self.memory_manager.get_relevant_memories(query)
+        
+        # Construct a thinking prompt
+        thinking_prompt = f"""
+TASK: {query}
+
+RELEVANT MEMORIES:
+{relevant_memories if relevant_memories else "No relevant memories found."}
+
+Please analyze this task and create a plan:
+1. What is this task asking for?
+2. What information do I need to solve it?
+3. What tools would be most helpful?
+4. What steps should I take to solve it?
+
+Provide your analysis and plan.
+"""
+        
+        # Use the agent to generate a plan
+        response = self.agent.chat(thinking_prompt)
+        
+        # Store the thinking in memory
+        self.memory_manager.add_to_short_term({
+            "type": "thinking",
+            "content": response,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Extract plan components (in a real implementation, this would be more structured)
+        return {
+            "analysis": response,
+            "plan": response  # For now, we're using the full response as the plan
+        }
+    
+    def act(self, plan, query):
+        """
+        Execute actions based on the plan
+        
+        Args:
+            plan: The plan generated by the think step
+            query: The original query
+            
+        Returns:
+            Results of the actions
+        """
+        # Use the agent to determine which tools to use based on the plan
+        tool_selection_prompt = f"""
+TASK: {query}
+
+MY PLAN:
+{plan['plan']}
+
+Based on this plan, which tool should I use first and with what parameters?
+Respond in the following format:
+TOOL: [tool name]
+PARAMETERS: [parameters for the tool]
+REASONING: [why this tool is appropriate]
+"""
+        
+        tool_selection = self.agent.chat(tool_selection_prompt)
+        
+        # Store the tool selection in memory
+        self.memory_manager.add_to_short_term({
+            "type": "tool_selection",
+            "content": tool_selection,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Execute the selected tool (in a real implementation, this would parse the tool selection more robustly)
+        # For now, we'll use the agent's built-in tool execution
+        action_prompt = f"""
+TASK: {query}
+
+MY PLAN:
+{plan['plan']}
+
+TOOL SELECTION:
+{tool_selection}
+
+Please execute the appropriate tool to help solve this task.
+"""
+        
+        action_result = self.agent.chat(action_prompt)
+        
+        # Store the action result in memory
+        self.memory_manager.add_to_short_term({
+            "type": "action_result",
+            "content": action_result,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        return action_result
+    
+    def observe(self, action_result, plan, query):
+        """
+        Analyze the results of actions and determine next steps
+        
+        Args:
+            action_result: Results from the act step
+            plan: The original plan
+            query: The original query
+            
+        Returns:
+            Observation and next steps
+        """
+        observation_prompt = f"""
+TASK: {query}
+
+MY PLAN:
+{plan['plan']}
+
+ACTION RESULT:
+{action_result}
+
+Please analyze these results:
+1. What did I learn from this action?
+2. Does this fully answer the original task?
+3. If not, what should I do next?
+4. If yes, what is the final answer?
+
+Provide your analysis and next steps or final answer.
+"""
+        
+        observation = self.agent.chat(observation_prompt)
+        
+        # Store the observation in memory
+        self.memory_manager.add_to_short_term({
+            "type": "observation",
+            "content": observation,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Check if we need to continue with more actions
+        if "next steps" in observation.lower() or "next tool" in observation.lower():
+            continue_execution = True
+        else:
+            # If it seems like we have a final answer, store it in long-term memory
+            self.memory_manager.add_to_long_term({
+                "type": "final_answer",
+                "query": query,
+                "content": observation,
+                "timestamp": datetime.now().isoformat()
+            })
+            continue_execution = False
+        
+        return {
+            "observation": observation,
+            "continue": continue_execution
+        }
+    
+    def solve(self, query, max_iterations=5):
+        """
+        Solve a task using the Think-Act-Observe workflow
+        
+        Args:
+            query: The user's query or task
+            max_iterations: Maximum number of iterations to prevent infinite loops
+            
+        Returns:
+            Final answer to the query
+        """
+        # Store the query in memory
+        self.memory_manager.add_to_short_term({
+            "type": "query",
+            "content": query,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Initialize the workflow
+        iteration = 0
+        final_answer = None
+        
+        while iteration < max_iterations:
+            print(f"Iteration {iteration + 1}/{max_iterations}")
+            
+            # Think
+            print("Thinking...")
+            plan = self.think(query)
+            
+            # Act
+            print("Acting...")
+            action_result = self.act(plan, query)
+            
+            # Observe
+            print("Observing...")
+            observation = self.observe(action_result, plan, query)
+            
+            # Check if we have a final answer
+            if not observation["continue"]:
+                final_answer = observation["observation"]
+                break
+            
+            # Update the query with the observation for the next iteration
+            query = f"""
+Original task: {query}
+
+Progress so far:
+{observation["observation"]}
+
+Please continue solving this task.
+"""
+            
+            iteration += 1
+        
+        # If we reached max iterations without a final answer
+        if final_answer is None:
+            final_answer = f"""
+I've spent {max_iterations} iterations trying to solve this task.
+Here's my best answer based on what I've learned:
+
+{observation["observation"]}
+
+Note: This answer may be incomplete as I reached the maximum number of iterations.
+"""
+        
+        return final_answer
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the agent
+    agent = GAIAAgent(use_local_model=False)
+    
+    # Example GAIA-style query
+    query = "What is the capital of France and what is its population? Also, calculate 15% of this population."
+    
+    # Solve the query
+    answer = agent.solve(query)
+    
+    print("\nFinal Answer:")
+    print(answer)

enhanced_agent.py

@@ -0,0 +1,411 @@
+"""
+Enhanced GAIA-Ready AI Agent with integrated memory and reasoning systems
+
+This is the main integration file that combines the agent, memory system,
+and reasoning system into a complete solution for the Hugging Face Agents Course.
+"""
+
+import os
+import sys
+import json
+import traceback
+from typing import List, Dict, Any, Optional, Union
+from datetime import datetime
+
+# Import the memory and reasoning systems
+try:
+    from memory_system import EnhancedMemoryManager
+    from reasoning_system import ReasoningSystem
+except ImportError:
+    print("Error: Could not import memory_system or reasoning_system modules.")
+    print("Make sure memory_system.py and reasoning_system.py are in the same directory.")
+    sys.exit(1)
+
+# Import smolagents
+try:
+    from smolagents import Agent, InferenceClientModel, Tool, LiteLLMModel
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "smolagents"])
+    from smolagents import Agent, InferenceClientModel, Tool
+    try:
+        from smolagents import LiteLLMModel
+    except ImportError:
+        print("Warning: LiteLLMModel not available, will use InferenceClientModel only.")
+
+# Import tool implementations
+from agent import (
+    web_search_function,
+    web_page_content_function,
+    calculator_function,
+    python_executor_function,
+    image_analyzer_function,
+    text_processor_function,
+    file_manager_function
+)
+
+
+class EnhancedGAIAAgent:
+    """
+    Enhanced AI Agent designed to perform well on the GAIA benchmark
+    Integrates memory and reasoning systems with the Think-Act-Observe workflow
+    """
+    def __init__(self, api_key=None, use_local_model=False, use_semantic_memory=True):
+        """
+        Initialize the enhanced GAIA agent
+        
+        Args:
+            api_key: API key for Hugging Face Inference API
+            use_local_model: Whether to use a local model via Ollama
+            use_semantic_memory: Whether to use semantic search for memory retrieval
+        """
+        # Initialize the memory system
+        self.memory_manager = EnhancedMemoryManager(use_semantic_search=use_semantic_memory)
+        
+        # Initialize the LLM model
+        if use_local_model:
+            # Use Ollama for local model
+            try:
+                self.model = LiteLLMModel(
+                    model_id="ollama_chat/qwen2:7b",
+                    api_base="http://127.0.0.1:11434",
+                    num_ctx=8192,
+                )
+                print("Using local Ollama model: qwen2:7b")
+            except Exception as e:
+                print(f"Error initializing local model: {str(e)}")
+                print("Falling back to Hugging Face Inference API")
+                self.model = InferenceClientModel(
+                    model_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
+                    api_key=api_key or os.environ.get("HF_API_KEY", "")
+                )
+                print("Using Hugging Face Inference API model: Mixtral-8x7B")
+        else:
+            # Use Hugging Face Inference API
+            self.model = InferenceClientModel(
+                model_id="mistralai/Mixtral-8x7B-Instruct-v0.1",
+                api_key=api_key or os.environ.get("HF_API_KEY", "")
+            )
+            print("Using Hugging Face Inference API model: Mixtral-8x7B")
+        
+        # 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
+            )
+        ]
+        
+        # Enhanced system prompt for GAIA benchmark
+        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
+   - Break down complex tasks into smaller steps
+   - Consider what information you need and how to get it
+   - Plan your approach before taking action
+
+2. Act: Use appropriate tools to gather information or perform actions
+   - 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)
+
+3. Observe: Analyze the results of your actions and adjust your approach
+   - Verify if the information answers the original question
+   - Identify any gaps or inconsistencies
+   - Determine if additional actions are needed
+
+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
+
+When reasoning:
+- Be thorough and methodical
+- Consider multiple perspectives
+- Explain your thought process clearly
+- Cite sources when providing factual information
+
+Remember that the GAIA benchmark tests your ability to:
+- Reason effectively about complex problems
+- Understand and process multimodal information
+- Navigate the web to find information
+- Use tools appropriately to solve tasks
+
+Always verify your answers before submitting them.
+"""
+        
+        # Initialize the base agent
+        self.base_agent = Agent(
+            model=self.model,
+            tools=self.tools,
+            system_prompt=self.system_prompt
+        )
+        
+        # Initialize the reasoning system
+        self.reasoning_system = ReasoningSystem(self.base_agent, self.memory_manager)
+        
+        # Error handling and recovery settings
+        self.max_retries = 3
+        self.error_log = []
+    
+    def solve(self, query: str, max_iterations: int = 5, verbose: bool = True) -> Dict[str, Any]:
+        """
+        Solve a task using the enhanced Think-Act-Observe workflow
+        
+        Args:
+            query: The user's query or task
+            max_iterations: Maximum number of iterations
+            verbose: Whether to print detailed progress
+            
+        Returns:
+            Dictionary containing the final answer and metadata
+        """
+        start_time = datetime.now()
+        
+        if verbose:
+            print(f"\n{'='*50}")
+            print(f"Starting to solve: {query}")
+            print(f"{'='*50}\n")
+        
+        try:
+            # Execute the reasoning cycle
+            final_answer = self.reasoning_system.execute_reasoning_cycle(query, max_iterations)
+            
+            # Record execution time
+            execution_time = (datetime.now() - start_time).total_seconds()
+            
+            if verbose:
+                print(f"\n{'='*50}")
+                print(f"Task completed in {execution_time:.2f} seconds")
+                print(f"{'='*50}\n")
+            
+            # Get memory summary for debugging
+            memory_summary = self.memory_manager.get_memory_summary()
+            
+            return {
+                "query": query,
+                "answer": final_answer,
+                "execution_time": execution_time,
+                "iterations": max_iterations,
+                "memory_summary": memory_summary,
+                "success": True,
+                "error": None
+            }
+        except Exception as e:
+            error_msg = f"Error solving task: {str(e)}\n{traceback.format_exc()}"
+            print(error_msg)
+            
+            # Record the error
+            self.error_log.append({
+                "timestamp": datetime.now().isoformat(),
+                "query": query,
+                "error": str(e),
+                "traceback": traceback.format_exc()
+            })
+            
+            # Try to recover and provide a partial answer
+            try:
+                recovery_prompt = f"""
+I encountered an error while trying to solve this task: {query}
+
+The error was: {str(e)}
+
+Based on what I know so far, please provide the best possible answer or explanation.
+If you can't provide a complete answer, explain what you do know and what information is missing.
+"""
+                recovery_answer = self.base_agent.chat(recovery_prompt)
+                
+                execution_time = (datetime.now() - start_time).total_seconds()
+                
+                if verbose:
+                    print(f"\n{'='*50}")
+                    print(f"Task completed with recovery in {execution_time:.2f} seconds")
+                    print(f"{'='*50}\n")
+                
+                return {
+                    "query": query,
+                    "answer": recovery_answer,
+                    "execution_time": execution_time,
+                    "iterations": 0,
+                    "success": False,
+                    "error": str(e),
+                    "recovery": True
+                }
+            except Exception as recovery_error:
+                # If recovery fails, return a basic error message
+                return {
+                    "query": query,
+                    "answer": f"I'm sorry, I encountered an error while solving this task and couldn't recover: {str(e)}",
+                    "execution_time": (datetime.now() - start_time).total_seconds(),
+                    "iterations": 0,
+                    "success": False,
+                    "error": str(e),
+                    "recovery_error": str(recovery_error),
+                    "recovery": False
+                }
+    
+    def batch_solve(self, queries: List[str], max_iterations: int = 5, verbose: bool = True) -> List[Dict[str, Any]]:
+        """
+        Solve multiple tasks in batch
+        
+        Args:
+            queries: List of user queries or tasks
+            max_iterations: Maximum number of iterations per query
+            verbose: Whether to print detailed progress
+            
+        Returns:
+            List of results for each query
+        """
+        results = []
+        
+        for i, query in enumerate(queries):
+            if verbose:
+                print(f"\n{'='*50}")
+                print(f"Processing task {i+1}/{len(queries)}: {query}")
+                print(f"{'='*50}\n")
+            
+            result = self.solve(query, max_iterations, verbose)
+            results.append(result)
+            
+            # Clear working memory between tasks
+            self.memory_manager.clear_working_memory()
+        
+        return results
+    
+    def save_results(self, results: Union[Dict[str, Any], List[Dict[str, Any]]], filename: str = "gaia_results.json") -> None:
+        """
+        Save results to a file
+        
+        Args:
+            results: Results from solve() or batch_solve()
+            filename: Name of the file to save results to
+        """
+        try:
+            with open(filename, 'w') as f:
+                json.dump(results, f, indent=2)
+            
+            print(f"Results saved to {filename}")
+        except Exception as e:
+            print(f"Error saving results: {str(e)}")
+    
+    def load_results(self, filename: str = "gaia_results.json") -> Union[Dict[str, Any], List[Dict[str, Any]]]:
+        """
+        Load results from a file
+        
+        Args:
+            filename: Name of the file to load results from
+            
+        Returns:
+            Loaded results
+        """
+        try:
+            with open(filename, 'r') as f:
+                results = json.load(f)
+            
+            print(f"Results loaded from {filename}")
+            return results
+        except Exception as e:
+            print(f"Error loading results: {str(e)}")
+            return []
+    
+    def evaluate_performance(self, results: List[Dict[str, Any]]) -> Dict[str, Any]:
+        """
+        Evaluate performance metrics from batch results
+        
+        Args:
+            results: Results from batch_solve()
+            
+        Returns:
+            Dictionary of performance metrics
+        """
+        if not results:
+            return {"error": "No results to evaluate"}
+        
+        total_queries = len(results)
+        successful_queries = sum(1 for r in results if r.get("success", False))
+        recovery_queries = sum(1 for r in results if not r.get("success", False) and r.get("recovery", False))
+        failed_queries = total_queries - successful_queries - recovery_queries
+        
+        avg_execution_time = sum(r.get("execution_time", 0) for r in results) / total_queries
+        
+        return {
+            "total_queries": total_queries,
+            "successful_queries": successful_queries,
+            "recovery_queries": recovery_queries,
+            "failed_queries": failed_queries,
+            "success_rate": successful_queries / total_queries if total_queries > 0 else 0,
+            "recovery_rate": recovery_queries / total_queries if total_queries > 0 else 0,
+            "failure_rate": failed_queries / total_queries if total_queries > 0 else 0,
+            "avg_execution_time": avg_execution_time
+        }
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the agent
+    agent = EnhancedGAIAAgent(use_local_model=False, use_semantic_memory=True)
+    
+    # Example GAIA-style queries
+    sample_queries = [
+        "What is the capital of France and what is its population? Also, calculate 15% of this population.",
+        "Who was the first person to walk on the moon? What year did this happen?",
+        "Explain the concept of photosynthesis in simple terms."
+    ]
+    
+    # Solve a single query
+    print("\nSolving single query...")
+    result = agent.solve(sample_queries[0])
+    print("\nFinal Answer:")
+    print(result["answer"])
+    
+    # Uncomment to solve batch queries
+    # print("\nSolving batch queries...")
+    # batch_results = agent.batch_solve(sample_queries)
+    # 
+    # # Save results
+    # agent.save_results(batch_results)
+    # 
+    # # Evaluate performance
+    # performance = agent.evaluate_performance(batch_results)
+    # print("\nPerformance Metrics:")
+    # for key, value in performance.items():
+    #     print(f"{key}: {value}")

memory_system.py

@@ -0,0 +1,462 @@
+"""
+Enhanced Memory System for GAIA-Ready AI Agent
+
+This module provides an advanced memory system for the AI agent,
+including short-term, long-term, and working memory components,
+as well as semantic retrieval capabilities.
+"""
+
+import os
+import json
+from typing import List, Dict, Any, Optional, Union
+from datetime import datetime
+import re
+import numpy as np
+from collections import defaultdict
+
+try:
+    from sentence_transformers import SentenceTransformer
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "sentence-transformers"])
+    from sentence_transformers import SentenceTransformer
+
+
+class EnhancedMemoryManager:
+    """
+    Advanced memory manager for the agent that maintains short-term, long-term,
+    and working memory with semantic retrieval capabilities.
+    """
+    def __init__(self, use_semantic_search=True):
+        self.short_term_memory = []  # Current conversation context
+        self.long_term_memory = []   # Key facts and results
+        self.working_memory = {}     # Temporary storage for complex tasks
+        self.max_short_term_items = 15
+        self.max_long_term_items = 100
+        self.use_semantic_search = use_semantic_search
+        
+        # Initialize semantic search if enabled
+        if self.use_semantic_search:
+            try:
+                self.embedding_model = SentenceTransformer('all-MiniLM-L6-v2')
+                self.memory_embeddings = []
+            except Exception as e:
+                print(f"Warning: Could not initialize semantic search: {str(e)}")
+                self.use_semantic_search = False
+        
+        # Memory persistence
+        self.memory_file = "agent_memory.json"
+        self.load_memories()
+    
+    def add_to_short_term(self, item: Dict[str, Any]) -> None:
+        """Add an item to short-term memory, maintaining size limit"""
+        # Ensure item has all required fields
+        if "content" not in item:
+            raise ValueError("Memory item must have 'content' field")
+        
+        if "timestamp" not in item:
+            item["timestamp"] = datetime.now().isoformat()
+        
+        if "type" not in item:
+            item["type"] = "general"
+        
+        self.short_term_memory.append(item)
+        
+        # Update semantic embeddings if enabled
+        if self.use_semantic_search:
+            try:
+                content = item.get("content", "")
+                embedding = self.embedding_model.encode(content)
+                self.memory_embeddings.append((embedding, len(self.short_term_memory) - 1, "short_term"))
+            except Exception as e:
+                print(f"Warning: Could not create embedding for memory item: {str(e)}")
+        
+        # Maintain size limit
+        if len(self.short_term_memory) > self.max_short_term_items:
+            removed_item = self.short_term_memory.pop(0)
+            # Remove corresponding embedding if it exists
+            if self.use_semantic_search:
+                self.memory_embeddings = [(emb, idx, mem_type) for emb, idx, mem_type in self.memory_embeddings 
+                                         if not (mem_type == "short_term" and idx == 0)]
+                # Update indices for remaining short-term memories
+                self.memory_embeddings = [(emb, idx-1 if mem_type == "short_term" else idx, mem_type) 
+                                         for emb, idx, mem_type in self.memory_embeddings]
+        
+        # Save memories periodically
+        self.save_memories()
+    
+    def add_to_long_term(self, item: Dict[str, Any]) -> None:
+        """Add an important item to long-term memory, maintaining size limit"""
+        # Ensure item has all required fields
+        if "content" not in item:
+            raise ValueError("Memory item must have 'content' field")
+        
+        if "timestamp" not in item:
+            item["timestamp"] = datetime.now().isoformat()
+        
+        if "type" not in item:
+            item["type"] = "general"
+        
+        # Add importance score if not present
+        if "importance" not in item:
+            # Calculate importance based on content length and type
+            content_length = len(item.get("content", ""))
+            type_importance = {
+                "final_answer": 0.9,
+                "key_fact": 0.8,
+                "reasoning": 0.7,
+                "general": 0.5
+            }
+            item["importance"] = min(1.0, (content_length / 1000) * type_importance.get(item["type"], 0.5))
+        
+        self.long_term_memory.append(item)
+        
+        # Update semantic embeddings if enabled
+        if self.use_semantic_search:
+            try:
+                content = item.get("content", "")
+                embedding = self.embedding_model.encode(content)
+                self.memory_embeddings.append((embedding, len(self.long_term_memory) - 1, "long_term"))
+            except Exception as e:
+                print(f"Warning: Could not create embedding for memory item: {str(e)}")
+        
+        # Sort long-term memory by importance (descending)
+        self.long_term_memory.sort(key=lambda x: x.get("importance", 0), reverse=True)
+        
+        # Maintain size limit
+        if len(self.long_term_memory) > self.max_long_term_items:
+            # Remove least important memory
+            removed_item = self.long_term_memory.pop()
+            # Remove corresponding embedding if it exists
+            if self.use_semantic_search:
+                self.memory_embeddings = [(emb, idx, mem_type) for emb, idx, mem_type in self.memory_embeddings 
+                                         if not (mem_type == "long_term" and idx == len(self.long_term_memory))]
+                # Update indices for remaining long-term memories
+                # This is more complex since we sorted by importance, so we need to rebuild indices
+                long_term_embeddings = []
+                for i, item in enumerate(self.long_term_memory):
+                    content = item.get("content", "")
+                    embedding = self.embedding_model.encode(content)
+                    long_term_embeddings.append((embedding, i, "long_term"))
+                
+                # Keep short-term embeddings and replace long-term ones
+                self.memory_embeddings = [(emb, idx, mem_type) for emb, idx, mem_type in self.memory_embeddings 
+                                         if mem_type == "short_term"] + long_term_embeddings
+        
+        # Save memories periodically
+        self.save_memories()
+    
+    def store_in_working_memory(self, key: str, value: Any) -> None:
+        """Store a value in working memory under the specified key"""
+        self.working_memory[key] = value
+        # Working memory is not persisted between sessions
+    
+    def get_from_working_memory(self, key: str) -> Optional[Any]:
+        """Retrieve a value from working memory by key"""
+        return self.working_memory.get(key)
+    
+    def clear_working_memory(self) -> None:
+        """Clear the working memory"""
+        self.working_memory = {}
+    
+    def get_relevant_memories(self, query: str, max_results: int = 10) -> List[Dict[str, Any]]:
+        """
+        Retrieve memories relevant to the current query
+        
+        Args:
+            query: The query to find relevant memories for
+            max_results: Maximum number of results to return
+            
+        Returns:
+            List of relevant memory items
+        """
+        if self.use_semantic_search:
+            try:
+                # Use semantic search to find relevant memories
+                query_embedding = self.embedding_model.encode(query)
+                
+                # Calculate cosine similarity with all memory embeddings
+                similarities = []
+                for embedding, idx, mem_type in self.memory_embeddings:
+                    similarity = np.dot(query_embedding, embedding) / (np.linalg.norm(query_embedding) * np.linalg.norm(embedding))
+                    similarities.append((similarity, idx, mem_type))
+                
+                # Sort by similarity (descending)
+                similarities.sort(reverse=True)
+                
+                # Get top results
+                relevant_memories = []
+                for similarity, idx, mem_type in similarities[:max_results]:
+                    if mem_type == "short_term":
+                        memory = self.short_term_memory[idx]
+                    else:  # long_term
+                        memory = self.long_term_memory[idx]
+                    
+                    # Add similarity score to memory item
+                    memory_with_score = memory.copy()
+                    memory_with_score["relevance_score"] = float(similarity)
+                    relevant_memories.append(memory_with_score)
+                
+                return relevant_memories
+            except Exception as e:
+                print(f"Warning: Semantic search failed: {str(e)}. Falling back to keyword search.")
+                return self._keyword_search(query, max_results)
+        else:
+            return self._keyword_search(query, max_results)
+    
+    def _keyword_search(self, query: str, max_results: int = 10) -> List[Dict[str, Any]]:
+        """
+        Fallback keyword-based search for relevant memories
+        
+        Args:
+            query: The query to find relevant memories for
+            max_results: Maximum number of results to return
+            
+        Returns:
+            List of relevant memory items
+        """
+        relevant_memories = []
+        query_keywords = set(re.findall(r'\b\w+\b', query.lower()))
+        
+        # Score function for keyword matching
+        def score_memory(memory):
+            content = memory.get("content", "").lower()
+            content_words = set(re.findall(r'\b\w+\b', content))
+            
+            # Count matching keywords
+            matches = len(query_keywords.intersection(content_words))
+            
+            # Consider memory type and recency
+            type_boost = {
+                "final_answer": 2.0,
+                "key_fact": 1.5,
+                "reasoning": 1.2,
+                "general": 1.0
+            }
+            
+            # Calculate recency (assuming ISO format timestamps)
+            try:
+                timestamp = datetime.fromisoformat(memory.get("timestamp", "2000-01-01T00:00:00"))
+                now = datetime.now()
+                hours_ago = (now - timestamp).total_seconds() / 3600
+                recency_factor = max(0.5, 1.0 - (hours_ago / 24))  # Decay over 24 hours
+            except:
+                recency_factor = 0.5
+            
+            # Calculate final score
+            score = matches * type_boost.get(memory.get("type", "general"), 1.0) * recency_factor
+            
+            return score
+        
+        # Score all memories
+        scored_memories = []
+        
+        # Check long-term memory first (more important)
+        for memory in self.long_term_memory:
+            score = score_memory(memory)
+            if score > 0:
+                memory_with_score = memory.copy()
+                memory_with_score["relevance_score"] = score
+                scored_memories.append((score, memory_with_score))
+        
+        # Then check short-term memory
+        for memory in self.short_term_memory:
+            score = score_memory(memory)
+            if score > 0:
+                memory_with_score = memory.copy()
+                memory_with_score["relevance_score"] = score
+                scored_memories.append((score, memory_with_score))
+        
+        # Sort by score (descending) and take top results
+        scored_memories.sort(reverse=True, key=lambda x: x[0])
+        relevant_memories = [memory for _, memory in scored_memories[:max_results]]
+        
+        return relevant_memories
+    
+    def get_memory_summary(self) -> str:
+        """Get a summary of the current memory state for the agent"""
+        # Get most recent short-term memories
+        recent_short_term = self.short_term_memory[-5:] if self.short_term_memory else []
+        short_term_summary = "\n".join([f"- [{m.get('type', 'general')}] {m.get('content', '')[:100]}..." 
+                                      for m in recent_short_term])
+        
+        # Get most important long-term memories
+        important_long_term = sorted(self.long_term_memory, 
+                                    key=lambda x: x.get("importance", 0), 
+                                    reverse=True)[:5] if self.long_term_memory else []
+        long_term_summary = "\n".join([f"- [{m.get('type', 'general')}] {m.get('content', '')[:100]}..." 
+                                     for m in important_long_term])
+        
+        # Summarize working memory
+        working_memory_summary = "\n".join([f"- {k}: {str(v)[:50]}..." if isinstance(v, str) and len(str(v)) > 50 
+                                          else f"- {k}: {v}" for k, v in self.working_memory.items()])
+        
+        return f"""
+MEMORY SUMMARY:
+--------------
+Recent Short-Term Memory:
+{short_term_summary if short_term_summary else "No recent short-term memories."}
+
+Important Long-Term Memory:
+{long_term_summary if long_term_summary else "No important long-term memories."}
+
+Working Memory:
+{working_memory_summary if working_memory_summary else "Working memory is empty."}
+"""
+    
+    def save_memories(self) -> None:
+        """Save memories to disk for persistence"""
+        try:
+            # Only save short-term and long-term memories (not working memory)
+            memories = {
+                "short_term": self.short_term_memory,
+                "long_term": self.long_term_memory,
+                "last_updated": datetime.now().isoformat()
+            }
+            
+            with open(self.memory_file, 'w') as f:
+                json.dump(memories, f, indent=2)
+        except Exception as e:
+            print(f"Warning: Could not save memories: {str(e)}")
+    
+    def load_memories(self) -> None:
+        """Load memories from disk if available"""
+        try:
+            if os.path.exists(self.memory_file):
+                with open(self.memory_file, 'r') as f:
+                    memories = json.load(f)
+                
+                self.short_term_memory = memories.get("short_term", [])
+                self.long_term_memory = memories.get("long_term", [])
+                
+                # Rebuild embeddings if semantic search is enabled
+                if self.use_semantic_search:
+                    self.memory_embeddings = []
+                    
+                    # Add embeddings for short-term memories
+                    for i, memory in enumerate(self.short_term_memory):
+                        try:
+                            content = memory.get("content", "")
+                            embedding = self.embedding_model.encode(content)
+                            self.memory_embeddings.append((embedding, i, "short_term"))
+                        except Exception as e:
+                            print(f"Warning: Could not create embedding for memory item: {str(e)}")
+                    
+                    # Add embeddings for long-term memories
+                    for i, memory in enumerate(self.long_term_memory):
+                        try:
+                            content = memory.get("content", "")
+                            embedding = self.embedding_model.encode(content)
+                            self.memory_embeddings.append((embedding, i, "long_term"))
+                        except Exception as e:
+                            print(f"Warning: Could not create embedding for memory item: {str(e)}")
+                
+                print(f"Loaded {len(self.short_term_memory)} short-term and {len(self.long_term_memory)} long-term memories.")
+        except Exception as e:
+            print(f"Warning: Could not load memories: {str(e)}")
+    
+    def forget_old_memories(self, days_threshold: int = 30) -> None:
+        """
+        Remove memories older than the specified threshold
+        
+        Args:
+            days_threshold: Age threshold in days
+        """
+        try:
+            now = datetime.now()
+            threshold = days_threshold * 24 * 60 * 60  # Convert to seconds
+            
+            # Filter short-term memories
+            new_short_term = []
+            for i, memory in enumerate(self.short_term_memory):
+                try:
+                    timestamp = datetime.fromisoformat(memory.get("timestamp", "2000-01-01T00:00:00"))
+                    age = (now - timestamp).total_seconds()
+                    if age < threshold:
+                        new_short_term.append(memory)
+                except:
+                    # Keep memories with invalid timestamps
+                    new_short_term.append(memory)
+            
+            # Filter long-term memories
+            new_long_term = []
+            for i, memory in enumerate(self.long_term_memory):
+                try:
+                    timestamp = datetime.fromisoformat(memory.get("timestamp", "2000-01-01T00:00:00"))
+                    age = (now - timestamp).total_seconds()
+                    # For long-term, also consider importance
+                    importance = memory.get("importance", 0.5)
+                    # More important memories have a higher threshold
+                    adjusted_threshold = threshold * (1 + importance)
+                    if age < adjusted_threshold:
+                        new_long_term.append(memory)
+                except:
+                    # Keep memories with invalid timestamps
+                    new_long_term.append(memory)
+            
+            # Update memories
+            removed_short_term = len(self.short_term_memory) - len(new_short_term)
+            removed_long_term = len(self.long_term_memory) - len(new_long_term)
+            
+            self.short_term_memory = new_short_term
+            self.long_term_memory = new_long_term
+            
+            # Rebuild embeddings if semantic search is enabled
+            if self.use_semantic_search:
+                self.memory_embeddings = []
+                
+                # Add embeddings for short-term memories
+                for i, memory in enumerate(self.short_term_memory):
+                    try:
+                        content = memory.get("content", "")
+                        embedding = self.embedding_model.encode(content)
+                        self.memory_embeddings.append((embedding, i, "short_term"))
+                    except Exception as e:
+                        print(f"Warning: Could not create embedding for memory item: {str(e)}")
+                
+                # Add embeddings for long-term memories
+                for i, memory in enumerate(self.long_term_memory):
+                    try:
+                        content = memory.get("content", "")
+                        embedding = self.embedding_model.encode(content)
+                        self.memory_embeddings.append((embedding, i, "long_term"))
+                    except Exception as e:
+                        print(f"Warning: Could not create embedding for memory item: {str(e)}")
+            
+            # Save updated memories
+            self.save_memories()
+            
+            print(f"Forgot {removed_short_term} short-term and {removed_long_term} long-term memories older than {days_threshold} days.")
+        except Exception as e:
+            print(f"Warning: Could not forget old memories: {str(e)}")
+
+
+# Example usage
+if __name__ == "__main__":
+    # Initialize the memory manager
+    memory_manager = EnhancedMemoryManager(use_semantic_search=True)
+    
+    # Add some test memories
+    memory_manager.add_to_short_term({
+        "type": "query",
+        "content": "What is the capital of France?",
+        "timestamp": datetime.now().isoformat()
+    })
+    
+    memory_manager.add_to_long_term({
+        "type": "key_fact",
+        "content": "Paris is the capital of France with a population of about 2.2 million people.",
+        "timestamp": datetime.now().isoformat()
+    })
+    
+    memory_manager.store_in_working_memory("current_task", "Finding information about France")
+    
+    # Test retrieval
+    relevant_memories = memory_manager.get_relevant_memories("What is the population of Paris?")
+    print("\nRelevant memories for 'What is the population of Paris?':")
+    for memory in relevant_memories:
+        print(f"- Score: {memory.get('relevance_score', 0):.2f}, Content: {memory.get('content', '')}")
+    
+    # Print memory summary
+    print("\nMemory Summary:")
+    print(memory_manager.get_memory_summary())

reasoning_system.py

@@ -0,0 +1,668 @@
+"""
+Reasoning System for GAIA-Ready AI Agent
+
+This module provides advanced reasoning capabilities for the AI agent,
+implementing the ReAct approach (Reasoning + Acting) and supporting
+the Think-Act-Observe workflow.
+"""
+
+import os
+import json
+from typing import List, Dict, Any, Optional, Union, Tuple
+from datetime import datetime
+import traceback
+import re
+
+try:
+    from smolagents import Agent, InferenceClientModel, Tool
+except ImportError:
+    import subprocess
+    subprocess.check_call(["pip", "install", "smolagents"])
+    from smolagents import Agent, InferenceClientModel, Tool
+
+
+class ReasoningSystem:
+    """
+    Advanced reasoning system implementing the ReAct approach
+    and supporting the Think-Act-Observe workflow.
+    """
+    def __init__(self, agent, memory_manager):
+        self.agent = agent
+        self.memory_manager = memory_manager
+        self.max_reasoning_depth = 5
+        self.reasoning_templates = self._load_reasoning_templates()
+    
+    def _load_reasoning_templates(self) -> Dict[str, str]:
+        """Load reasoning templates for different stages of the workflow"""
+        return {
+            "think": """
+# Task Analysis and Planning
+
+## Task
+{query}
+
+## Relevant Context
+{context}
+
+## Analysis
+Let me analyze this task step by step:
+1. What is being asked?
+2. What information do I need?
+3. What challenges might I encounter?
+
+## Plan
+Based on my analysis, here's my plan:
+1. [First step]
+2. [Second step]
+3. [Third step]
+...
+
+## Tools Needed
+To accomplish this task, I'll need:
+- [Tool 1]: For [purpose]
+- [Tool 2]: For [purpose]
+...
+
+## Expected Outcome
+If successful, I expect to:
+[Description of expected outcome]
+""",
+            "act": """
+# Action Execution
+
+## Current Task
+{query}
+
+## Current Plan
+{plan}
+
+## Previous Results
+{previous_results}
+
+## Next Action
+Based on my plan and previous results, I'll now:
+1. Use the [tool name] tool
+2. With parameters: [parameters]
+3. Purpose: [why this action is needed]
+
+## Execution
+[Detailed description of how I'll execute this action]
+""",
+            "observe": """
+# Result Analysis
+
+## Current Task
+{query}
+
+## Action Taken
+{action}
+
+## Results Obtained
+{results}
+
+## Analysis
+Let me analyze these results:
+1. What did I learn?
+2. Does this answer the original question?
+3. Are there any inconsistencies or gaps?
+
+## Next Steps
+Based on my analysis:
+- [Next step recommendation]
+- [Alternative approach if needed]
+
+## Progress Assessment
+Task completion status: [percentage]%
+[Explanation of current progress]
+"""
+        }
+    
+    def think(self, query: str) -> Dict[str, Any]:
+        """
+        Analyze the task and plan an approach (Think phase)
+        
+        Args:
+            query: The user's query or task
+            
+        Returns:
+            Dictionary containing analysis and plan
+        """
+        # Retrieve relevant memories
+        relevant_memories = self.memory_manager.get_relevant_memories(query)
+        
+        # Format context from relevant memories
+        context = ""
+        if relevant_memories:
+            context_items = []
+            for memory in relevant_memories:
+                memory_type = memory.get("type", "general")
+                content = memory.get("content", "")
+                relevance = memory.get("relevance_score", 0)
+                context_items.append(f"- [{memory_type.upper()}] (Relevance: {relevance:.2f}): {content}")
+            context = "\n".join(context_items)
+        else:
+            context = "No relevant prior knowledge found."
+        
+        # Apply the thinking template
+        thinking_template = self.reasoning_templates["think"]
+        thinking_prompt = thinking_template.format(
+            query=query,
+            context=context
+        )
+        
+        # Use the agent to generate a plan
+        try:
+            response = self.agent.chat(thinking_prompt)
+            
+            # Store the thinking in memory
+            self.memory_manager.add_to_short_term({
+                "type": "thinking",
+                "content": response,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            # Parse the response to extract structured information
+            analysis = self._extract_section(response, "Analysis")
+            plan = self._extract_section(response, "Plan")
+            tools_needed = self._extract_section(response, "Tools Needed")
+            expected_outcome = self._extract_section(response, "Expected Outcome")
+            
+            return {
+                "raw_response": response,
+                "analysis": analysis,
+                "plan": plan,
+                "tools_needed": tools_needed,
+                "expected_outcome": expected_outcome
+            }
+        except Exception as e:
+            error_msg = f"Error during thinking phase: {str(e)}\n{traceback.format_exc()}"
+            print(error_msg)
+            
+            # Store the error in memory
+            self.memory_manager.add_to_short_term({
+                "type": "error",
+                "content": error_msg,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            # Return a basic plan despite the error
+            return {
+                "raw_response": "Error occurred during thinking phase.",
+                "analysis": "Could not analyze the task due to an error.",
+                "plan": "1. Try a simpler approach\n2. Break down the task into smaller steps",
+                "tools_needed": "web_search: To find basic information",
+                "expected_outcome": "Partial answer to the query"
+            }
+    
+    def act(self, plan: Dict[str, Any], query: str, previous_results: str = "") -> Dict[str, Any]:
+        """
+        Execute actions based on the plan (Act phase)
+        
+        Args:
+            plan: The plan generated by the think step
+            query: The original query
+            previous_results: Results from previous actions
+            
+        Returns:
+            Dictionary containing action details and results
+        """
+        # Apply the action template
+        action_template = self.reasoning_templates["act"]
+        action_prompt = action_template.format(
+            query=query,
+            plan=plan.get("plan", "No plan available."),
+            previous_results=previous_results if previous_results else "No previous results."
+        )
+        
+        try:
+            # Use the agent to determine the next action
+            action_response = self.agent.chat(action_prompt)
+            
+            # Store the action planning in memory
+            self.memory_manager.add_to_short_term({
+                "type": "action_planning",
+                "content": action_response,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            # Parse the action response to extract tool and parameters
+            tool_info = self._extract_tool_info(action_response)
+            
+            if not tool_info:
+                # If no tool was identified, try a more direct approach
+                direct_prompt = f"""
+Based on the task "{query}" and the plan:
+{plan.get('plan', 'No plan available.')}
+
+Which specific tool should I use next and with what parameters?
+Respond in this format:
+TOOL: [tool name]
+PARAMETERS: [parameter1=value1, parameter2=value2, ...]
+"""
+                direct_response = self.agent.chat(direct_prompt)
+                tool_info = self._extract_tool_info(direct_response)
+            
+            if tool_info:
+                tool_name = tool_info["tool"]
+                tool_params = tool_info["parameters"]
+                
+                # Find the matching tool
+                matching_tool = None
+                for tool in self.agent.tools:
+                    if tool.name == tool_name:
+                        matching_tool = tool
+                        break
+                
+                if matching_tool:
+                    # Execute the tool
+                    try:
+                        if isinstance(tool_params, dict):
+                            result = matching_tool.function(**tool_params)
+                        else:
+                            result = matching_tool.function(tool_params)
+                        
+                        # Store the successful action result in memory
+                        self.memory_manager.add_to_short_term({
+                            "type": "action_result",
+                            "content": f"Tool: {tool_name}\nParameters: {tool_params}\nResult: {result}",
+                            "timestamp": datetime.now().isoformat()
+                        })
+                        
+                        return {
+                            "tool": tool_name,
+                            "parameters": tool_params,
+                            "result": result,
+                            "success": True,
+                            "error": None
+                        }
+                    except Exception as e:
+                        error_msg = f"Error executing tool {tool_name}: {str(e)}\n{traceback.format_exc()}"
+                        print(error_msg)
+                        
+                        # Store the error in memory
+                        self.memory_manager.add_to_short_term({
+                            "type": "error",
+                            "content": error_msg,
+                            "timestamp": datetime.now().isoformat()
+                        })
+                        
+                        return {
+                            "tool": tool_name,
+                            "parameters": tool_params,
+                            "result": f"Error: {str(e)}",
+                            "success": False,
+                            "error": str(e)
+                        }
+                else:
+                    error_msg = f"Tool '{tool_name}' not found."
+                    print(error_msg)
+                    
+                    # Store the error in memory
+                    self.memory_manager.add_to_short_term({
+                        "type": "error",
+                        "content": error_msg,
+                        "timestamp": datetime.now().isoformat()
+                    })
+                    
+                    return {
+                        "tool": tool_name,
+                        "parameters": tool_params,
+                        "result": f"Error: Tool '{tool_name}' not found.",
+                        "success": False,
+                        "error": "Tool not found"
+                    }
+            else:
+                error_msg = "Could not determine which tool to use."
+                print(error_msg)
+                
+                # Store the error in memory
+                self.memory_manager.add_to_short_term({
+                    "type": "error",
+                    "content": error_msg,
+                    "timestamp": datetime.now().isoformat()
+                })
+                
+                # Default to web search as a fallback
+                try:
+                    web_search_tool = None
+                    for tool in self.agent.tools:
+                        if tool.name == "web_search":
+                            web_search_tool = tool
+                            break
+                    
+                    if web_search_tool:
+                        result = web_search_tool.function(query)
+                        return {
+                            "tool": "web_search",
+                            "parameters": query,
+                            "result": result,
+                            "success": True,
+                            "error": None,
+                            "fallback": True
+                        }
+                    else:
+                        return {
+                            "tool": "none",
+                            "parameters": "none",
+                            "result": "Could not determine which tool to use and web_search fallback not available.",
+                            "success": False,
+                            "error": "No tool selected"
+                        }
+                except Exception as e:
+                    return {
+                        "tool": "web_search",
+                        "parameters": query,
+                        "result": f"Error in fallback web search: {str(e)}",
+                        "success": False,
+                        "error": str(e),
+                        "fallback": True
+                    }
+        except Exception as e:
+            error_msg = f"Error during action phase: {str(e)}\n{traceback.format_exc()}"
+            print(error_msg)
+            
+            # Store the error in memory
+            self.memory_manager.add_to_short_term({
+                "type": "error",
+                "content": error_msg,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            return {
+                "tool": "none",
+                "parameters": "none",
+                "result": f"Error during action planning: {str(e)}",
+                "success": False,
+                "error": str(e)
+            }
+    
+    def observe(self, action_result: Dict[str, Any], plan: Dict[str, Any], query: str) -> Dict[str, Any]:
+        """
+        Analyze the results of actions and determine next steps (Observe phase)
+        
+        Args:
+            action_result: Results from the act step
+            plan: The original plan
+            query: The original query
+            
+        Returns:
+            Dictionary containing observation and next steps
+        """
+        # Apply the observation template
+        observation_template = self.reasoning_templates["observe"]
+        observation_prompt = observation_template.format(
+            query=query,
+            action=f"Tool: {action_result.get('tool', 'none')}\nParameters: {action_result.get('parameters', 'none')}",
+            results=action_result.get('result', 'No results.')
+        )
+        
+        try:
+            # Use the agent to analyze the results
+            observation_response = self.agent.chat(observation_prompt)
+            
+            # Store the observation in memory
+            self.memory_manager.add_to_short_term({
+                "type": "observation",
+                "content": observation_response,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            # Parse the observation to extract structured information
+            analysis = self._extract_section(observation_response, "Analysis")
+            next_steps = self._extract_section(observation_response, "Next Steps")
+            progress = self._extract_section(observation_response, "Progress Assessment")
+            
+            # Determine if we need to continue with more actions
+            continue_execution = True
+            
+            # Check for completion indicators
+            completion_phrases = [
+                "task complete", "question answered", "fully answered",
+                "100%", "task is complete", "fully resolved"
+            ]
+            
+            if any(phrase in observation_response.lower() for phrase in completion_phrases):
+                continue_execution = False
+                
+                # Store the final answer in long-term memory
+                self.memory_manager.add_to_long_term({
+                    "type": "final_answer",
+                    "query": query,
+                    "content": observation_response,
+                    "timestamp": datetime.now().isoformat(),
+                    "importance": 0.8  # High importance for final answers
+                })
+            
+            return {
+                "raw_response": observation_response,
+                "analysis": analysis,
+                "next_steps": next_steps,
+                "progress": progress,
+                "continue": continue_execution
+            }
+        except Exception as e:
+            error_msg = f"Error during observation phase: {str(e)}\n{traceback.format_exc()}"
+            print(error_msg)
+            
+            # Store the error in memory
+            self.memory_manager.add_to_short_term({
+                "type": "error",
+                "content": error_msg,
+                "timestamp": datetime.now().isoformat()
+            })
+            
+            # Default observation with continuation
+            return {
+                "raw_response": f"Error occurred during observation phase: {str(e)}",
+                "analysis": "Could not analyze the results due to an error.",
+                "next_steps": "Try a different approach or tool.",
+                "progress": "Unknown due to error.",
+                "continue": True  # Continue by default on error
+            }
+    
+    def _extract_section(self, text: str, section_name: str) -> str:
+        """Extract a section from the response text"""
+        pattern = rf"(?:^|\n)(?:#+\s*{re.escape(section_name)}:?|\*\*{re.escape(section_name)}:?\*\*|{re.escape(section_name)}:?)\s*(.*?)(?:\n(?:#+\s*|$)|\Z)"
+        match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
+        
+        if match:
+            content = match.group(1).strip()
+            return content
+        
+        # Try a more lenient approach if the first one fails
+        pattern = rf"{re.escape(section_name)}:?\s*(.*?)(?:\n\n|\n[A-Z]|\Z)"
+        match = re.search(pattern, text, re.DOTALL | re.IGNORECASE)
+        
+        if match:
+            content = match.group(1).strip()
+            return content
+        
+        return f"No {section_name.lower()} found."
+    
+    def _extract_tool_info(self, text: str) -> Optional[Dict[str, Any]]:
+        """Extract tool name and parameters from the response text"""
+        # Try to find tool name
+        tool_pattern = r"(?:TOOL|Tool|tool):\s*(\w+)"
+        tool_match = re.search(tool_pattern, text)
+        
+        if not tool_match:
+            return None
+        
+        tool_name = tool_match.group(1).strip()
+        
+        # Try to find parameters
+        params_pattern = r"(?:PARAMETERS|Parameters|parameters):\s*(.*?)(?:\n\n|\n[A-Z]|\Z)"
+        params_match = re.search(params_pattern, text, re.DOTALL)
+        
+        if params_match:
+            params_text = params_match.group(1).strip()
+            
+            # Check if parameters are in key=value format
+            if "=" in params_text:
+                # Parse as dictionary
+                params_dict = {}
+                param_pairs = re.findall(r"(\w+)\s*=\s*([^,\n]+)", params_text)
+                
+                for key, value in param_pairs:
+                    params_dict[key.strip()] = value.strip()
+                
+                return {
+                    "tool": tool_name,
+                    "parameters": params_dict
+                }
+            else:
+                # Treat as a single string parameter
+                return {
+                    "tool": tool_name,
+                    "parameters": params_text
+                }
+        else:
+            # No parameters found, use empty dict
+            return {
+                "tool": tool_name,
+                "parameters": {}
+            }
+    
+    def execute_reasoning_cycle(self, query: str, max_iterations: int = 5) -> str:
+        """
+        Execute a complete Think-Act-Observe reasoning cycle
+        
+        Args:
+            query: The user's query or task
+            max_iterations: Maximum number of iterations
+            
+        Returns:
+            Final answer to the query
+        """
+        # Store the query in memory
+        self.memory_manager.add_to_short_term({
+            "type": "query",
+            "content": query,
+            "timestamp": datetime.now().isoformat()
+        })
+        
+        # Initialize the workflow
+        iteration = 0
+        final_answer = None
+        all_results = []
+        
+        while iteration < max_iterations:
+            print(f"Iteration {iteration + 1}/{max_iterations}")
+            
+            # Think
+            print("Thinking...")
+            plan = self.think(query)
+            
+            # Act
+            print("Acting...")
+            previous_results = "\n".join([r.get("result", "") for r in all_results])
+            action_result = self.act(plan, query, previous_results)
+            all_results.append(action_result)
+            
+            # Observe
+            print("Observing...")
+            observation = self.observe(action_result, plan, query)
+            
+            # Check if we have a final answer
+            if not observation["continue"]:
+                # Generate final answer
+                final_answer_prompt = f"""
+TASK: {query}
+
+REASONING PROCESS:
+{plan.get('raw_response', 'No thinking process available.')}
+
+ACTIONS TAKEN:
+{', '.join([f"{r.get('tool', 'unknown')}({r.get('parameters', '')})" for r in all_results])}
+
+RESULTS:
+{previous_results}
+{action_result.get('result', '')}
+
+OBSERVATION:
+{observation.get('raw_response', 'No observation available.')}
+
+Based on all the above, provide a comprehensive final answer to the original task.
+"""
+                final_answer = self.agent.chat(final_answer_prompt)
+                
+                # Store the final answer in long-term memory
+                self.memory_manager.add_to_long_term({
+                    "type": "final_answer",
+                    "query": query,
+                    "content": final_answer,
+                    "timestamp": datetime.now().isoformat(),
+                    "importance": 0.9  # Very high importance
+                })
+                
+                break
+            
+            # Update the query with the observation for the next iteration
+            query = f"""
+Original task: {query}
+
+Progress so far:
+{observation.get('raw_response', 'No observation available.')}
+
+Please continue solving this task.
+"""
+            
+            iteration += 1
+        
+        # If we reached max iterations without a final answer
+        if final_answer is None:
+            final_answer = f"""
+I've spent {max_iterations} iterations trying to solve this task.
+Here's my best answer based on what I've learned:
+
+{observation.get('raw_response', 'No final observation available.')}
+
+Note: This answer may be incomplete as I reached the maximum number of iterations.
+"""
+            
+            # Store the partial answer in long-term memory
+            self.memory_manager.add_to_long_term({
+                "type": "partial_answer",
+                "query": query,
+                "content": final_answer,
+                "timestamp": datetime.now().isoformat(),
+                "importance": 0.6  # Medium importance for partial answers
+            })
+        
+        return final_answer
+
+
+# Example usage
+if __name__ == "__main__":
+    # This would be imported from your agent.py
+    from smolagents import Agent, InferenceClientModel, Tool
+    
+    # Mock agent for testing
+    class MockAgent:
+        def __init__(self):
+            self.tools = [
+                Tool(name="web_search", description="Search the web", function=lambda x: f"Search results for: {x}"),
+                Tool(name="calculator", description="Calculate", function=lambda x: f"Result: {eval(x)}")
+            ]
+        
+        def chat(self, message):
+            return f"Response to: {message[:50]}..."
+    
+    # Mock memory manager
+    class MockMemoryManager:
+        def add_to_short_term(self, item):
+            print(f"Added to short-term: {item['type']}")
+        
+        def add_to_long_term(self, item):
+            print(f"Added to long-term: {item['type']}")
+        
+        def get_relevant_memories(self, query):
+            return []
+    
+    # Test the reasoning system
+    agent = MockAgent()
+    memory_manager = MockMemoryManager()
+    reasoning = ReasoningSystem(agent, memory_manager)
+    
+    result = reasoning.execute_reasoning_cycle("What is 2+2?")
+    print(f"\nFinal result: {result}")