Fix GAIA API

agent/local_llm.py

@@ -1,19 +1,28 @@
-# agent/local_llm.py
-from transformers import AutoModelForCausalLM, AutoTokenizer
-from llama_index.llms.huggingface import HuggingFaceLLM
-import torch
+# File: agent/local_llm.py
+try:
+    from transformers import AutoModelForCausalLM, AutoTokenizer
+    from llama_index.llms.huggingface import HuggingFaceLLM
+    import torch
+except ImportError as e:
+    print(f"Import error in local_llm.py: {e}")
+    raise
 
 class LocalLLM:
     def __init__(self):
         # Use smaller model that works reliably
-        self.model_name = "microsoft/DialoGPT-medium"  # More stable alternative
+        self.model_name = "microsoft/DialoGPT-medium"
+        print(f"Initializing LocalLLM with model: {self.model_name}")
         self.llm = self._create_llama_index_llm()
     
     def _create_llama_index_llm(self):
         """Create LlamaIndex compatible LLM"""
         try:
-            # Load tokenizer and model
+            print("Loading tokenizer...")
             tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            if tokenizer.pad_token is None:
+                tokenizer.pad_token = tokenizer.eos_token
+            
+            print("Loading model...")
             model = AutoModelForCausalLM.from_pretrained(
                 self.model_name,
                 torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
@@ -21,7 +30,7 @@ class LocalLLM:
                 low_cpu_mem_usage=True
             )
             
-            # Create LlamaIndex LLM
+            print("Creating LlamaIndex LLM...")
             llm = HuggingFaceLLM(
                 model=model,
                 tokenizer=tokenizer,
@@ -33,6 +42,7 @@ class LocalLLM:
                 }
             )
             
+            print("LLM created successfully!")
             return llm
             
         except Exception as e:
@@ -42,6 +52,7 @@ class LocalLLM:
     
     def _create_fallback_llm(self):
         """Fallback to a very basic model"""
+        print("Using fallback model: gpt2")
         model_name = "gpt2"
         tokenizer = AutoTokenizer.from_pretrained(model_name)
         tokenizer.pad_token = tokenizer.eos_token

agent/tools.py

