Updated agent

README.md

@@ -1,13 +1,51 @@
 ---
-title: Isadora Final Assignment
-emoji: 🕵🏻‍♂️
-colorFrom: indigo
-colorTo: indigo
+title: My GAIA Agent - Final Project
+emoji: 🤖
+colorFrom: blue
+colorTo: green
 sdk: gradio
 sdk_version: 5.25.2
 app_file: app.py
 pinned: false
 hf_oauth: true
-# optional, default duration is 8 hours/480 minutes. Max duration is 30 days/43200 minutes.
 hf_oauth_expiration_minutes: 480
----
+---
+
+# My GAIA Agent - Final Course Project
+
+This is my submission for the AI Agents course. I built an agent that can hopefully pass the GAIA benchmark with 30%+ score to get my certificate!
+
+## What My Agent Does
+
+My agent combines everything I learned in the course:
+
+- **🔍 Web Search**: Uses DuckDuckGo to find current information 
+- **🧮 Calculator**: Does math calculations (super important for GAIA!)
+- **📊 File Analysis**: Can analyze CSV files and other data
+- **👥 Persona Database**: RAG system with vector search over persona descriptions
+- **🤖 Agent Workflow**: Uses LlamaIndex AgentWorkflow like we learned in class
+
+## How to Use
+
+1. **Login** with your HuggingFace account using the button below
+2. **Click "Run GAIA Evaluation"** and wait (takes 5-10 minutes)
+3. **See your results** and hopefully pass with 30%+!
+
+## Technical Details
+
+- **LLM**: OpenAI GPT-4o-mini (primary) or HuggingFace Qwen2.5 (fallback)
+- **Vector DB**: ChromaDB with in-memory storage for HF Spaces
+- **Embeddings**: BAAI/bge-small-en-v1.5 
+- **Agent**: LlamaIndex AgentWorkflow
+- **Interface**: Gradio web app
+
+## Setup
+
+The Space needs either:
+- `OPENAI_API_KEY` (recommended for better performance)
+- `HF_TOKEN` (free fallback option)
+
+Set these in the Space's Repository secrets.
+
+---
+

app.py

@@ -1,27 +1,14 @@
 """
-app.py - GAIA Benchmark Agent Application
+My GAIA Benchmark Agent - Final Course Project
 
-This is the main application file that brings together:
-1. Tools from tools.py (web search, calculator, file analysis)
-2. RAG system from retriever.py (guest database)
-3. LLM integration with fallback options
-4. Agent workflow for handling GAIA questions
-5. Gradio interface for submission to the GAIA benchmark
+This is my attempt at building an agent that can pass the GAIA benchmark.
+I'm combining everything I learned in the course:
+- Tools (web search, calculator, file processing)
+- RAG with a persona database
+- Agent workflows from LlamaIndex
+- Gradio interface
 
-The goal is to achieve 30%+ score on GAIA benchmark questions to earn the course certificate.
-
-How it works:
-1. User logs in with HuggingFace account
-2. System fetches GAIA questions from the evaluation API
-3. Our agent processes each question using its tools
-4. Answers are submitted and scored
-5. Results are displayed with pass/fail status
-
-Key design decisions:
-- Modular architecture: tools and retriever in separate files
-- Robust error handling: graceful failures with logging
-- API key flexibility: OpenAI (best) or HuggingFace (fallback)
-- GAIA-optimized: focused on accuracy over speed
+Goal: Get 30%+ score to pass the course!
 """
 
 import os
@@ -30,679 +17,364 @@ import requests
 import pandas as pd
 import asyncio
 import logging
-from typing import List, Dict, Any, Optional
 
-# Setup comprehensive logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s'
-)
+# Set up logging so I can debug issues
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 logger = logging.getLogger(__name__)
 
-# ============================================================================
-# CONSTANTS AND CONFIGURATION
-# ============================================================================
-
-# GAIA evaluation API endpoint
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
-
-# Required score to pass the course
-PASSING_SCORE = 30  # 30% minimum to earn certificate
+# Config stuff
+GAIA_API_URL = "https://agents-course-unit4-scoring.hf.space"
+PASSING_SCORE = 30  # Need this to get my certificate!
 
-# ============================================================================
-# LLM SETUP WITH FALLBACK OPTIONS
-# ============================================================================
-
-def create_llm():
+def setup_llm():
     """
-    Create an LLM (Large Language Model) with fallback options.
-    
-    Priority order:
-    1. OpenAI GPT-4 (best performance for GAIA)
-    2. HuggingFace Qwen model (free alternative)
-    
-    Why this order:
-    - OpenAI models generally perform better on GAIA benchmark
-    - HuggingFace provides free alternative for those without OpenAI credits
-    - Fallback ensures the agent works regardless of available keys
-    
-    API Keys Setup:
-    - Go to your HuggingFace Space settings
-    - Add "Repository secrets"
-    - Set OPENAI_API_KEY (recommended) and/or HF_TOKEN
-    
-    Returns:
-        LLM: Configured language model ready for use
-        
-    Raises:
-        RuntimeError: If no API keys are available
+    Setting up the LLM - trying OpenAI first since it usually works better,
+    but falling back to HuggingFace if I don't have OpenAI credits
     """
-    logger.info("Initializing LLM with fallback options...")
+    logger.info("Setting up LLM...")
     
-    # Try OpenAI first (recommended for GAIA performance)
+    # Try OpenAI first (better performance but costs money)
     openai_key = os.getenv("OPENAI_API_KEY")
     if openai_key:
         try:
             from llama_index.llms.openai import OpenAI
-            
             llm = OpenAI(
                 api_key=openai_key,
-                model="gpt-4o-mini",  # Good balance of cost and performance
-                max_tokens=1024,      # Reasonable limit for GAIA answers
-                temperature=0.1       # Low temperature for more consistent, factual responses
+                model="gpt-4o-mini",  # Good balance of performance and cost
+                max_tokens=1024,
+                temperature=0.1  # Low temp for more consistent answers
             )
-            
-            logger.info("✅ Successfully initialized OpenAI LLM")
+            logger.info("Got OpenAI working!")
             return llm
-            
-        except ImportError:
-            logger.warning("❌ OpenAI library not available, trying HuggingFace...")
         except Exception as e:
-            logger.warning(f"❌ OpenAI initialization failed: {e}, trying HuggingFace...")
-    else:
-        logger.info("ℹ️ No OPENAI_API_KEY found, trying HuggingFace...")
+            logger.warning(f"OpenAI didn't work: {e}")
     
-    # Fallback to HuggingFace
+    # Fallback to HuggingFace (free but maybe not as good)
     hf_token = os.getenv("HF_TOKEN")
     if hf_token:
         try:
             from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
-            
             llm = HuggingFaceInferenceAPI(
-                model_name="Qwen/Qwen2.5-Coder-32B-Instruct",  # Good open-source model
+                model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
                 token=hf_token,
-                max_new_tokens=512,    # Limit for response length
-                temperature=0.1,       # Low temperature for consistency
-                context_window=8192    # Context window size
+                max_new_tokens=512,
+                temperature=0.1
             )
-            
-            logger.info("✅ Successfully initialized HuggingFace LLM")
+            logger.info("Using HuggingFace LLM")
             return llm
-            
-        except ImportError:
-            logger.error("❌ HuggingFace library not available")
         except Exception as e:
-            logger.error(f"❌ HuggingFace initialization failed: {e}")
-    else:
-        logger.info("ℹ️ No HF_TOKEN found")
+            logger.error(f"HuggingFace also failed: {e}")
     
-    # If we get here, no LLM could be initialized
-    error_msg = (
-        "No LLM could be initialized. Please set either:\n"
-        "- OPENAI_API_KEY (recommended for better GAIA performance)\n"
-        "- HF_TOKEN (free alternative)\n"
-        "In your HuggingFace Space settings → Repository secrets"
-    )
-    logger.error(error_msg)
-    raise RuntimeError(error_msg)
-
-
-# ============================================================================
-# GAIA AGENT CLASS - Main Agent Implementation
-# ============================================================================
+    # If we get here, nothing worked
+    raise RuntimeError("No LLM available! Need either OPENAI_API_KEY or HF_TOKEN")
 
-class GAIAAgent:
+class MyGAIAAgent:
     """
-    GAIA Benchmark Agent that combines course learning with benchmark capabilities.
-    
-    This agent demonstrates:
-    1. Multi-tool usage (web search, calculator, file analysis)
-    2. RAG implementation (guest database from course)
-    3. LLM integration with robust error handling
-    4. GAIA-optimized prompting for accurate answers
-    
-    The agent is designed to handle various types of GAIA questions:
-    - Factual questions requiring web search
-    - Mathematical problems requiring calculations
-    - Data analysis questions requiring file processing
-    - Questions about the guest database (demonstrating RAG)
+    This is my main agent class. It brings together the LLM, tools, and 
+    the agent workflow from the course.
     """
     
     def __init__(self):
-        """
-        Initialize the GAIA agent with LLM and tools.
+        logger.info("Building my GAIA agent...")
         
-        This sets up:
-        1. The language model (with fallback options)
-        2. All available tools (web search, calculator, etc.)
-        3. The agent workflow that orchestrates everything
-        """
-        logger.info("🚀 Initializing GAIA Agent...")
+        # Step 1: Get the LLM working
+        self.llm = setup_llm()
         
-        # Step 1: Initialize the LLM
-        try:
-            self.llm = create_llm()
-            logger.info("✅ LLM initialized successfully")
-        except Exception as e:
-            logger.error(f"❌ Failed to initialize LLM: {e}")
-            raise
+        # Step 2: Load my tools
+        from tools import get_my_tools
+        self.tools = get_my_tools(self.llm)  # Pass LLM so all tools use same one
         
-        # Step 2: Import and create tools
-        tools = []
+        if not self.tools:
+            raise RuntimeError("No tools loaded! Check tools.py")
         
-        # Import tools from our tools.py file
-        try:
-            from tools import get_all_tools
-            tool_list = get_all_tools()
-            tools.extend(tool_list)
-            logger.info(f"✅ Loaded {len(tool_list)} tools from tools.py")
-        except ImportError as e:
-            logger.error(f"❌ Could not import tools.py: {e}")
-        except Exception as e:
-            logger.warning(f"⚠️ Error loading tools from tools.py: {e}")
-        
-        # Check if we have any tools
-        if not tools:
-            error_msg = "❌ No tools available! Check tools.py and retriever.py"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
+        logger.info(f"Loaded {len(self.tools)} tools:")
+        for tool in self.tools:
+            logger.info(f"  - {tool.metadata.name}")
         
-        logger.info(f"✅ Total tools available: {len(tools)}")
-        for tool in tools:
-            logger.info(f"   - {tool.metadata.name}: {tool.metadata.description[:50]}...")
+        # Step 3: Create the agent using the workflow pattern from class
+        from llama_index.core.agent.workflow import AgentWorkflow
         
-        # Step 3: Create the agent using AgentWorkflow (course approach)
-        try:
-            from llama_index.core.agent.workflow import AgentWorkflow, ToolCallResult, AgentStream
-            
-            # Create the agent with a GAIA-optimized system prompt (exactly like course)
-            self.agent = AgentWorkflow.from_tools_or_functions(
-                tools_or_functions=tools,
-                llm=self.llm,
-                system_prompt=self._create_system_prompt()
-            )
-            
-            logger.info("✅ AgentWorkflow created successfully")
-            
-        except ImportError as e:
-            error_msg = f"❌ Could not import AgentWorkflow: {e}"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
-        except Exception as e:
-            error_msg = f"❌ Failed to create agent workflow: {e}"
-            logger.error(error_msg)
-            raise RuntimeError(error_msg)
+        self.agent = AgentWorkflow.from_tools_or_functions(
+            tools_or_functions=self.tools,
+            llm=self.llm,
+            system_prompt=self._get_system_prompt()
+        )
         
-        logger.info("🎉 GAIA Agent initialization complete!")
+        logger.info("Agent ready to go!")
     
-    def _create_system_prompt(self) -> str:
+    def _get_system_prompt(self):
         """
-        Create a system prompt optimized for GAIA benchmark performance.
-        
-        The prompt is designed to:
-        1. Encourage accuracy over creativity
-        2. Guide proper tool usage
-        3. Ensure concise, direct answers
-        4. Handle various question types
-        
-        Returns:
-            str: Optimized system prompt for GAIA questions
+        My system prompt - trying to make it good for GAIA questions
         """
-        return """You are a helpful AI assistant specialized in answering questions accurately and concisely.
-
-            IMPORTANT - GAIA BENCHMARK GUIDELINES:
-            - Provide direct, factual answers without extra explanations
-            - Use your tools when you need specific information or calculations
-            - Be precise and accurate - exact matches are required for scoring
-            - If you're not certain about an answer, use available tools to verify
-
-            AVAILABLE TOOLS AND WHEN TO USE THEM:
-            1. web_search: Use for current information, recent events, facts not in your training data
-            2. calculator: Use for ANY mathematical calculations to ensure accuracy
-            3. file_analyzer: Use when questions involve analyzing data files or documents
-            4. persona_database: Use for questions about people, characteristics, interests, professions
-            (Database contains 5000 diverse personas with various backgrounds and interests)
-
-            RESPONSE GUIDELINES:
-            - Give direct answers without phrases like "Based on my search..." or "According to..."
-            - For numerical answers, provide just the number or value
-            - For factual questions, provide just the fact
-            - For yes/no questions, answer yes or no clearly
-            - Always use tools for calculations rather than doing math in your head
+        return """You are my AI assistant for answering GAIA benchmark questions accurately.
 
-            EXAMPLES:
-            Question: "What is 15% of 847?"
-            Good: Use calculator tool, then respond with just the number
-            Bad: Try to calculate mentally and risk errors
+Key rules:
+- Give direct, precise answers (GAIA needs exact matches)
+- Use tools when you need current info or calculations  
+- Don't add extra explanations unless asked
+- For math problems, always use the calculator tool
+- For current events, use web search
 
-            Question: "Who is the current president of France?"
-            Good: Use web search to get current information
-            Bad: Guess based on training data that might be outdated
+Available tools:
+- web_search: for current information and facts
+- calculator: for any math calculations  
+- file_analyzer: for processing data files
+- persona_database: database of different people and their interests
 
-            Remember: Accuracy is more important than speed. Use your tools to ensure correct answers."""
+Be accurate above all else - that's how I pass this course!"""
     
-    def __call__(self, question: str) -> str:
+    def answer_question(self, question):
         """
-        Process a GAIA question and return an answer using course approach.
-        
-        This follows the exact pattern from the course notebook:
-        1. Run the agent to get a handler
-        2. Stream events asynchronously  
-        3. Extract the final response
-        4. Clean and return the answer
-        
-        Args:
-            question (str): The GAIA question to answer
-            
-        Returns:
-            str: The agent's answer to the question
+        Main function to answer a GAIA question
         """
-        logger.info(f"📝 Processing GAIA question: {question[:100]}...")
+        logger.info(f"Got question: {question[:100]}...")
         
         try:
-            # Import event types for processing
+            # Import the event types for processing
             from llama_index.core.agent.workflow import ToolCallResult, AgentStream
             
-            # Run the agent asynchronously following course pattern
+            # Run the agent (this is the async pattern from the course)
             loop = asyncio.new_event_loop()
             asyncio.set_event_loop(loop)
             
             try:
                 async def run_agent():
-                    # Start the agent run (course pattern)
                     handler = self.agent.run(user_msg=question)
                     
-                    # Stream events and collect reasoning (optional for debugging)
-                    reasoning_steps = []
-                    async for ev in handler.stream_events():
-                        if isinstance(ev, ToolCallResult):
-                            step = f"Tool: {ev.tool_name}({ev.tool_kwargs}) => {ev.tool_output}"
-                            reasoning_steps.append(step)
-                            logger.info(f"🔧 {step}")
-                        elif isinstance(ev, AgentStream):
-                            # This is the agent's thought process
-                            pass  # We could log this for debugging
+                    # Watch what the agent does (helpful for debugging)
+                    async for event in handler.stream_events():
+                        if isinstance(event, ToolCallResult):
+                            logger.info(f"Used tool: {event.tool_name} -> {str(event.tool_output)[:100]}...")
                     
-                    # Get the final response
-                    resp = await handler
-                    return resp
+                    result = await handler
+                    return result
                 
-                # Execute the agent
                 result = loop.run_until_complete(run_agent())
                 
-                # Extract the response from the result object
-                answer = self._extract_response(result)
+                # Extract the actual answer from the result
+                answer = self._extract_answer(result)
+                answer = self._clean_answer(answer)
                 
-                # Clean and format the answer for GAIA submission
-                cleaned_answer = self._clean_answer(answer)
-                
-                logger.info(f"✅ Generated answer: {cleaned_answer[:100]}...")
-                return cleaned_answer
+                logger.info(f"My answer: {answer[:100]}...")
+                return answer
                 
             finally:
-                # Always close the event loop to prevent memory leaks
                 loop.close()
                 
         except Exception as e:
-            # If anything goes wrong, return a helpful error message
-            error_msg = f"I encountered an error processing this question: {str(e)}"
-            logger.error(f"❌ Error processing question: {e}")
+            error_msg = f"Something went wrong: {str(e)}"
+            logger.error(error_msg)
             return error_msg
     
-    def _extract_response(self, result: Any) -> str:
+    def _extract_answer(self, result):
         """
-        Extract the text response from the AgentWorkflow result.
-        
-        Based on the course notebook, AgentWorkflow returns an AgentOutput with this structure:
-        AgentOutput(response=ChatMessage(...), tool_calls=[], raw={...})
-        
-        Args:
-            result: The result object from the agent workflow
-            
-        Returns:
-            str: Extracted response text
+        Extract the text from the agent result - this took me a while to figure out
         """
         try:
-            # Handle AgentOutput format from course (most likely)
-            if hasattr(result, 'response'):
-                chat_message = result.response
-                if hasattr(chat_message, 'blocks'):
-                    # Extract text from TextBlock(s)
-                    for block in chat_message.blocks:
-                        if hasattr(block, 'text'):
-                            return str(block.text)
-                elif hasattr(chat_message, 'content'):
-                    return str(chat_message.content)
-                else:
-                    return str(chat_message)
+            # The result has a response with blocks containing text
+            if hasattr(result, 'response') and hasattr(result.response, 'blocks'):
+                for block in result.response.blocks:
+                    if hasattr(block, 'text'):
+                        return str(block.text)
             
-            # Fallback to other common formats
+            # Fallback methods if the structure is different
+            if hasattr(result, 'response'):
+                return str(result.response)
             elif hasattr(result, 'content'):
                 return str(result.content)
-            elif hasattr(result, 'message'):
-                if hasattr(result.message, 'content'):
-                    return str(result.message.content)
-                else:
-                    return str(result.message)
             else:
-                # Final fallback: convert whatever we got to string
                 return str(result)
-                
-        except Exception as e:
-            logger.warning(f"⚠️ Error extracting response: {e}")
-            # If extraction fails, try simple string conversion
+        except:
             return str(result)
     
-    def _clean_answer(self, answer: str) -> str:
+    def _clean_answer(self, answer):
         """
-        Clean and format the answer for GAIA submission.
-        
-        GAIA requires exact matches, so we need to:
-        1. Remove common prefixes that agents add
-        2. Strip whitespace
-        3. Ensure clean, direct responses
-        
-        Args:
-            answer (str): Raw answer from the agent
-            
-        Returns:
-            str: Cleaned answer ready for submission
+        Clean up the answer - remove common prefixes that agents add
         """
-        # Remove common agent response prefixes
+        # Remove stuff like "Based on my search" etc.
         prefixes_to_remove = [
-            "assistant:",
-            "Assistant:",
-            "Based on my search,",
-            "According to the search results,",
-            "The answer is:",
-            "Answer:"
+            "assistant:", "Assistant:", "Based on my search,", 
+            "According to the search results,", "The answer is:", "Answer:"
         ]
         
         cleaned = answer.strip()
-        
         for prefix in prefixes_to_remove:
             if cleaned.startswith(prefix):
                 cleaned = cleaned[len(prefix):].strip()
         
         return cleaned
 
-
-# ============================================================================
-# EVALUATION AND SUBMISSION LOGIC
-# ============================================================================
-
-def run_and_submit_all(profile: gr.OAuthProfile | None) -> tuple[str, pd.DataFrame]:
+def run_gaia_evaluation(profile):
     """
-    Main function that handles the entire GAIA evaluation process.
-    
-    This function:
-    1. Validates user authentication
-    2. Fetches questions from GAIA API
-    3. Runs the agent on all questions
-    4. Submits answers for scoring
-    5. Returns results and status
-    
-    Args:
-        profile: Gradio OAuth profile (None if not logged in)
-        
-    Returns:
-        tuple: (status_message, results_dataframe)
+    This is the main function that runs when someone clicks the button.
+    It fetches questions from GAIA, runs my agent on them, and submits results.
     """
-    # Step 1: Check authentication
     if not profile:
-        logger.warning("❌ User not logged in")
-        return "Please log in to HuggingFace using the button above.", None
+        return "Need to log in with HuggingFace first!", None
     
     username = profile.username
-    logger.info(f"👤 User logged in: {username}")
+    logger.info(f"Running evaluation for {username}")
     
-    # Step 2: Get space information for code link
+    # Get the space info for submission
     space_id = os.getenv("SPACE_ID")
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "No space ID available"
+    code_link = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "No space ID"
     
-    # Step 3: Set up API endpoints
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
-    
-    # Step 4: Initialize the agent
-    logger.info("🤖 Initializing GAIA Agent...")
+    # Initialize my agent
     try:
-        agent = GAIAAgent()
-        logger.info("✅ GAIA Agent ready for evaluation")
+        agent = MyGAIAAgent()
     except Exception as e:
-        error_msg = f"❌ Failed to initialize agent: {str(e)}"
-        logger.error(error_msg)
-        return error_msg, None
+        return f"Failed to create agent: {e}", None
     
-    # Step 5: Fetch GAIA questions
-    logger.info(f"📥 Fetching questions from: {questions_url}")
+    # Fetch the questions
     try:
-        response = requests.get(questions_url, timeout=15)
+        logger.info("Getting questions from GAIA...")
+        response = requests.get(f"{GAIA_API_URL}/questions", timeout=15)
         response.raise_for_status()
-        questions_data = response.json()
-        
-        if not questions_data:
-            return "❌ No questions received from GAIA API", None
+        questions = response.json()
         
-        logger.info(f"✅ Fetched {len(questions_data)} GAIA questions")
+        if not questions:
+            return "No questions received!", None
+            
+        logger.info(f"Got {len(questions)} questions to answer")
         
-    except requests.exceptions.RequestException as e:
-        error_msg = f"❌ Network error fetching questions: {str(e)}"
-        logger.error(error_msg)
-        return error_msg, None
     except Exception as e:
-        error_msg = f"❌ Error processing questions: {str(e)}"
-        logger.error(error_msg)
-        return error_msg, None
+        return f"Failed to get questions: {e}", None
     
-    # Step 6: Process all questions
-    logger.info(f"🧠 Running agent on {len(questions_data)} questions...")
-    results_log = []
-    answers_payload = []
+    # Answer all the questions
+    results = []
+    answers_for_submission = []
     
-    for i, item in enumerate(questions_data, 1):
+    for i, item in enumerate(questions, 1):
         task_id = item.get("task_id")
         question_text = item.get("question")
         
-        if not task_id or question_text is None:
-            logger.warning(f"⚠️ Skipping invalid question item: {item}")
+        if not task_id or not question_text:
             continue
-        
-        logger.info(f"📝 Processing question {i}/{len(questions_data)}: {task_id}")
+            
+        logger.info(f"Question {i}/{len(questions)}: {task_id}")
         
         try:
-            # Run the agent on this question
-            submitted_answer = agent(question_text)
+            answer = agent.answer_question(question_text)
             
             # Store for submission