@@ -1,22 +1,47 @@
-# agent/tools.py
-from llama_index.core.tools import FunctionTool
-from utils.gaia_api import GaiaAPI
+# File: agent/tools.py
+try:
+    from llama_index.core.tools import FunctionTool
+    import sys
+    import os
+    
+    # Add the parent directory to the path so we can import utils
+    sys.path.append(os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+    
+    from utils.gaia_api import GaiaAPI
+except ImportError as e:
+    print(f"Import error in tools.py: {e}")
+    # Create a fallback GaiaAPI class if import fails
+    class GaiaAPI:
+        @classmethod
+        def get_questions(cls):
+            return [{"task_id": "fallback", "question": "What is 2+2?"}]
+        
+        @classmethod
+        def get_random_question(cls):
+            return {"task_id": "fallback", "question": "What is 2+2?"}
+
 import requests
 from typing import Optional
 import json
 
 def get_gaia_questions() -> str:
     """Fetch all GAIA benchmark questions for reference"""
-    questions = GaiaAPI.get_questions()
-    result = "Available GAIA Questions:\n"
-    for q in questions[:5]:  # Show first 5 questions
-        result += f"ID: {q['task_id']} - {q['question'][:100]}...\n"
-    return result
+    try:
+        questions = GaiaAPI.get_questions()
+        result = "Available GAIA Questions:\n"
+        for q in questions[:5]:  # Show first 5 questions
+            result += f"ID: {q['task_id']} - {q['question'][:100]}...\n"
+        return result
+    except Exception as e:
+        return f"Error fetching questions: {str(e)}"
 
 def get_random_gaia_question() -> str:
     """Get a single random GAIA question to work on"""
-    question = GaiaAPI.get_random_question()
-    return f"Task ID: {question['task_id']}\nQuestion: {question['question']}"
+    try:
+        question = GaiaAPI.get_random_question()
+        return f"Task ID: {question['task_id']}\nQuestion: {question['question']}"
+    except Exception as e:
+        return f"Error getting random question: {str(e)}"
 
 def search_web(query: str) -> str:
     """Search the web for information (mock implementation)"""
@@ -54,35 +79,39 @@ def get_current_info(topic: str) -> str:
     return f"Current information about '{topic}': This is a mock response. In a real implementation, this would fetch current information from reliable sources."
 
 # Create the tools list for the agent
-gaia_tools = [
-    FunctionTool.from_defaults(
-        fn=get_gaia_questions,
-        name="get_gaia_questions",
-        description="Fetch all available GAIA benchmark questions"
-    ),
-    FunctionTool.from_defaults(
-        fn=get_random_gaia_question,
-        name="get_random_question", 
-        description="Get a single random GAIA question to work on"
-    ),
-    FunctionTool.from_defaults(
-        fn=search_web,
-        name="search_web",
-        description="Search the web for information about a topic"
-    ),
-    FunctionTool.from_defaults(
-        fn=calculate,
-        name="calculate",
-        description="Perform mathematical calculations safely"
-    ),
-    FunctionTool.from_defaults(
-        fn=read_file_content,
-        name="read_file",
-        description="Read content from a file associated with GAIA tasks"
-    ),
-    FunctionTool.from_defaults(
-        fn=get_current_info,
-        name="get_current_info",
-        description="Get current information about a specific topic"
-    )
-]
+try:
+    gaia_tools = [
+        FunctionTool.from_defaults(
+            fn=get_gaia_questions,
+            name="get_gaia_questions",
+            description="Fetch all available GAIA benchmark questions"
+        ),
+        FunctionTool.from_defaults(
+            fn=get_random_gaia_question,
+            name="get_random_question", 
+            description="Get a single random GAIA question to work on"
+        ),
+        FunctionTool.from_defaults(
+            fn=search_web,
+            name="search_web",
+            description="Search the web for information about a topic"
+        ),
+        FunctionTool.from_defaults(
+            fn=calculate,
+            name="calculate",
+            description="Perform mathematical calculations safely"
+        ),
+        FunctionTool.from_defaults(
+            fn=read_file_content,
+            name="read_file",
+            description="Read content from a file associated with GAIA tasks"
+        ),
+        FunctionTool.from_defaults(
+            fn=get_current_info,
+            name="get_current_info",
+            description="Get current information about a specific topic"
+        )
+    ]
+except Exception as e:
+    print(f"Error creating tools: {e}")
+    gaia_tools = []

app.py

@@ -1,22 +1,34 @@
-# app.py
 import gradio as gr
 import os
-from typing import List, Dict
+import sys
 import json
+from typing import List, Dict
+
+# Add the current directory to Python path
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-# Import our modules
+# ✅ Ensure GaiaAPI is imported at the top level
+from utils.gaia_api import GaiaAPI
+
+# Initialize variables
+AGENT_READY = False
+agent = None
+
+# Import other agent modules
 try:
+    print("Importing modules...")
     from agent.local_llm import LocalLLM
     from agent.tools import gaia_tools
-    from utils.gaia_api import GaiaAPI
     from llama_index.core.agent import ReActAgent
     from llama_index.core.memory import ChatMemoryBuffer
-    
+
+    print("All imports successful!")
+
     # Initialize components
     print("Initializing Local LLM...")
     local_llm = LocalLLM()
     llm = local_llm.get_llm()
-    
+
     print("Creating ReAct Agent...")
     memory = ChatMemoryBuffer.from_defaults(token_limit=2000)
     agent = ReActAgent.from_tools(
@@ -24,14 +36,16 @@ try:
         llm=llm,
         memory=memory,
         verbose=True,
-        max_iterations=3  # Limit iterations to avoid long processing
+        max_iterations=3
     )
-    
+
     print("Agent initialized successfully!")
     AGENT_READY = True
-    
+
 except Exception as e:
     print(f"Failed to initialize agent: {str(e)}")
+    import traceback
+    traceback.print_exc()
     AGENT_READY = False
     agent = None
 
@@ -39,91 +53,81 @@ def process_single_question(question_text: str) -> str:
     """Process a single GAIA question through the agent"""
     if not AGENT_READY:
         return "❌ Agent not ready. Please check the logs for initialization errors."
-    
+
+    if not question_text.strip():
+        return "❌ Please enter a question."
+
     try:
-        # Add instruction to give direct answers only
         enhanced_prompt = f"""
         Answer the following question directly and concisely. Do not include "FINAL ANSWER" or any other prefixes in your response. Just provide the answer.
-        
+
         Question: {question_text}
         """
-        
         response = agent.query(enhanced_prompt)
-        
-        # Clean the response to ensure it's just the answer
         answer = str(response).strip()
-        
-        # Remove common prefixes that might appear
-        prefixes_to_remove = ["FINAL ANSWER:", "Answer:", "The answer is:", "Final answer:"]
-        for prefix in prefixes_to_remove:
+
+        # Remove common prefixes
+        for prefix in ["FINAL ANSWER:", "Answer:", "The answer is:", "Final answer:"]:
             if answer.startswith(prefix):
                 answer = answer[len(prefix):].strip()
-        
+
         return answer
-        
+
     except Exception as e:
-        return f"❌ Error processing question: {str(e)}"
+        import traceback
+        return f"❌ Error: {str(e)}\n\n{traceback.format_exc()}"
 
 def process_all_questions() -> str:
     """Process all GAIA questions and prepare answers for submission"""
     if not AGENT_READY:
-        return "❌ Agent not ready. Cannot process questions."
-    
+        return "❌ Agent not ready."
+
     try:
         questions = GaiaAPI.get_questions()
         processed_answers = []
-        
+
         for i, question in enumerate(questions):
             print(f"Processing question {i+1}/{len(questions)}: {question['task_id']}")
-            
             answer = process_single_question(question['question'])
-            
             processed_answers.append({
                 "task_id": question['task_id'],
                 "submitted_answer": answer
             })
-        
-        # Save answers to file for review
+
         with open("gaia_answers.json", "w") as f:
             json.dump(processed_answers, f, indent=2)
-        
+
         summary = f"✅ Processed {len(processed_answers)} questions.\n"
-        summary += f"Answers saved to gaia_answers.json\n"
-        summary += f"First 3 answers:\n"
-        
+        summary += "First 3 answers:\n"
         for ans in processed_answers[:3]:
             summary += f"- {ans['task_id']}: {ans['submitted_answer'][:50]}...\n"
-        
+
         return summary
-        
+
     except Exception as e:
-        return f"❌ Error processing all questions: {str(e)}"
+        import traceback
+        return f"❌ Error: {str(e)}\n\n{traceback.format_exc()}"
 
 def submit_to_gaia(username: str, code_url: str) -> str:
     """Submit answers to GAIA benchmark"""
     if not AGENT_READY:
-        return "❌ Agent not ready. Cannot submit."
-    
+        return "❌ Agent not ready."
+
     if not username or not code_url:
         return "❌ Please provide both username and code URL."
-    
+
+    try:
+        with open("gaia_answers.json", "r") as f:
+            answers = json.load(f)
+    except FileNotFoundError:
+        return "❌ No processed answers found. Please process them first."
+
     try:
-        # Load processed answers
-        try:
-            with open("gaia_answers.json", "r") as f:
-                answers = json.load(f)
-        except FileNotFoundError:
-            return "❌ No processed answers found. Please process questions first."
-        
-        # Submit to GAIA
         result = GaiaAPI.submit_answers(username, code_url, answers)
-        
         if "error" in result:
             return f"❌ Submission failed: {result['error']}"
-        
-        score = result.get('score', 'Unknown')
-        return f"✅ Submission successful!\n📊 Score: {score}\n🎯 Check the leaderboard for your ranking!"
-        
+        score = result.get("score", "Unknown")
+        return f"✅ Submission successful!\n📊 Score: {score}"
     except Exception as e:
         return f"❌ Submission error: {str(e)}"
 
@@ -135,19 +139,19 @@ def get_sample_question() -> str:
     except Exception as e:
         return f"Error loading sample question: {str(e)}"
 
-# Create Gradio interface
+# ---------- Gradio UI ----------
 with gr.Blocks(title="🦙 GAIA LlamaIndex Agent") as demo:
-    gr.Markdown("""
+    gr.Markdown(f"""
     # 🦙 GAIA Benchmark Agent with LlamaIndex
     
     This agent uses LlamaIndex with a local LLM to tackle GAIA benchmark questions.
     
     **Status:** {"✅ Ready" if AGENT_READY else "❌ Not Ready"}
     """)
-    
+
     with gr.Tab("🔬 Test Single Question"):
         gr.Markdown("Test the agent with individual questions")
-        
+
         with gr.Row():
             with gr.Column():
                 question_input = gr.Textbox(
@@ -158,88 +162,58 @@ with gr.Blocks(title="🦙 GAIA LlamaIndex Agent") as demo:
                 with gr.Row():
                     sample_btn = gr.Button("🎲 Load Sample Question")
                     process_btn = gr.Button("🚀 Process Question", variant="primary")
-            
+
             with gr.Column():
                 answer_output = gr.Textbox(
                     label="Agent Answer",
                     lines=5,
                     interactive=False
                 )
-        
+
         sample_btn.click(get_sample_question, outputs=question_input)
         process_btn.click(process_single_question, inputs=question_input, outputs=answer_output)
-    
+
     with gr.Tab("📊 Full Evaluation"):
         gr.Markdown("Process all GAIA questions and prepare for submission")
-        
-        with gr.Row():
-            process_all_btn = gr.Button("🔄 Process All Questions", variant="primary")
-            
-        processing_output = gr.Textbox(
-            label="Processing Status",
-            lines=10,
-            interactive=False
-        )
-        
+
+        process_all_btn = gr.Button("🔄 Process All Questions", variant="primary")
+        processing_output = gr.Textbox(label="Processing Status", lines=10, interactive=False)
+
         process_all_btn.click(process_all_questions, outputs=processing_output)
-    
+
     with gr.Tab("🏆 Submit to GAIA"):
         gr.Markdown("""
         Submit your processed answers to the GAIA benchmark for official scoring.
-        
+
         **Requirements:**
         1. Your Hugging Face username
-        2. Link to your Space code (e.g., `https://huggingface.co/spaces/YOUR_USERNAME/gaia-llamaindex-agent/tree/main`)
-        3. Questions must be processed first in the "Full Evaluation" tab
+        2. Link to your Space code (e.g., https://huggingface.co/spaces/your-username/gaia-agent)
         """)
-        
+
         with gr.Row():
             with gr.Column():
-                username_input = gr.Textbox(
-                    label="HF Username",
-                    placeholder="your-username"
-                )
-                code_url_input = gr.Textbox(
-                    label="Space Code URL",
-                    placeholder="https://huggingface.co/spaces/your-username/gaia-llamaindex-agent/tree/main"
-                )
+                username_input = gr.Textbox(label="HF Username", placeholder="your-username")
+                code_url_input = gr.Textbox(label="Space Code URL", placeholder="https://huggingface.co/spaces/your-username/gaia-agent")
                 submit_btn = gr.Button("🎯 Submit to GAIA", variant="primary")
-            
+
             with gr.Column():
-                submission_output = gr.Textbox(
-                    label="Submission Result",
-                    lines=5,
-                    interactive=False
-                )
-        
-        submit_btn.click(
-            submit_to_gaia,
-            inputs=[username_input, code_url_input],
-            outputs=submission_output
-        )
-    
-    with gr.Tab("ℹ️ Info"):
-        gr.Markdown("""
+                submission_output = gr.Textbox(label="Submission Result", lines=5, interactive=False)
+
+        submit_btn.click(submit_to_gaia, inputs=[username_input, code_url_input], outputs=submission_output)
+
+    with gr.Tab("ℹ️ Info & Debug"):
+        gr.Markdown(f"""
         ## About This Agent
         
-        This agent combines:
-        - **LlamaIndex**: For orchestrating the agent workflow
-        - **Local LLM**: Running entirely on Hugging Face Spaces  
-        - **ReAct Framework**: For reasoning and acting iteratively
-        - **GAIA Tools**: Web search, calculation, file reading, etc.
-        
-        ## Usage Tips
-        
-        1. **Start with single questions** to test the agent
-        2. **Process all questions** when ready for full evaluation
-        3. **Submit to GAIA** for official scoring
-        
-        ## Troubleshooting
+        This agent uses:
+        - **LlamaIndex** (ReAct Agent + Tools)
+        - **Local LLM** (e.g., DialoGPT or fallback GPT2)
+        - **GAIA Tools** (question fetch, file reader, math, etc.)
         
-        - If agent fails to initialize, check the model loading
-        - For memory issues, try restarting the Space
-        - For API errors, verify the GAIA endpoint URL
+        ## Current Status
+        - Agent Ready: {"✅ Yes" if AGENT_READY else "❌ No"}
+        - Tools Loaded: {len(gaia_tools) if 'gaia_tools' in globals() else 0}
         """)
 
 if __name__ == "__main__":
-    demo.launch(show_error=True)
+    demo.launch(show_error=True)

utils/gaia_api.py

@@ -1,4 +1,4 @@
-# utils/gaia_api.py
+# File: utils/gaia_api.py
 import requests
 from typing import List, Dict, Optional
 import json
@@ -7,7 +7,7 @@ class GaiaAPI:
     """Client for interacting with GAIA Benchmark API"""
     
     # Fixed API endpoint
-    BASE_URL = "https://agents-course-unit4-scoring.hf.space/random-question"
+    BASE_URL = "https://agents-course-unit4-scoring.hf.space"
     
     @classmethod
     def get_questions(cls) -> List[Dict]:
@@ -81,4 +81,4 @@ class GaiaAPI:
                 "level": 1,
                 "final_answer": "JavaScript, Python, PHP"
             }
-        ]
+        ]