-            answers_payload.append({
+            answers_for_submission.append({
                 "task_id": task_id,
-                "submitted_answer": submitted_answer
+                "submitted_answer": answer
             })
             
-            # Store for display (truncated for readability)
-            results_log.append({
+            # Store for display (truncated)
+            results.append({
                 "Task ID": task_id,
                 "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                "Answer": submitted_answer[:150] + "..." if len(submitted_answer) > 150 else submitted_answer
+                "My Answer": answer[:150] + "..." if len(answer) > 150 else answer
             })
             
-            logger.info(f"✅ Question {i} completed")
-            
         except Exception as e:
             error_answer = f"ERROR: {str(e)}"
-            logger.error(f"❌ Error on question {i}: {e}")
-            
-            answers_payload.append({
+            answers_for_submission.append({
                 "task_id": task_id,
                 "submitted_answer": error_answer
             })
-            
-            results_log.append({
+            results.append({
                 "Task ID": task_id,
                 "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
-                "Answer": error_answer
+                "My Answer": error_answer
             })
     
-    if not answers_payload:
-        return "❌ No answers generated for submission", pd.DataFrame(results_log)
-    
-    # Step 7: Submit answers to GAIA API
-    logger.info(f"📤 Submitting {len(answers_payload)} answers...")
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload
-    }
-    
+    # Submit my answers
     try:
-        response = requests.post(submit_url, json=submission_data, timeout=60)
+        logger.info(f"Submitting {len(answers_for_submission)} answers...")
+        
+        submission = {
+            "username": username,
+            "agent_code": code_link,
+            "answers": answers_for_submission
+        }
+        
+        response = requests.post(f"{GAIA_API_URL}/submit", json=submission, timeout=60)
         response.raise_for_status()
         result_data = response.json()
         
-        # Extract results
+        # Get my score!
         score = result_data.get('score', 0)
-        correct_count = result_data.get('correct_count', 0)
-        total_attempted = result_data.get('total_attempted', len(answers_payload))
+        correct = result_data.get('correct_count', 0)
+        total = result_data.get('total_attempted', len(answers_for_submission))
         
-        # Determine pass/fail status
+        # Did I pass?
         passed = score >= PASSING_SCORE
-        status_emoji = "🎉" if passed else "📊"
+        emoji = "🎉" if passed else "😔"
         
-        # Create status message
-        final_status = (
-            f"{status_emoji} GAIA Evaluation Results\n"
-            f"User: {username}\n"
-            f"Score: {score}% ({correct_count}/{total_attempted} correct)\n"
-            f"Required: {PASSING_SCORE}% to pass\n"
-            f"Status: {'✅ PASSED - Certificate Earned!' if passed else '❌ Not passed - Try again!'}\n"
-            f"Message: {result_data.get('message', 'Evaluation completed')}"
-        )
+        status_message = f"""{emoji} GAIA Results for {username}
+
+Score: {score}% ({correct}/{total} correct)
+Required to pass: {PASSING_SCORE}%
+
+{'🎊 PASSED! I got my certificate!' if passed else '😞 Not quite... need to try again'}
+
+{result_data.get('message', 'Evaluation complete')}"""
         
-        logger.info(f"✅ Submission successful - Score: {score}%")
-        return final_status, pd.DataFrame(results_log)
+        logger.info(f"Final score: {score}%")
+        return status_message, pd.DataFrame(results)
         
-    except requests.exceptions.RequestException as e:
-        error_msg = f"❌ Submission failed: {str(e)}"
-        logger.error(error_msg)
-        return error_msg, pd.DataFrame(results_log)
     except Exception as e:
-        error_msg = f"❌ Unexpected error during submission: {str(e)}"
-        logger.error(error_msg)
-        return error_msg, pd.DataFrame(results_log)
-
-
-# ============================================================================
-# GRADIO INTERFACE
-# ============================================================================
+        return f"Submission failed: {e}", pd.DataFrame(results)
 
 # Create the Gradio interface
-with gr.Blocks(title="GAIA Benchmark Agent") as demo:
-    # Header and instructions
-    gr.Markdown("# 🎯 GAIA Benchmark Agent - Course Final Project")
-    
+with gr.Blocks(title="My GAIA Agent") as demo:
+    gr.Markdown("# 🤖 My GAIA Benchmark Agent")
     gr.Markdown("""
-    ## 🚀 Welcome to Your Final Challenge!
-    
-    This agent combines everything you've learned in the course:
-    - **🔧 Multi-Tool Integration**: Web search, calculator, file analysis
-    - **📚 RAG Implementation**: Persona database with 5K diverse individuals
-    - **🤖 Agent Workflows**: LlamaIndex agent orchestration
-    - **🎯 GAIA Optimization**: Designed for benchmark performance
-    
-    ### 📋 Setup Checklist:
-    1. **🔑 API Keys**: Set `OPENAI_API_KEY` or `HF_TOKEN` in Space secrets
-    2. **🔓 Public Space**: Keep your space public for verification
-    3. **👤 Login**: Use the HuggingFace login button below
-    4. **▶️ Run**: Click the evaluation button and wait for results
+    This is my final project for the AI Agents course! 
     
-    ### 🏆 Goal: Score 30%+ to earn your certificate!
+    My agent can:
+    - 🔍 Search the web for current information
+    - 🧮 Do mathematical calculations  
+    - 📊 Analyze data files
+    - 👥 Query a database of personas
     
-    ---
+    **Goal:** Score 30%+ on GAIA benchmark to pass the course!
     """)
     
-    # Login section
-    gr.Markdown("### Step 1: Login to HuggingFace")
+    gr.Markdown("### Step 1: Login")
     gr.LoginButton()
     
-    # Evaluation section
-    gr.Markdown("### Step 2: Run GAIA Evaluation")
-    gr.Markdown("⚠️ **Note**: This may take 5-10 minutes to complete all questions. Please be patient!")
+    gr.Markdown("### Step 2: Run the Evaluation")
+    gr.Markdown("⏰ This might take 5-10 minutes...")
     
-    run_button = gr.Button(
-        "🚀 Run GAIA Evaluation & Submit Results",
-        variant="primary",
-        size="lg"
-    )
+    run_btn = gr.Button("🚀 Run GAIA Evaluation", variant="primary", size="lg")
     
-    # Results section
-    gr.Markdown("### Step 3: View Results")
+    gr.Markdown("### Step 3: Results")
     
-    status_output = gr.Textbox(
-        label="📊 Evaluation Status & Results",
-        lines=8,
+    status_text = gr.Textbox(
+        label="📊 My Results",
+        lines=10,
         interactive=False,
-        placeholder="Results will appear here after evaluation..."
-    )
-    
-    results_table = gr.DataFrame(
-        label="📝 Question-by-Question Results",
-        wrap=True
+        placeholder="Results will show here..."
     )
     
-    # Wire up the interface
-    run_button.click(
-        fn=run_and_submit_all,
-        outputs=[status_output, results_table]
-    )
+    results_df = gr.DataFrame(label="📝 Question by Question Results")
     
-    # Footer
-    gr.Markdown("""
-    ---
-    ### 🔧 Troubleshooting:
-    - **No API Key Error**: Add `OPENAI_API_KEY` or `HF_TOKEN` to your Space secrets
-    - **Import Errors**: Check that all dependencies are installed
-    - **Low Score**: GAIA requires exact answers - the agent uses tools for accuracy
+    # Connect the button
+    run_btn.click(fn=run_gaia_evaluation, outputs=[status_text, results_df])
     
-    ### 🏅 Good luck earning your certificate!
-    """)
-
-
-# ============================================================================
-# MAIN EXECUTION
-# ============================================================================
+    gr.Markdown("---")
+    gr.Markdown("🤞 Fingers crossed I pass this course!")
 
 if __name__ == "__main__":
-    print("\n" + "="*60)
-    print("🎯 GAIA BENCHMARK AGENT - Course Final Project")
-    print("="*60)
-    
-    # Check environment setup
-    print("\n🔍 Environment Check:")
+    print("🎯 My GAIA Agent - Final Course Project")
+    print("=" * 50)
     
-    space_host = os.getenv("SPACE_HOST")
-    space_id = os.getenv("SPACE_ID")
+    # Check my environment
     openai_key = os.getenv("OPENAI_API_KEY")
     hf_token = os.getenv("HF_TOKEN")
     
-    if space_host:
-        print(f"✅ SPACE_HOST: {space_host}")
-    if space_id:
-        print(f"✅ SPACE_ID: {space_id}")
     if openai_key:
-        print("✅ OPENAI_API_KEY: Set")
+        print("✅ OpenAI key found")
     if hf_token:
-        print("✅ HF_TOKEN: Set")
-    
+        print("✅ HuggingFace token found")
     if not openai_key and not hf_token:
-        print("⚠️  WARNING: No API keys found!")
-        print("   Please set OPENAI_API_KEY or HF_TOKEN in Space secrets")
-    
-    print(f"\n🎯 Target Score: {PASSING_SCORE}% (to earn certificate)")
-    print("🚀 Agent Features:")
-    print("   - Web Search (DuckDuckGo)")
-    print("   - Calculator (Math operations)")
-    print("   - Guest Database RAG (Course demo)")
-    print("   - File Analysis (Data processing)")
+        print("⚠️ No API keys! Add OPENAI_API_KEY or HF_TOKEN to secrets")
     
-    print("\n" + "="*60)
-    print("🌐 Launching Gradio Interface...")
-    print("="*60 + "\n")
+    print(f"🎯 Need {PASSING_SCORE}% to pass the course")
+    print("🚀 Starting my agent...")
     
-    # Launch the Gradio app
-    demo.launch(
-        debug=True,
-        share=False,
-        show_error=True
-    )
+    demo.launch(debug=True, share=False, show_error=True)

requirements.txt

@@ -1,104 +1,32 @@
-# ============================================================================
-# GAIA Benchmark Agent - Requirements
-# ============================================================================
-# This file lists all the Python packages needed for the GAIA agent to work.
-# Each section explains what the packages are used for.
-
-# ============================================================================
-# CORE INTERFACE AND API DEPENDENCIES
-# ============================================================================
-# These are essential for the app to run and communicate with GAIA API
+# My GAIA Agent Requirements
+# These are all the packages I need for my final project
 
+# Basic stuff for the web interface
 gradio>=4.0.0
-# Web interface for the agent - provides the UI where users interact
-# Includes login functionality and result display
-
-requests>=2.28.0
-# For HTTP requests to the GAIA evaluation API
-# Used to fetch questions and submit answers
-
+requests>=2.28.0  
 pandas>=1.5.0
-# Data manipulation and display of results in tables
-# Used to show question-answer pairs in a nice format
-
-# ============================================================================
-# LLAMAINDEX CORE - The Foundation
-# ============================================================================
-# LlamaIndex is the main framework from the course
 
+# Main LlamaIndex stuff - this is the core framework we learned about
 llama-index-core>=0.10.0
-# Core LlamaIndex functionality - documents, nodes, retrievers, etc.
-# This is the foundation that everything else builds on
-
-# ============================================================================
-# LLM (Language Model) INTEGRATIONS
-# ============================================================================
-# These allow us to use different LLMs with fallback options
 
+# Different LLM options - trying both OpenAI and HuggingFace
 llama-index-llms-openai
-# OpenAI integration (GPT-4, GPT-3.5) - recommended for best GAIA performance
-# Requires OPENAI_API_KEY in your Space secrets
-
 llama-index-llms-huggingface-api
-# HuggingFace Inference API integration - free alternative
-# Uses models like Qwen/Qwen2.5-Coder-32B-Instruct
-# Requires HF_TOKEN in your Space secrets
-
-# ============================================================================
-# AGENT SYSTEM - Course Approach
-# ============================================================================
-# AgentWorkflow is part of llama-index-core, no separate package needed
-# This matches exactly what the course notebook uses
-
-# ============================================================================
-# RETRIEVAL SYSTEMS (RAG) - Enhanced with Vector Embeddings
-# ============================================================================
-# These are for the advanced RAG (Retrieval-Augmented Generation) functionality
 
+# For the RAG part with embeddings and vector search
 llama-index-retrievers-bm25
-# BM25 retriever for keyword-based search (still useful as fallback)
-# Great for finding exact matches and proper nouns
-
 llama-index-embeddings-huggingface
-# HuggingFace embedding models for semantic search
-# Converts text to vectors that capture meaning and context
-# Used with BAAI/bge-small-en-v1.5 model
-
 llama-index-vector-stores-chroma
-# ChromaDB vector store integration
-# Provides persistent storage for vector embeddings
-# Fast similarity search for semantic retrieval
 
+# Vector database - using ChromaDB like in the course
 chromadb>=0.4.0
-# ChromaDB database for vector storage
-# Self-contained vector database with no external dependencies
-# Stores embeddings locally for fast retrieval
 
+# To load the persona dataset from HuggingFace
 datasets>=2.0.0
-# HuggingFace datasets library
-# Used to load the finepersonas dataset
-# Provides easy access to thousands of datasets
-
-# ============================================================================
-# TOOLS AND EXTERNAL SERVICES
-# ============================================================================
-# These packages enable the agent's tools
 
+# Web search tool
 duckduckgo-search>=6.0.0
-# Web search functionality using DuckDuckGo
-# Essential for GAIA questions requiring current information
-# Free alternative to Google Search API
-
-# ============================================================================
-# UTILITIES AND ENVIRONMENT
-# ============================================================================
-# Supporting packages for configuration and development
 
+# Helper packages
 python-dotenv
-# For loading environment variables from .env files
-# Useful for local development and testing
-
-nest-asyncio
-# Allows running async code in environments that already have an event loop
-# Required for running LlamaIndex query engines in Jupyter/Gradio
-# Fixes "RuntimeError: This event loop is already running" errors
+nest-asyncio

retriever.py

@@ -1,526 +1,341 @@
 """
-retriever.py - Advanced RAG Implementation with Personas Database
+My Persona Database - RAG Implementation
 
-This file implements an advanced RAG system using:
-1. Real dataset from HuggingFace (dvilasuero/finepersonas-v0.1-tiny)
-2. Vector embeddings for semantic search
-3. ChromaDB for persistent vector storage
-4. LlamaIndex IngestionPipeline for processing
+This is where I build my persona database using what I learned about RAG.
+I'm using:
+- HuggingFace dataset with persona descriptions
+- ChromaDB for vector storage (learned this is good for small projects)
+- Embeddings to find similar personas
+- LlamaIndex to tie it all together
 
-This demonstrates advanced course concepts:
-- Dataset integration from HuggingFace
-- Vector embeddings vs keyword search
-- Persistent storage with ChromaDB
-- Ingestion pipelines for data processing
+The goal is to have a database I can query like "find me creative people" 
+and get back actual persona descriptions.
 
-Why this approach:
-- 5K personas provide rich, diverse data
-- Vector embeddings capture semantic meaning
-- ChromaDB provides fast, persistent storage
-- More realistic than simple guest database
-
-download_and_prepare_personas()   # Download 5K personas
-load_persona_documents()          # Load into documents  
-create_persona_index()            # Create vector index
-get_persona_query_engine()        # For tools.py to use
+Note: I made this work in HuggingFace Spaces by keeping everything in memory
+and using a smaller dataset so it doesn't crash.
 """
 
 import logging
 import os
-from typing import List, Dict, Any
+from typing import List, Optional
 from pathlib import Path
 
-# LlamaIndex core components
+# Core LlamaIndex stuff
 from llama_index.core.schema import Document
-from llama_index.core.tools import FunctionTool, QueryEngineTool
-from llama_index.core import SimpleDirectoryReader, VectorStoreIndex
+from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
 from llama_index.core.node_parser import SentenceSplitter
-from llama_index.core.ingestion import IngestionPipeline
 
-# Embeddings and vector store
+# For embeddings and vector storage
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
 from llama_index.vector_stores.chroma import ChromaVectorStore
 
-# External libraries
-from datasets import load_dataset
-import chromadb
-
-# Setup logging
-logger = logging.getLogger(__name__)
-
-# ============================================================================
-# CONFIGURATION AND CONSTANTS
-# ============================================================================
+# External stuff
+try:
+    from datasets import load_dataset
+    CAN_LOAD_DATASETS = True
+except ImportError:
+    CAN_LOAD_DATASETS = False
 
-# Dataset configuration
-DATASET_NAME = "dvilasuero/finepersonas-v0.1-tiny"
-DATA_DIR = Path("data")
-CHROMA_DB_PATH = "./alfred_chroma_db"
-COLLECTION_NAME = "alfred"
+try:
+    import chromadb
+    CHROMADB_WORKS = True
+except ImportError:
+    CHROMADB_WORKS = False
 
-# Embedding model - good balance of performance and speed
-EMBEDDING_MODEL = "BAAI/bge-small-en-v1.5"
+logger = logging.getLogger(__name__)
 
-# Chunk size for text splitting - optimal for personas
-CHUNK_SIZE = 1024
-CHUNK_OVERLAP = 20
+# My settings
+PERSONA_DATASET = "dvilasuero/finepersonas-v0.1-tiny"
+MAX_PERSONAS = 300  # Keep it small for HF Spaces
+EMBEDDING_MODEL = "BAAI/bge-small-en-v1.5"  # This one works well
+CHUNK_SIZE = 400  # Smaller chunks work better
 
-# ============================================================================
-# DATA PREPARATION - Loading Personas from HuggingFace
-# ============================================================================
+# Cache so I don't rebuild this every time
+_my_persona_index = None
 
-def download_and_prepare_personas() -> int:
+def make_sample_personas():
     """
-    Download personas from HuggingFace and save as individual text files.
-    
-    This approach demonstrates:
-    1. Dataset integration from HuggingFace Hub
-    2. Local file preparation for SimpleDirectoryReader
-    3. Data persistence for repeated runs
-    
-    Why save as files:
-    - SimpleDirectoryReader expects file-based input
-    - Allows for easy inspection and debugging
-    - Caches data locally to avoid repeated downloads
-    - Mimics real-world scenario where you have document files
-    
-    Returns:
-        int: Number of persona files created
+    Backup personas in case I can't download the real dataset
+    These are just examples but at least my agent will work
     """
-    logger.info(f"Starting persona data preparation...")
-    
-    # Create data directory if it doesn't exist
-    DATA_DIR.mkdir(parents=True, exist_ok=True)
-    
-    # Check if we already have data (avoid re-downloading)
-    existing_files = list(DATA_DIR.glob("persona_*.txt"))
-    if existing_files:
-        logger.info(f"Found {len(existing_files)} existing persona files, skipping download")
-        return len(existing_files)
-    
-    try:
-        # Load the dataset from HuggingFace
-        logger.info(f"Loading dataset: {DATASET_NAME}")
-        dataset = load_dataset(path=DATASET_NAME, split="train")
-        logger.info(f"Dataset loaded successfully with {len(dataset)} personas")
-        
-        # Save each persona as a separate text file
-        personas_created = 0
-        for i, persona_data in enumerate(dataset):
-            persona_file = DATA_DIR / f"persona_{i}.txt"
-            
-            # Extract the persona text
-            persona_text = persona_data["persona"]
-            
-            # Add some metadata to make the persona more searchable
-            enhanced_text = f"Persona {i}:\n{persona_text}"
-            
-            # Write to file
-            with open(persona_file, "w", encoding="utf-8") as f:
-                f.write(enhanced_text)
-            
-            personas_created += 1
-            
-            # Log progress for large datasets
-            if personas_created % 1000 == 0:
-                logger.info(f"Created {personas_created} persona files...")
-        
-        logger.info(f"✅ Successfully created {personas_created} persona files")
-        return personas_created
+    samples = [
+        "I'm a 28-year-old software developer from Seattle. I love hiking on weekends, coding in Python, and playing indie video games. I work at a tech startup and dream of building my own app someday.",
         
-    except Exception as e:
-        logger.error(f"❌ Error downloading personas: {e}")
-        raise RuntimeError(f"Failed to download personas: {e}")
-
-
-# ============================================================================
-# DOCUMENT LOADING - Converting Files to LlamaIndex Documents
-# ============================================================================
-
-def load_persona_documents() -> List[Document]:
-    """
-    Load persona files into LlamaIndex Document objects.
-    
-    This demonstrates:
-    1. SimpleDirectoryReader usage for file loading
-    2. Document object creation and metadata handling
-    3. Error handling for file operations
-    
-    Why SimpleDirectoryReader:
-    - Handles multiple file formats automatically
-    - Preserves file metadata (filename, path, etc.)
-    - Integrates seamlessly with LlamaIndex pipeline
-    - Scales well for large document collections
-    
-    Returns:
-        List[Document]: List of loaded persona documents
-    """
-    logger.info("Loading persona documents...")
-    
-    # Ensure we have persona data
-    if not DATA_DIR.exists() or not list(DATA_DIR.glob("persona_*.txt")):
-        logger.info("No persona files found, downloading...")
-        download_and_prepare_personas()
-    
-    try:
-        # Use SimpleDirectoryReader to load all text files
-        reader = SimpleDirectoryReader(input_dir=str(DATA_DIR))
-        documents = reader.load_data()
+        "I'm a 35-year-old high school teacher in Boston. I teach English literature and spend my free time writing poetry. I volunteer at the local animal shelter and love mystery novels.",
         
-        logger.info(f"✅ Loaded {len(documents)} persona documents")
+        "I'm a 42-year-old chef who owns a small Italian restaurant in Chicago. I learned to cook from my grandmother and love experimenting with fusion cuisine. I teach cooking classes on Sundays.",
         
-        # Log some statistics about the documents
-        if documents:
-            total_chars = sum(len(doc.text) for doc in documents)
-            avg_chars = total_chars / len(documents)
-            logger.info(f"Average document length: {avg_chars:.0f} characters")
+        "I'm a 24-year-old graphic designer in Los Angeles. I freelance for indie game studios and love creating digital art. My hobbies include skateboarding and visiting coffee shops for inspiration.",
         
-        return documents
+        "I'm a 39-year-old veterinarian in Denver. I specialize in wildlife rehabilitation and spend weekends hiking in the mountains. I volunteer at the local zoo and love photography.",
         
-    except Exception as e:
-        logger.error(f"❌ Error loading documents: {e}")
-        raise RuntimeError(f"Failed to load persona documents: {e}")
-
-
-# ============================================================================
-# VECTOR STORE SETUP - ChromaDB Configuration
-# ============================================================================
+        "I'm a 31-year-old journalist in New York covering tech trends. I write a weekly newsletter about AI and automation. I practice yoga daily and love exploring the city's food scene.",
+        
+        "I'm a 45-year-old musician who plays guitar in a blues band. I teach music lessons during the day and perform at local venues on weekends. I collect vintage vinyl records.",
+        
+        "I'm a 27-year-old marine biologist studying coral reefs in San Diego. I love scuba diving and underwater photography. I'm passionate about ocean conservation and climate change.",
+        
+        "I'm a 33-year-old architect designing sustainable buildings in Portland. I believe in green construction and volunteer for Habitat for Humanity. I enjoy urban sketching.",
+        
+        "I'm a 29-year-old data scientist working in healthcare analytics in Austin. I love solving puzzles and play chess competitively. I brew craft beer as a hobby."
+    ]
+    
+    logger.info(f"Created {len(samples)} backup personas")
+    return samples
 
-def setup_chroma_vector_store():
+def download_personas():
     """
-    Set up ChromaDB vector store for persistent storage.
-    
-    This demonstrates:
-    1. Persistent vector database configuration
-    2. Collection management
-    3. Integration with LlamaIndex vector stores
-    
-    Why ChromaDB:
-    - Persistent storage (survives application restarts)
-    - Fast vector similarity search
-    - Easy integration with LlamaIndex
-    - Good for development and production
-    - No external dependencies (self-contained)
-    
-    Returns:
-        ChromaVectorStore: Configured vector store ready for use
+    Try to get the real persona dataset from HuggingFace
+    If that fails, use my backup personas
     """
-    logger.info("Setting up ChromaDB vector store...")
+    logger.info("Trying to download persona dataset...")
+    
+    if not CAN_LOAD_DATASETS:
+        logger.warning("Can't load datasets library, using backups")
+        return make_sample_personas()
     
     try:
-        # Create persistent ChromaDB client
-        # This creates a local database that persists between runs
-        db = chromadb.PersistentClient(path=CHROMA_DB_PATH)
-        logger.info(f"ChromaDB client created at: {CHROMA_DB_PATH}")
-        
-        # Get or create collection for our personas
-        # Collections are like tables in a traditional database
-        chroma_collection = db.get_or_create_collection(name=COLLECTION_NAME)
-        logger.info(f"Using collection: {COLLECTION_NAME}")
+        # Load the dataset (streaming to save memory)
+        dataset = load_dataset(PERSONA_DATASET, split="train", streaming=True)
         
-        # Wrap ChromaDB collection in LlamaIndex vector store
-        vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
+        personas = []
+        for i, item in enumerate(dataset):
+            if i >= MAX_PERSONAS:  # Don't go over my limit
+                break
+                
+            persona_text = item.get("persona", "")
+            if persona_text.strip():
+                personas.append(f"Person {i+1}: {persona_text}")
+                
+            if (i + 1) % 50 == 0:
+                logger.info(f"Downloaded {i+1} personas...")
         
-        logger.info("✅ ChromaDB vector store configured successfully")
-        return vector_store
+        logger.info(f"Got {len(personas)} personas from HuggingFace!")
+        return personas
         
     except Exception as e:
-        logger.error(f"❌ Error setting up ChromaDB: {e}")
-        raise RuntimeError(f"Failed to setup ChromaDB: {e}")
-
-
-# ============================================================================
-# INGESTION PIPELINE - Document Processing with Embeddings
-# ============================================================================
+        logger.warning(f"Download failed: {e}, using backups")
+        return make_sample_personas()
 
-def create_ingestion_pipeline(vector_store) -> IngestionPipeline:
+def make_documents(personas):
     """
-    Create an ingestion pipeline for processing persona documents.
-    
-    This demonstrates:
-    1. Text chunking with SentenceSplitter
-    2. Embedding generation with HuggingFace models
-    3. Pipeline composition for complex processing
-    
-    The pipeline does:
-    1. Split documents into smaller chunks (better for retrieval)
-    2. Generate vector embeddings for each chunk
-    3. Store embeddings in the vector database
-    
-    Why this approach:
-    - Chunking improves retrieval precision
-    - Embeddings capture semantic meaning
-    - Pipeline caches results for efficiency
-    - Modular design allows easy modification
-    
-    Args:
-        vector_store: ChromaDB vector store for persistence
-        
-    Returns:
-        IngestionPipeline: Configured pipeline ready for document processing
+    Turn my persona strings into LlamaIndex documents
     """
-    logger.info("Creating ingestion pipeline...")
+    logger.info(f"Making documents from {len(personas)} personas...")
+    
+    docs = []
+    for i, persona_text in enumerate(personas):
+        doc = Document(
+            text=persona_text,
+            metadata={
+                "source": f"persona_{i}",
+                "persona_id": i,
+                "type": "persona_description"
+            }
+        )
+        docs.append(doc)
     
+    logger.info(f"Created {len(docs)} documents")
+    return docs
+
+def setup_vector_store():
+    """
+    Set up ChromaDB for storing my vectors
+    Using in-memory so it works in HuggingFace Spaces
+    """
+    if not CHROMADB_WORKS:
+        logger.error("ChromaDB not available!")
+        return None
+        
     try:
-        # Create text splitter
-        # SentenceSplitter respects sentence boundaries for better coherence
-        text_splitter = SentenceSplitter(
-            chunk_size=CHUNK_SIZE,     # Max characters per chunk
-            chunk_overlap=CHUNK_OVERLAP  # Overlap to maintain context
-        )
-        logger.info(f"Text splitter configured: {CHUNK_SIZE} chars, {CHUNK_OVERLAP} overlap")
+        logger.info("Setting up in-memory vector store...")
         
-        # Create embedding model
-        # This model converts text to numerical vectors that capture meaning
-        embed_model = HuggingFaceEmbedding(model_name=EMBEDDING_MODEL)
-        logger.info(f"Embedding model configured: {EMBEDDING_MODEL}")
-        
-        # Create the ingestion pipeline
-        # This processes documents through the transformations in order
-        pipeline = IngestionPipeline(
-            transformations=[
-                text_splitter,  # First: split into chunks
-                embed_model,    # Second: create embeddings
-            ],
-            vector_store=vector_store  # Third: store in database
-        )
+        # In-memory client (no files to worry about)
+        client = chromadb.Client()
+        collection = client.get_or_create_collection("my_personas")
         
-        logger.info("✅ Ingestion pipeline created successfully")
-        return pipeline
+        # Wrap it for LlamaIndex
+        vector_store = ChromaVectorStore(chroma_collection=collection)
+        
+        logger.info("Vector store ready!")
+        return vector_store
         
     except Exception as e:
-        logger.error(f"❌ Error creating ingestion pipeline: {e}")
-        raise RuntimeError(f"Failed to create ingestion pipeline: {e}")
-
+        logger.error(f"Vector store setup failed: {e}")
+        return None
 
-# ============================================================================
-# INDEX CREATION - Vector Search Index
-# ============================================================================
-
-def create_persona_index():
+def build_persona_index():
     """
-    Create or load the persona vector index.
-    
-    This is the main function that orchestrates the entire RAG setup:
-    1. Load documents from files
-    2. Set up vector storage
-    3. Process documents through pipeline
-    4. Create searchable index
-    
-    The index enables semantic search where:
-    - Similar meanings are found even with different words
-    - Context and relationships are preserved
-    - Fast retrieval from thousands of personas
-    
-    Returns:
-        VectorStoreIndex: Ready-to-use search index
+    Build my persona index from scratch
+    This might take a minute the first time
     """
-    logger.info("Creating persona search index...")
+    logger.info("Building persona index...")
     
     try:
-        # Step 1: Load persona documents
-        documents = load_persona_documents()
-        if not documents:
-            raise RuntimeError("No documents loaded")
+        # Step 1: Get the persona data
+        personas = download_personas()
+        if not personas:
+            logger.error("No persona data available")
+            return None
+        
+        # Step 2: Make documents
+        documents = make_documents(personas)
         
-        # Step 2: Set up vector store
-        vector_store = setup_chroma_vector_store()
+        # Step 3: Set up vector storage
+        vector_store = setup_vector_store()
+        if not vector_store:
+            logger.error("Can't create vector store")
+            return None
         
-        # Step 3: Check if we already have processed data
-        # This saves time on repeated runs
+        # Step 4: Set up embeddings
         try:
-            # Try to create index from existing vector store
             embed_model = HuggingFaceEmbedding(model_name=EMBEDDING_MODEL)
-            existing_index = VectorStoreIndex.from_vector_store(
-                vector_store=vector_store,
-                embed_model=embed_model
-            )
-            
-            # Test if the index has data
-            test_retriever = existing_index.as_retriever(similarity_top_k=1)
-            test_results = test_retriever.retrieve("test query")
-            
-            if test_results:
-                logger.info("✅ Found existing persona index with data")
-                return existing_index
-            else:
-                logger.info("Existing index is empty, rebuilding...")
-                
-        except Exception:
-            logger.info("No existing index found, creating new one...")
+            logger.info(f"Loaded embedding model: {EMBEDDING_MODEL}")
+        except Exception as e:
+            logger.error(f"Can't load embeddings: {e}")
+            return None
         
-        # Step 4: Process documents through ingestion pipeline
-        pipeline = create_ingestion_pipeline(vector_store)
+        # Step 5: Build the index
+        logger.info("Creating vector index... this might take a moment")
         
-        logger.info(f"Processing {len(documents)} documents through pipeline...")
-        # This may take a while for large datasets as it generates embeddings
-        nodes = pipeline.run(documents=documents)
-        logger.info(f"✅ Processed {len(nodes)} document chunks")
-        
-        # Step 5: Create the final index
-        embed_model = HuggingFaceEmbedding(model_name=EMBEDDING_MODEL)
-        index = VectorStoreIndex.from_vector_store(
+        index = VectorStoreIndex.from_documents(
+            documents=documents,
             vector_store=vector_store,
-            embed_model=embed_model
+            embed_model=embed_model,
+            show_progress=True
         )
         
-        logger.info("✅ Persona index created successfully")
+        logger.info("Persona index built successfully!")
         return index
         
     except Exception as e:
-        logger.error(f"❌ Error creating persona index: {e}")
-        raise RuntimeError(f"Failed to create persona index: {e}")
-
-
-# ============================================================================
-# MAIN FUNCTIONS USED BY TOOLS.PY
-# ============================================================================
-# These are the core functions that tools.py uses to access the persona database.
-# Tool creation is handled in tools.py following the course structure.
+        logger.error(f"Index building failed: {e}")
+        return None
 
 def get_persona_index():
     """
-    Get the persona index for use by tools.py.
+    Get my persona index (builds it if needed, caches it if possible)
+    """
+    global _my_persona_index
     
-    This is a simple wrapper function that tools.py can import and use.
-    It ensures the index is created and ready for use.
+    if _my_persona_index is None:
+        logger.info("Building persona index for the first time...")
+        _my_persona_index = build_persona_index()
+    else:
+        logger.info("Using cached persona index")
     
-    Returns:
-        VectorStoreIndex: The persona database index
-    """
-    return create_persona_index()
+    return _my_persona_index
 
-
-def get_persona_query_engine():
+def get_persona_query_engine(llm=None):
     """
-    Get a configured query engine for the persona database.
-    
-    This creates a query engine ready for use in QueryEngineTool.
-    Tools.py can import this to create the persona database tool.
-    
-    Returns:
-        QueryEngine: Configured query engine for persona database
+    Get a query engine I can use to search my personas
+    This is what gets called from my tools
     """
     try:
-        # Get the index
-        index = create_persona_index()
+        index = get_persona_index()
+        if index is None:
+            logger.warning("No persona index available")
+            return None
         
-        # Configure embedding model (same as indexing)
-        embed_model = HuggingFaceEmbedding(model_name=EMBEDDING_MODEL)
-        
-        # Create query engine with optimal settings
+        # Make the query engine
         query_engine = index.as_query_engine(
-            response_mode="tree_summarize",  # Good for combining multiple sources
-            similarity_top_k=5,  # Retrieve top 5 most relevant personas
-            streaming=False  # Disable streaming for stability
+            llm=llm,  # Use the LLM from my agent
+            response_mode="tree_summarize",  # Good for combining multiple results
+            similarity_top_k=3,  # Get top 3 matches
+            streaming=False
         )
         
-        logger.info("✅ Persona query engine ready for tools.py")
+        logger.info("Persona query engine ready")
         return query_engine
         
     except Exception as e:
-        logger.error(f"❌ Error creating query engine for tools.py: {e}")
-        raise
-
+        logger.error(f"Query engine creation failed: {e}")
+        return None
 
-# ============================================================================
-# TESTING AND DEBUGGING FUNCTIONS
-# ============================================================================
-
-def test_persona_system():
+def test_my_personas():
     """
-    Test the persona system components available in retriever.py.
-    This helps verify that the database setup is working correctly.
-    
-    Note: Tool creation testing is now in tools.py since that's where tools are created.
+    Test that my persona system works
     """
-    print("\n=== Testing Persona Database System ===")
+    print("\n=== Testing My Persona Database ===")
     
-    # Test data preparation
-    print("\n--- Testing Data Preparation ---")
-    try:
-        count = download_and_prepare_personas()
-        print(f"✅ Data preparation successful: {count} personas")
-    except Exception as e:
-        print(f"❌ Data preparation failed: {e}")
-        return
+    # Check dependencies
+    print(f"Datasets available: {CAN_LOAD_DATASETS}")
+    print(f"ChromaDB available: {CHROMADB_WORKS}")
     
-    # Test document loading
-    print("\n--- Testing Document Loading ---")
-    try:
-        docs = load_persona_documents()
-        print(f"✅ Document loading successful: {len(docs)} documents")
-    except Exception as e:
-        print(f"❌ Document loading failed: {e}")
-        return
+    if not CHROMADB_WORKS:
+        print("❌ ChromaDB missing - persona database won't work")
+        return False
     
-    # Test index creation
-    print("\n--- Testing Index Creation ---")
+    # Test data loading
+    print("\nTesting persona loading...")
     try:
-        index = create_persona_index()
-        print("✅ Index creation successful")
+        personas = download_personas()
+        print(f"✅ Got {len(personas)} personas")
+        if personas:
+            print(f"Sample: {personas[0][:100]}...")
     except Exception as e:
-        print(f"❌ Index creation failed: {e}")
-        return
-    
-    # Test basic retrieval (without tool wrapper)
-    print("\n--- Testing Basic Retrieval ---")
-    test_queries = [
-        "writers and authors",
-        "people interested in travel", 
-        "scientists and researchers"
-    ]
+        print(f"❌ Persona loading failed: {e}")
+        return False
     
+    # Test vector store
+    print("\nTesting vector store...")
     try:
-        retriever = index.as_retriever(similarity_top_k=2)
-        
-        for query in test_queries:
-            print(f"\nQuery: {query}")
-            try:
-                results = retriever.retrieve(query)
-                if results:
-                    print(f"✅ Found {len(results)} results")
-                    print(f"Sample: {results[0].text[:100]}...")
-                else:
-                    print("No results found")
-            except Exception as e:
-                print(f"❌ Query failed: {e}")
-                
+        vector_store = setup_vector_store()
+        if vector_store:
+            print("✅ Vector store created")
+        else:
+            print("❌ Vector store failed")
+            return False
     except Exception as e:
-        print(f"❌ Retriever creation failed: {e}")
+        print(f"❌ Vector store error: {e}")
+        return False
     
-    # Test query engine creation (for tools.py)
-    print("\n--- Testing Query Engine Creation ---")
+    # Test index building (small test)
+    print("\nTesting index building...")
     try:
-        query_engine = get_persona_query_engine()
-        print("✅ Query engine creation successful")
-        print("   (This query engine can be used by tools.py)")
+        # Use just a few personas for testing
+        test_personas = make_sample_personas()[:3]
+        test_docs = make_documents(test_personas)
+        
+        vector_store = setup_vector_store()
+        embed_model = HuggingFaceEmbedding(model_name=EMBEDDING_MODEL)
+        
+        index = VectorStoreIndex.from_documents(
+            documents=test_docs,
+            vector_store=vector_store,
+            embed_model=embed_model
+        )
+        
+        print("✅ Index building works")
+        
+        # Test a simple query
+        query_engine = index.as_query_engine(similarity_top_k=1)
+        results = query_engine.query("software developer")
+        print("✅ Query test passed")
+        
+        return True
+        
     except Exception as e:
-        print(f"❌ Query engine creation failed: {e}")
-    
-    print("\n=== Database System Testing Complete ===")
-    print("\nNote: For tool testing, run tools.py or usage_example.py")
-
-
-# ============================================================================
-# MAIN EXECUTION
-# ============================================================================
+        print(f"❌ Index test failed: {e}")
+        return False
 
 if __name__ == "__main__":
-    # If this file is run directly, run tests
-    print("Persona Database System Testing")
-    print("=" * 50)
-    
-    # Set up logging for testing
+    # Test my persona system
+    import logging
     logging.basicConfig(level=logging.INFO)
     
-    # Run database system tests
-    test_persona_system()
+    print("Testing My Persona Database System")
+    print("=" * 40)
+    
+    success = test_my_personas()
+    
+    if success:
+        print("\n✅ Persona database is working!")
+    else:
+        print("\n❌ Persona database has issues")
     
-    print("\n" + "=" * 50)
-    print("Database testing complete!")
-    print("\nFor tool testing, run:")
-    print("  python tools.py")
-    print("  python usage_example.py")
-    print("\nFor full agent testing, run:")
-    print("  python app.py")
+    print("\nThis system is optimized for HuggingFace Spaces:")
+    print("- Uses in-memory storage (no files)")
+    print("- Limited personas (saves memory)")
+    print("- Fallback data (works offline)")
+    print("- Fast startup (cached building)")

test_hf_space.py

@@ -0,0 +1,297 @@
+"""
+Test Everything - Making Sure My GAIA Agent Works
+
+I'm nervous about submitting my final project, so I made this test script
+to check that everything works properly before I deploy to HuggingFace Spaces.
+
+This tests:
+- All my dependencies are installed
+- My tools work correctly  
+- My persona database loads
+- My agent can be created
+- Everything runs in HF Space environment
+
+If this passes, I should be good to go for the GAIA evaluation!
+"""
+
+import sys
+import os
+import logging
+import traceback
+
+# Setup logging so I can see what's happening
+logging.basicConfig(level=logging.INFO, format='%(levelname)s: %(message)s')
+logger = logging.getLogger(__name__)
+
+def check_my_dependencies():
+    """
+    Make sure I have all the packages I need
+    """
+    print("\n📦 Checking My Dependencies...")
+    
+    required = [
+        "gradio", "requests", "pandas",
+        "llama_index.core", "llama_index.llms.huggingface_api",
+        "llama_index.embeddings.huggingface", "llama_index.vector_stores.chroma"
+    ]
+    
+    results = {}
+    
+    for package in required:
+        try:
+            __import__(package)
+            print(f"✅ {package}")
+            results[package] = True
+        except ImportError as e:
+            print(f"❌ {package}: {e}")
+            results[package] = False
+    
+    # Check optional ones
+    optional = ["chromadb", "datasets", "duckduckgo_search"]
+    
+    for package in optional:
+        try:
+            __import__(package)
+            print(f"✅ {package} (optional)")
+            results[package] = True
+        except ImportError:
+            print(f"⚠️ {package} (optional) - missing")
+            results[package] = False
+    
+    return results
+
+def check_my_environment():
+    """
+    Check if I'm in the right environment and have API keys
+    """
+    print("\n🌍 Checking My Environment...")
+    
+    env = {
+        "python_version": sys.version.split()[0],
+        "platform": sys.platform,
+        "working_dir": os.getcwd(),
+        "is_hf_space": bool(os.getenv("SPACE_HOST")),
+        "has_hf_token": bool(os.getenv("HF_TOKEN")),
+        "has_openai_key": bool(os.getenv("OPENAI_API_KEY"))
+    }
+    
+    print(f"✅ Python {env['python_version']}")
+    print(f"✅ Platform: {env['platform']}")
+    print(f"✅ Working in: {env['working_dir']}")
+    
+    if env['is_hf_space']:
+        print("✅ Running in HuggingFace Space")
+    else:
+        print("ℹ️ Running locally (not in HF Space)")
+    
+    if env['has_openai_key'] or env['has_hf_token']:
+        print("✅ Have at least one API key")
+    else:
+        print("⚠️ No API keys found - might not work")
+    
+    return env
+
+def test_my_tools():
+    """
+    Test that all my tools work properly
+    """
+    print("\n🔧 Testing My Tools...")
+    
+    try:
+        from tools import get_my_tools
+        
+        # Test creating tools without LLM first
+        tools = get_my_tools()
+        print(f"✅ Created {len(tools)} tools")
+        
+        # List what I got
+        for tool in tools:
+            tool_name = tool.metadata.name
+            print(f"   - {tool_name}")
+        
+        # Test some basic functions
+        print("\nTesting basic functions...")
+        
+        from tools import do_math, analyze_file
+        
+        # Test calculator
+        result = do_math("10 + 5 * 2")
+        print(f"✅ Calculator: 10 + 5 * 2 = {result}")
+        
+        # Test file analyzer
+        test_csv = "name,age\nAlice,25\nBob,30"
+        result = analyze_file(test_csv, "csv")
+        print(f"✅ File analyzer works")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Tool testing failed: {e}")
+        traceback.print_exc()
+        return False
+
+def test_my_persona_database():
+    """
+    Test my persona database system
+    """
+    print("\n👥 Testing My Persona Database...")
+    
+    try:
+        from my_retriever import test_my_personas
+        
+        # Run the built-in test
+        success = test_my_personas()
+        
+        if success:
+            print("✅ Persona database works!")
+        else:
+            print("⚠️ Persona database issues (agent will still work)")
+        
+        return success
+        
+    except Exception as e:
+        print(f"⚠️ Persona database test failed: {e}")
+        print("   This is OK - agent can work without it")
+        return False
+
+def test_my_agent():
+    """
+    Test that I can create my agent and it works
+    """
+    print("\n🤖 Testing My Agent...")
+    
+    try:
+        # Import what I need
+        from llama_index.core.agent.workflow import AgentWorkflow
+        from tools import get_my_tools
+        
+        print("Testing LLM setup...")
+        
+        # Try to create an LLM
+        llm = None
+        openai_key = os.getenv("OPENAI_API_KEY")
+        hf_token = os.getenv("HF_TOKEN")
+        
+        if openai_key:
+            try:
+                from llama_index.llms.openai import OpenAI
+                llm = OpenAI(api_key=openai_key, model="gpt-4o-mini", max_tokens=50)
+                print("✅ OpenAI LLM works")
+            except Exception as e:
+                print(f"⚠️ OpenAI failed: {e}")
+        
+        if llm is None and hf_token:
+            try:
+                from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
+                llm = HuggingFaceInferenceAPI(
+                    model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
+                    token=hf_token,
+                    max_new_tokens=50
+                )
+                print("✅ HuggingFace LLM works")
+            except Exception as e:
+                print(f"⚠️ HuggingFace failed: {e}")
+        
+        if llm is None:
+            print("❌ No LLM available - can't test agent")
+            return False
+        
+        # Test creating tools with LLM
+        tools = get_my_tools(llm)
+        print(f"✅ Got {len(tools)} tools with LLM")
+        
+        # Create the agent
+        agent = AgentWorkflow.from_tools_or_functions(
+            tools_or_functions=tools,
+            llm=llm,
+            system_prompt="You are my test assistant."
+        )
+        print("✅ Agent created successfully")
+        
+        # Test a simple question
+        import asyncio
+        
+        async def test_simple_question():
+            try:
+                handler = agent.run(user_msg="What is 3 + 4?")
+                result = await handler
+                return str(result)
+            except Exception as e:
+                return f"Error: {e}"
+        
+        # Run the test
+        loop = asyncio.new_event_loop()
+        asyncio.set_event_loop(loop)
+        try:
+            answer = loop.run_until_complete(test_simple_question())
+            print(f"✅ Agent answered: {answer[:100]}...")
+        finally:
+            loop.close()
+        
+        print("✅ My agent is fully working!")
+        return True
+        
+    except Exception as e:
+        print(f"❌ Agent test failed: {e}")
+        traceback.print_exc()
+        return False
+
+def run_all_my_tests():
+    """
+    Run every test I can think of
+    """
+    print("🎯 Testing My GAIA Agent - Final Project Check")
+    print("=" * 50)
+    
+    # Run all the tests
+    deps_ok = check_my_dependencies()
+    env_info = check_my_environment()
+    tools_ok = test_my_tools()
+    personas_ok = test_my_persona_database()
+    agent_ok = test_my_agent()
+    
+    # Check critical dependencies
+    critical = ["llama_index.core", "gradio", "requests"]
+    critical_ok = all(deps_ok.get(dep, False) for dep in critical)
+    
+    # Summary
+    print("\n" + "=" * 50)
+    print("📊 MY TEST RESULTS")
+    print("=" * 50)
+    
+    print(f"Critical Dependencies: {'✅ GOOD' if critical_ok else '❌ BAD'}")
+    print(f"My Tools: {'✅ GOOD' if tools_ok else '❌ BAD'}")
+    print(f"Persona Database: {'✅ GOOD' if personas_ok else '⚠️ OPTIONAL'}")
+    print(f"My Agent: {'✅ GOOD' if agent_ok else '❌ BAD'}")
+    
+    # Final verdict
+    ready_for_gaia = critical_ok and tools_ok and agent_ok
+    
+    print("\n" + "=" * 50)
+    if ready_for_gaia:
+        print("🎉 I'M READY FOR GAIA!")
+        print("My agent should work properly in HuggingFace Spaces.")
+        print("Time to deploy and hope I get 30%+ to pass! 🤞")
+        
+        if not personas_ok:
+            print("\nNote: Persona database might not work, but that's OK.")
+    else:
+        print("😰 NOT READY YET")
+        print("I need to fix the issues above before submitting.")
+        print("Don't want to fail the course!")
+    
+    print("=" * 50)
+    
+    return ready_for_gaia
+
+if __name__ == "__main__":
+    # Run all my tests
+    success = run_all_my_tests()
+    
+    # Exit with appropriate code
+    if success:
+        print("\n🚀 All systems go! Ready to deploy!")
+        sys.exit(0)
+    else:
+        print("\n🛑 Need to fix issues first!")
+        sys.exit(1)

tools.py

@@ -1,15 +1,15 @@
 """
-tools.py - Agent Tools for GAIA Benchmark (Course Didactic Structure)
+My Agent Tools
 
-This file follows the course approach of separating:
-1. Raw functions (the actual functionality)
-2. Tool wrappers (FunctionTool and QueryEngineTool creation)
+These are all the tools I'm giving my agent. I learned in the course that you need
+to separate the actual functions from the tool wrappers.
 
-This makes it easier to understand and debug each component separately.
-Each tool addresses specific GAIA benchmark needs while demonstrating course concepts.
-
-create_persona_database_tool()    # QueryEngineTool creation
-get_all_tools()                   # All tools collection
+Tools I'm building:
+1. Web search (for current info)
+2. Calculator (for math - super important for GAIA)
+3. File analyzer (for data questions)
+4. Weather tool (just for demo)
+5. Persona database (RAG with vector search)
 """
 
 import logging
@@ -19,639 +19,319 @@ import random
 from typing import List
 import chromadb
 
-# LlamaIndex imports
+# LlamaIndex stuff for creating tools
 from llama_index.core.tools import FunctionTool, QueryEngineTool
 from llama_index.core import VectorStoreIndex
 from llama_index.embeddings.huggingface import HuggingFaceEmbedding
 from llama_index.vector_stores.chroma import ChromaVectorStore
 from llama_index.llms.huggingface_api import HuggingFaceInferenceAPI
 
-# Setup logging
 logger = logging.getLogger(__name__)
 
-# ============================================================================
-# PART 1: RAW FUNCTIONS (The actual functionality)
-# ============================================================================
-# These are the core functions that do the actual work.
-# They can be tested independently and are easy to understand.
+# ========================================
+# THE ACTUAL FUNCTIONS
+# ========================================
 
-def web_search(query: str) -> str:
+def search_web(query: str) -> str:
     """
-    Search the web for information using DuckDuckGo.
-    
-    This function handles the actual web searching logic.
-    Critical for GAIA questions requiring current information.
-    
-    Args:
-        query (str): The search query/question
-        
-    Returns:
-        str: Formatted search results with titles, content, and URLs
-        
-    Why this is essential for GAIA:
-    - Many GAIA questions need current information (news, prices, events)
-    - LLMs have knowledge cutoffs and may not know recent facts
-    - Web search provides access to the latest information
+    Search the web using DuckDuckGo
+    I'm using this instead of Google because it's free
     """
-    logger.info(f"🔍 Web search requested: {query}")
+    logger.info(f"Searching for: {query}")
     
     try:
-        # Import DuckDuckGo search - free search API
         from duckduckgo_search import DDGS
         
-        # Perform the search with a reasonable limit
         with DDGS() as ddgs:
-            # Get top 3 results to avoid overwhelming the LLM
+            # Get top 3 results so I don't overwhelm the LLM
             results = list(ddgs.text(query, max_results=3))
             
             if not results:
-                logger.warning("No search results found")
-                return "No search results found for this query."
+                return "No search results found."
             
-            # Format results in a clean, readable way
-            formatted_results = []
+            # Format the results nicely
+            formatted = []
             for i, result in enumerate(results, 1):
-                formatted_result = (
-                    f"Result {i}:\n"
-                    f"Title: {result['title']}\n"
-                    f"Content: {result['body']}\n"
-                    f"URL: {result['href']}\n"
-                )
-                formatted_results.append(formatted_result)
+                formatted.append(f"""Result {i}:
+Title: {result['title']}
+Content: {result['body']}
+URL: {result['href']}
+""")
             
-            final_result = "\n".join(formatted_results)
-            logger.info(f"✅ Web search completed: {len(results)} results found")
-            return final_result
+            return "\n".join(formatted)
             
     except ImportError:
-        error_msg = "DuckDuckGo search library not available. Please install duckduckgo-search."
-        logger.error(error_msg)
-        return error_msg
+        return "Search not available - duckduckgo_search not installed"
     except Exception as e:
-        error_msg = f"Search error: {str(e)}"
-        logger.error(f"Web search failed: {e}")
-        return error_msg
-
+        return f"Search failed: {e}"
 
-def calculate(expression: str) -> str:
+def do_math(expression: str) -> str:
     """
-    Safely evaluate mathematical expressions.
-    
-    This function handles mathematical calculations with safety measures.
-    CRITICAL for GAIA because many questions involve precise calculations.
-    
-    Args:
-        expression (str): Mathematical expression (e.g., "2 + 2", "sqrt(16)", "sin(pi/2)")
-        
-    Returns:
-        str: The result of the calculation or an error message
-        
-    Why this is essential for GAIA:
-    - GAIA has many mathematical questions (percentages, conversions, etc.)
-    - LLMs can make arithmetic errors, especially with complex math
-    - Exact numerical accuracy is required (GAIA uses exact match scoring)
-    
-    Examples:
-        calculate("2 + 2") → "4"
-        calculate("15% of 847") → calculate("0.15 * 847") → "127.05"
-        calculate("sqrt(16)") → "4.0"
+    Calculate math expressions safely
+    This is super important for GAIA - lots of math questions!
     """
-    logger.info(f"🧮 Calculation requested: {expression}")
+    logger.info(f"Calculating: {expression}")
     
     try:
-        # Create a safe environment for evaluation
-        # Only allow mathematical functions, no dangerous operations
-        allowed_names = {
-            # Include all math module functions (sin, cos, sqrt, log, etc.)
-            k: v for k, v in math.__dict__.items() if not k.startswith("__")
+        # Only allow safe math operations - learned this the hard way
+        safe_functions = {
+            # Basic math
+            'abs': abs, 'round': round, 'min': min, 'max': max, 'sum': sum, 'pow': pow,
+            # Math module functions
+            **{k: v for k, v in math.__dict__.items() if not k.startswith("__")},
+            # Constants
+            'pi': math.pi, 'e': math.e,
         }
         
-        # Add safe Python functions
-        allowed_names.update({
-            "abs": abs,      # Absolute value
-            "round": round,  # Rounding
-            "min": min,      # Minimum
-            "max": max,      # Maximum
-            "sum": sum,      # Sum of iterables
-            "pow": pow,      # Power function
-        })
-        
-        # Add mathematical constants
-        allowed_names.update({
-            "pi": math.pi,   # π
-            "e": math.e,     # Euler's number
-        })
-        
-        # Evaluate the expression safely
-        # __builtins__ = {} prevents dangerous functions like open(), exec()
-        result = eval(expression, {"__builtins__": {}}, allowed_names)
-        
-        result_str = str(result)
-        logger.info(f"✅ Calculation result: {expression} = {result_str}")
-        return result_str
+        # eval is dangerous but this is safe with limited scope
+        result = eval(expression, {"__builtins__": {}}, safe_functions)
+        return str(result)
         
     except ZeroDivisionError:
-        error_msg = "Error: Division by zero"
-        logger.error(error_msg)
-        return error_msg
-    except ValueError as e:
-        error_msg = f"Error: Invalid mathematical operation - {str(e)}"
-        logger.error(error_msg)
-        return error_msg
-    except SyntaxError:
-        error_msg = "Error: Invalid mathematical expression syntax"
-        logger.error(error_msg)
-        return error_msg
+        return "Error: Division by zero"
     except Exception as e:
-        error_msg = f"Calculation error: {str(e)}"
-        logger.error(f"Unexpected calculation error: {e}")
-        return error_msg
-
+        return f"Math error: {e}"
 
-def analyze_file(file_content: str, file_type: str = "text") -> str:
+def analyze_file(content: str, file_type: str = "text") -> str:
     """
-    Analyze file content and extract relevant information.
-    
-    This function processes different file types for analysis.
-    Useful for GAIA questions that include file attachments.
-    
-    Args:
-        file_content (str): The content of the file
-        file_type (str): Type of file ("text", "csv", "json", etc.)
-        
-    Returns:
-        str: Analysis results or extracted information
-        
-    Why this helps with GAIA:
-    - Some GAIA questions include data files to analyze
-    - Questions might ask for statistics, summaries, or specific data extraction
-    - File processing shows practical data analysis skills
+    Analyze file contents - useful for GAIA questions with data
     """
-    logger.info(f"📊 File analysis requested for {file_type} file")
+    logger.info(f"Analyzing {file_type} file")
     
     try:
         if file_type.lower() == "csv":
-            # For CSV files, provide basic statistics
-            lines = file_content.strip().split('\n')
+            lines = content.strip().split('\n')
             if not lines:
                 return "Empty file"
             
-            # Count rows and columns (assuming first row is header)
-            num_rows = len(lines) - 1  # Subtract header
-            if lines:
-                num_cols = len(lines[0].split(','))
-                analysis = (
-                    f"CSV Analysis:\n"
-                    f"- Rows: {num_rows}\n"
-                    f"- Columns: {num_cols}\n"
-                    f"- Headers: {lines[0]}"
-                )
-                if num_rows > 0:
-                    analysis += f"\n- First data row: {lines[1] if len(lines) > 1 else 'None'}"
-                return analysis
-                
-        elif file_type.lower() in ["txt", "text"]:
-            # For text files, provide basic statistics
-            lines = file_content.split('\n')
-            words = file_content.split()
-            chars = len(file_content)
+            rows = len(lines) - 1  # minus header
+            cols = len(lines[0].split(',')) if lines else 0
             
-            return (
-                f"Text Analysis:\n"
-                f"- Lines: {len(lines)}\n"
-                f"- Words: {len(words)}\n"
-                f"- Characters: {chars}"
-            )
+            analysis = f"""CSV Analysis:
+Rows: {rows}
+Columns: {cols}
+Headers: {lines[0]}"""
             
+            if rows > 0 and len(lines) > 1:
+                analysis += f"\nFirst row: {lines[1]}"
+            
+            return analysis
+            
+        elif file_type.lower() in ["txt", "text"]:
+            lines = content.split('\n')
+            words = content.split()
+            
+            return f"""Text Analysis:
+Lines: {len(lines)}
+Words: {len(words)}
+Characters: {len(content)}"""
+        
         else:
-            # For other file types, return content with basic info
-            preview = file_content[:1000] + '...' if len(file_content) > 1000 else file_content
+            # Just show a preview
+            preview = content[:500] + '...' if len(content) > 500 else content
             return f"File content ({file_type}):\n{preview}"
             
     except Exception as e:
-        error_msg = f"File analysis error: {str(e)}"
-        logger.error(error_msg)
-        return error_msg
-
+        return f"File analysis error: {e}"
 
 def get_weather(location: str) -> str:
     """
-    Get dummy weather information for a location.
-    
-    This is a simplified weather function for demonstration.
-    In a real implementation, you'd connect to a weather API like OpenWeatherMap.
-    
-    Args:
-        location (str): City or location name
-        
-    Returns:
-        str: Weather description with temperature
-        
-    Note: This is a dummy implementation for course purposes.
-    Real weather data would require an API key and actual weather service.
+    Dummy weather function - just for demonstration
+    In a real app I'd use an actual weather API
     """
-    logger.info(f"🌤️ Weather requested for: {location}")
-    
-    # Dummy weather data for demonstration
-    weather_conditions = [
-        {"condition": "Sunny", "temp_c": 25, "humidity": 60},
-        {"condition": "Cloudy", "temp_c": 20, "humidity": 70},
-        {"condition": "Rainy", "temp_c": 15, "humidity": 85},
-        {"condition": "Windy", "temp_c": 22, "humidity": 55},
-        {"condition": "Clear", "temp_c": 28, "humidity": 45}
+    logger.info(f"Getting weather for {location}")
+    
+    # Fake weather data
+    weather_options = [
+        {"condition": "Sunny", "temp": 25, "humidity": 60},
+        {"condition": "Cloudy", "temp": 18, "humidity": 75},
+        {"condition": "Rainy", "temp": 15, "humidity": 90},
+        {"condition": "Clear", "temp": 28, "humidity": 45}
     ]
     
-    # Randomly select weather (in real implementation, this would be API call)
-    weather = random.choice(weather_conditions)
-    
-    result = (
-        f"Weather in {location.title()}:\n"
-        f"Condition: {weather['condition']}\n"
-        f"Temperature: {weather['temp_c']}°C\n"
-        f"Humidity: {weather['humidity']}%"
-    )
+    weather = random.choice(weather_options)
     
-    logger.info(f"✅ Weather result: {weather['condition']}, {weather['temp_c']}°C")
-    return result
+    return f"""Weather in {location}:
+Condition: {weather['condition']}
+Temperature: {weather['temp']}°C
+Humidity: {weather['humidity']}%"""
 
+# ========================================
+# PERSONA DATABASE SETUP
+# ========================================
 
-# ============================================================================
-# PART 2: PERSONA DATABASE SETUP (QueryEngine creation)
-# ============================================================================
-# This sets up the persona database query engine following the course pattern.
-
-def create_persona_query_engine():
+def setup_persona_database(llm=None):
     """
-    Create a query engine for the persona database following course pattern.
-    
-    This demonstrates the exact approach from the course:
-    1. Connect to existing ChromaDB database
-    2. Create VectorStoreIndex from the stored vectors
-    3. Configure LLM for response generation
-    4. Create QueryEngine with specific settings
-    
-    Returns:
-        QueryEngine: Ready-to-use query engine for persona database
-        
-    Why QueryEngine vs simple retrieval:
-    - QueryEngine combines retrieval + LLM generation
-    - Provides natural, conversational responses
-    - Can synthesize information from multiple personas
-    - Better for complex questions requiring reasoning
+    This creates a query engine for my persona database
+    Using the patterns I learned in the course
     """
-    logger.info("🏗️ Creating persona database query engine...")
+    logger.info("Setting up persona database...")
     
     try:
-        # Step 1: Connect to existing ChromaDB (created by retriever.py)
-        db = chromadb.PersistentClient(path="./alfred_chroma_db")
-        chroma_collection = db.get_or_create_collection("alfred")
-        vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
-        logger.info("✅ Connected to ChromaDB")
+        # Connect to my ChromaDB database
+        db = chromadb.PersistentClient(path="./my_persona_db")
+        collection = db.get_or_create_collection("personas")
+        vector_store = ChromaVectorStore(chroma_collection=collection)
         
-        # Step 2: Set up embedding model (same as used during indexing)
+        # Use the same embedding model as in the course
         embed_model = HuggingFaceEmbedding(model_name="BAAI/bge-small-en-v1.5")
-        logger.info("✅ Embedding model configured")
         
-        # Step 3: Create VectorStoreIndex from existing data
+        # Create the index
         index = VectorStoreIndex.from_vector_store(
-            vector_store=vector_store, 
+            vector_store=vector_store,
             embed_model=embed_model
         )
-        logger.info("✅ Vector index created")
-        
-        # Step 4: Configure LLM for response generation
-        # Try to get LLM from settings first, then fallback
-        try:
-            from llama_index.core import Settings
-            llm = Settings.llm
-            
-            if llm is None:
-                # Fallback to HuggingFace LLM
-                hf_token = os.getenv("HF_TOKEN")
-                if hf_token:
-                    llm = HuggingFaceInferenceAPI(
-                        model_name="Qwen/Qwen2.5-Coder-32B-Instruct",
-                        token=hf_token,
-                        max_new_tokens=512,
-                        temperature=0.1
-                    )
-                    logger.info("✅ Using HuggingFace LLM")
-                else:
-                    logger.warning("⚠️ No LLM available, query engine will use default")
-                    llm = None
-        except Exception:
-            logger.warning("⚠️ Could not configure LLM, using default")
-            llm = None
         
-        # Step 5: Create QueryEngine with optimized settings
+        # Make the query engine
         query_engine = index.as_query_engine(
-            llm=llm,
-            response_mode="tree_summarize",  # Good for combining multiple sources
-            similarity_top_k=5,  # Retrieve top 5 most relevant personas
-            streaming=False  # Disable streaming for stability
+            llm=llm,  # Use the same LLM as the agent
+            response_mode="tree_summarize",
+            similarity_top_k=3,  # Get top 3 matches
+            streaming=False
         )
         
-        logger.info("✅ Persona query engine created successfully")
+        logger.info("Persona database ready")
         return query_engine
         
     except Exception as e:
-        logger.error(f"❌ Error creating persona query engine: {e}")
-        raise RuntimeError(f"Failed to create persona query engine: {e}")
-
+        logger.warning(f"Persona database failed: {e}")
+        return None
 
-# ============================================================================
-# PART 3: TOOL WRAPPERS (Converting functions to tools)
-# ============================================================================
-# This section creates the actual tools that the agent can use.
-# Each tool wraps a function with metadata for the LLM to understand.
+# ========================================
+# CREATING THE TOOLS
+# ========================================
 
-# Web Search Tool
-web_search_tool = FunctionTool.from_defaults(
-    fn=web_search,
+# Make function tools from my functions
+web_tool = FunctionTool.from_defaults(
+    fn=search_web,
     name="web_search",
-    description=(
-        "Search the web for current information, recent events, statistics, "
-        "facts, or any information not in the LLM's training data. "
-        "Use this when you need up-to-date or specific factual information. "
-        "Essential for GAIA questions about current events, prices, or recent developments."
-    )
+    description="Search the web for current information, recent events, or facts"
 )
 
-# Calculator Tool  
-calculator_tool = FunctionTool.from_defaults(
-    fn=calculate,
-    name="calculator", 
-    description=(
-        "Perform mathematical calculations and evaluate mathematical expressions. "
-        "Supports basic arithmetic (+, -, *, /), advanced math functions (sqrt, sin, cos, log), "
-        "and mathematical constants (pi, e). Use this for any numerical computations, "
-        "percentage calculations, unit conversions, or statistical operations. "
-        "CRITICAL for GAIA mathematical questions to ensure accuracy."
-    )
+calc_tool = FunctionTool.from_defaults(
+    fn=do_math,
+    name="calculator",
+    description="Calculate mathematical expressions. Use this for ANY math calculations!"
 )
 
-# File Analysis Tool
-file_analysis_tool = FunctionTool.from_defaults(
+file_tool = FunctionTool.from_defaults(
     fn=analyze_file,
-    name="file_analyzer",
-    description=(
-        "Analyze file contents including CSV files, text files, and other data files. "
-        "Can extract statistics, summarize content, and process structured data. "
-        "Use this when GAIA questions involve analyzing attached files or datasets."
-    )
+    name="file_analyzer", 
+    description="Analyze file contents like CSV files or text files"
 )
 
-# Weather Tool (demonstration)
 weather_tool = FunctionTool.from_defaults(
     fn=get_weather,
     name="weather_tool",
-    description=(
-        "Get weather information for a specific location. "
-        "Note: This is a demo implementation with dummy data. "
-        "Use when questions ask about weather conditions."
-    )
+    description="Get weather information (demo only - uses fake data)"
 )
 
-# Persona Database Query Engine Tool
-def create_persona_database_tool():
+def create_persona_tool(llm=None):
     """
-    Create the persona database tool using QueryEngineTool.
-    
-    This follows the exact course pattern for creating QueryEngineTool.
-    The tool combines retrieval with LLM generation for natural responses.
-    
-    Returns:
-        QueryEngineTool: Tool for querying the persona database
+    Create the persona database tool
+    This might fail in some environments so I handle errors gracefully
     """
-    logger.info("🛠️ Creating persona database tool...")
+    logger.info("Creating persona database tool...")
     
     try:
-        # First ensure we have the persona data (this will create it if needed)
+        # Try to load the persona data first
         try:
-            from retriever import create_persona_index
-            # This creates the index if it doesn't exist
-            create_persona_index()
-            logger.info("✅ Persona index ready")
-        except Exception as e:
-            logger.warning(f"⚠️ Could not ensure persona index: {e}")
+            from my_retriever import get_persona_query_engine
+            query_engine = get_persona_query_engine(llm=llm)
+        except ImportError:
+            # Fallback if my_retriever doesn't exist
+            query_engine = setup_persona_database(llm=llm)
         
-        # Create the query engine
-        query_engine = create_persona_query_engine()
+        if query_engine is None:
+            logger.warning("Couldn't create persona database")
+            return None
         
-        # Create the QueryEngineTool following course pattern
+        # Make the tool
         persona_tool = QueryEngineTool.from_defaults(
             query_engine=query_engine,
             name="persona_database",
             description=(
-                "Search and query a database of 5000 diverse personas with various backgrounds, "
-                "interests, and professions. Use this to find people with specific characteristics, "
-                "skills, or interests. Can answer questions like 'find writers', 'who likes travel', "
-                "'scientists in the group', 'creative professionals', or 'people interested in technology'. "
-                "Returns detailed information about matching personas with their backgrounds and interests."
+                "Search a database of people with different backgrounds and interests. "
+                "Use this to find people with specific skills, hobbies, or characteristics."
             )
         )
         
-        logger.info("✅ Persona database tool created successfully")
+        logger.info("Persona tool created")
         return persona_tool
         
     except Exception as e:
-        logger.error(f"❌ Error creating persona database tool: {e}")
-        # Return None so the agent can still work without this tool
+        logger.warning(f"Persona tool creation failed: {e}")
         return None
 
-
-# ============================================================================
-# PART 4: TOOL COLLECTION (Getting all tools together)
-# ============================================================================
-
-def get_all_tools() -> List:
+def get_my_tools(llm=None):
     """
-    Get all available tools for the GAIA agent.
-    
-    This function collects all tools and handles any creation errors gracefully.
-    The agent will work with whatever tools are successfully created.
-    
-    Returns:
-        List: All successfully created tools
+    Get all my tools together
+    This is what my agent will call
     """
-    logger.info("🔧 Collecting all tools...")
+    logger.info("Loading all my tools...")
     
     tools = []
     
-    # Add function-based tools (these should always work)
-    try:
-        tools.extend([
-            web_search_tool,
-            calculator_tool, 
-            file_analysis_tool,
-            weather_tool
-        ])
-        logger.info(f"✅ Added {len(tools)} function-based tools")
-    except Exception as e:
-        logger.error(f"❌ Error adding function tools: {e}")
+    # Add the basic function tools (these should always work)
+    basic_tools = [web_tool, calc_tool, file_tool, weather_tool]
+    tools.extend(basic_tools)
+    logger.info(f"Added {len(basic_tools)} basic tools")
     
-    # Add persona database tool (this might fail if database isn't ready)
-    try:
-        persona_tool = create_persona_database_tool()
-        if persona_tool:
-            tools.append(persona_tool)
-            logger.info("✅ Added persona database tool")
-        else:
-            logger.warning("⚠️ Persona database tool not available")
-    except Exception as e:
-        logger.warning(f"⚠️ Could not create persona database tool: {e}")
+    # Try to add the persona database tool
+    persona_tool = create_persona_tool(llm=llm)
+    if persona_tool:
+        tools.append(persona_tool)
+        logger.info("Added persona database tool")
+    else:
+        logger.info("Persona tool not available (that's ok)")
+    
+    logger.info(f"Total tools ready: {len(tools)}")
     
-    logger.info(f"🎯 Total tools available: {len(tools)}")
+    # Log what I have
     for tool in tools:
-        tool_name = getattr(tool.metadata, 'name', 'Unknown')
-        logger.info(f"   - {tool_name}")
+        logger.info(f"  - {tool.metadata.name}")
     
     return tools
 
+# ========================================
+# TESTING MY TOOLS
+# ========================================
 
-# ============================================================================
-# PART 5: TESTING FUNCTIONS (For development and debugging)
-# ============================================================================
-
-def test_individual_functions():
+def test_my_tools():
     """
-    Test each function individually to make sure they work.
-    This helps with debugging and understanding what each function does.
+    Quick test to make sure my tools work
     """
-    print("\n=== Testing Individual Functions ===")
-    
-    # Test web search
-    print("\n--- Testing Web Search Function ---")
-    try:
-        result = web_search("current year")
-        print(f"Web search result: {result[:150]}...")
-        print("✅ Web search function works")
-    except Exception as e:
-        print(f"❌ Web search failed: {e}")
+    print("\n=== Testing My Tools ===")
     
     # Test calculator
-    print("\n--- Testing Calculator Function ---")
-    try:
-        result = calculate("2 + 2 * 3")
-        print(f"Calculator result (2 + 2 * 3): {result}")
-        result = calculate("sqrt(16)")
-        print(f"Calculator result (sqrt(16)): {result}")
-        print("✅ Calculator function works")
-    except Exception as e:
-        print(f"❌ Calculator failed: {e}")
+    print("Testing calculator...")
+    result = do_math("2 + 2 * 3")
+    print(f"2 + 2 * 3 = {result}")
+    
+    result = do_math("sqrt(16)")
+    print(f"sqrt(16) = {result}")
     
     # Test file analyzer
-    print("\n--- Testing File Analysis Function ---")
-    try:
-        sample_csv = "name,age,city\nJohn,25,NYC\nJane,30,LA\nBob,35,SF"
-        result = analyze_file(sample_csv, "csv")
-        print(f"File analysis result: {result}")
-        print("✅ File analysis function works")
-    except Exception as e:
-        print(f"❌ File analysis failed: {e}")
+    print("\nTesting file analyzer...")
+    sample_csv = "name,age,city\nAlice,25,NYC\nBob,30,LA"
+    result = analyze_file(sample_csv, "csv")
+    print(f"CSV analysis:\n{result}")
     
     # Test weather
-    print("\n--- Testing Weather Function ---")
-    try:
-        result = get_weather("Paris")
-        print(f"Weather result: {result}")
-        print("✅ Weather function works")
-    except Exception as e:
-        print(f"❌ Weather failed: {e}")
-
-
-def test_tool_creation():
-    """
-    Test that all tools can be created successfully.
-    """
-    print("\n=== Testing Tool Creation ===")
+    print("\nTesting weather...")
+    result = get_weather("Paris")
+    print(f"Weather:\n{result}")
     
-    try:
-        tools = get_all_tools()
-        print(f"✅ Successfully created {len(tools)} tools")
-        
-        for tool in tools:
-            tool_name = getattr(tool.metadata, 'name', 'Unknown')
-            tool_desc = getattr(tool.metadata, 'description', 'No description')[:100]
-            print(f"   - {tool_name}: {tool_desc}...")
-            
-    except Exception as e:
-        print(f"❌ Tool creation failed: {e}")
-
-
-def test_tool_functionality():
-    """
-    Test that tools can actually be called and return results.
-    """
-    print("\n=== Testing Tool Functionality ===")
-    
-    tools = get_all_tools()
+    # Test tool creation
+    print("\nTesting tool creation...")
+    tools = get_my_tools()
+    print(f"Created {len(tools)} tools successfully!")
     
-    for tool in tools:
-        tool_name = getattr(tool.metadata, 'name', 'Unknown')
-        print(f"\n--- Testing {tool_name} ---")
-        
-        try:
-            if tool_name == "calculator":
-                # Test calculator tool
-                result = tool.func("5 * 8")
-                print(f"Calculator test (5 * 8): {result}")
-                
-            elif tool_name == "web_search":
-                # Test web search (might be slow)
-                print("Testing web search (this might take a moment)...")
-                result = tool.func("Python programming")
-                print(f"Web search test: {result[:100]}...")
-                
-            elif tool_name == "file_analyzer":
-                # Test file analyzer
-                test_data = "col1,col2\nval1,val2\nval3,val4"
-                result = tool.func(test_data, "csv")
-                print(f"File analyzer test: {result}")
-                
-            elif tool_name == "weather_tool":
-                # Test weather tool
-                result = tool.func("London")
-                print(f"Weather test: {result}")
-                
-            elif tool_name == "persona_database":
-                # Test persona database (might be slow on first run)
-                print("Testing persona database (this might take a moment)...")
-                # This would be an async call in real usage
-                print("Persona database test skipped (requires async)")
-                
-            print(f"✅ {tool_name} test completed")
-            
-        except Exception as e:
-            print(f"❌ {tool_name} test failed: {e}")
-
-
-# ============================================================================
-# MAIN EXECUTION (For testing when file is run directly)
-# ============================================================================
+    print("\n=== All Tests Done ===")
 
 if __name__ == "__main__":
-    print("GAIA Agent Tools Testing")
-    print("=" * 50)
-    
-    # Set up logging for testing
+    # Run tests if this file is called directly
+    import logging
     logging.basicConfig(level=logging.INFO)
     
-    # Test individual functions first
-    test_individual_functions()
-    
-    # Test tool creation
-    test_tool_creation()
-    
-    # Test tool functionality (optional - can be slow)
-    response = input("\nRun tool functionality tests? (y/n): ")
-    if response.lower() == 'y':
-        test_tool_functionality()
-    else:
-        print("Skipping functionality tests")
-    
-    print("\n=== Tools Testing Complete ===")
-    print("\nTo use these tools in your agent:")
-    print("from tools import get_all_tools")
-    print("tools = get_all_tools()")
-    
+    test_my_tools()