Add agent and utils modules

Dockerfile

@@ -1,4 +1,5 @@
 # Use a base Python image with better compatibility
+ENV PYTHONPATH=/app
 FROM python:3.10-slim
 
 # Set environment variables to fix permission issues (use /tmp paths)

agent/local_llm.py

@@ -1,41 +1,38 @@
-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
+# File: agent/local_llm.py
+
+import torch
+from transformers import AutoTokenizer, AutoModelForCausalLM
+from llama_index.llms.huggingface import HuggingFaceLLM
 
 class LocalLLM:
     def __init__(self):
-        # Use a lightweight chat-compatible model that actually exists
         self.model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
         print(f"Initializing LocalLLM with model: {self.model_name}")
         self.llm = self._create_llama_index_llm()
 
     def _create_llama_index_llm(self):
         try:
-            print("Loading tokenizer...")
+            print("🔄 Loading tokenizer...")
             tokenizer = AutoTokenizer.from_pretrained(self.model_name)
 
-            print("Loading model...")
+            print("🧠 Loading model with 8-bit quantization...")
             model = AutoModelForCausalLM.from_pretrained(
                 self.model_name,
-                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
-                device_map="auto" if torch.cuda.is_available() else None,
-                low_cpu_mem_usage=True
+                load_in_8bit=True,  # Requires bitsandbytes
+                device_map="auto",
+                torch_dtype=torch.float16
             )
 
-            print("Creating LlamaIndex-compatible LLM...")
+            print("🔗 Wrapping in HuggingFaceLLM...")
             llm = HuggingFaceLLM(
                 model=model,
                 tokenizer=tokenizer,
                 context_window=2048,
                 generate_kwargs={"temperature": 0.7, "max_new_tokens": 256},
                 tokenizer_kwargs={"use_fast": True},
-                device_map="auto" if torch.cuda.is_available() else None
+                device_map="auto"
             )
-            print("✅ LLM created successfully!")
+            print("✅ LLM initialized successfully!")
             return llm
 
         except Exception as e:
@@ -43,13 +40,12 @@ class LocalLLM:
             return self._create_fallback_llm()
 
     def _create_fallback_llm(self):
-        print("⚠️ Falling back to GPT2 model")
-        model_name = "gpt2"
+        print("⚠️ Falling back to GPT2...")
+        fallback_model = "gpt2"
         try:
-            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            tokenizer = AutoTokenizer.from_pretrained(fallback_model)
             tokenizer.pad_token = tokenizer.eos_token
-
-            model = AutoModelForCausalLM.from_pretrained(model_name)
+            model = AutoModelForCausalLM.from_pretrained(fallback_model)
 
             return HuggingFaceLLM(
                 model=model,
@@ -57,25 +53,15 @@ class LocalLLM:
                 generate_kwargs={"temperature": 0.7, "max_new_tokens": 256},
             )
         except Exception as e:
-            print(f"⚠️ Fallback model also failed: {e}")
+            print(f"❌ Fallback model failed: {e}")
             return self._create_mock_llm()
 
     def _create_mock_llm(self):
-        print("⚠️ Using mock LLM")
+        print("🛠️ Using MockLLM fallback...")
         class MockLLM:
-            def chat(self, messages, **kwargs):
-                class MockResponse:
-                    def __init__(self, text):
-                        self.message = type('obj', (object,), {'content': text})
-                return MockResponse("Mock chat response: I would analyze this question and provide an answer.")
-            
             def complete(self, prompt, **kwargs):
-                class MockCompletion:
-                    def __init__(self, text):
-                        self.text = text
-                return MockCompletion("Mock completion response: I would analyze this question and provide an answer.")
-        
+                return type("Response", (), {"text": "Mock answer: I would respond here."})
         return MockLLM()
 
     def get_llm(self):
-        return self.llm
+        return self.llm

app.py

@@ -10,6 +10,7 @@ warnings.filterwarnings("ignore", category=FutureWarning)
 warnings.filterwarnings("ignore", category=UserWarning)
 
 import gradio as gr
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 # --- Environment variable setup to fix permission issues ---
 def setup_environment():

directory_structure_and_contents.txt

@@ -0,0 +1,1017 @@
+--- Contents of .\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 a lightweight chat-compatible model that actually exists
+        self.model_name = "TinyLlama/TinyLlama-1.1B-Chat-v1.0"
+        print(f"Initializing LocalLLM with model: {self.model_name}")
+        self.llm = self._create_llama_index_llm()
+
+    def _create_llama_index_llm(self):
+        try:
+            print("Loading tokenizer...")
+            tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+
+            print("Loading model...")
+            model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16 if torch.cuda.is_available() else torch.float32,
+                device_map="auto" if torch.cuda.is_available() else None,
+                low_cpu_mem_usage=True
+            )
+
+            print("Creating LlamaIndex-compatible LLM...")
+            llm = HuggingFaceLLM(
+                model=model,
+                tokenizer=tokenizer,
+                context_window=2048,
+                generate_kwargs={"temperature": 0.7, "max_new_tokens": 256},
+                tokenizer_kwargs={"use_fast": True},
+                device_map="auto" if torch.cuda.is_available() else None
+            )
+            print("✅ LLM created successfully!")
+            return llm
+
+        except Exception as e:
+            print(f"❌ Failed to load {self.model_name}: {e}")
+            return self._create_fallback_llm()
+
+    def _create_fallback_llm(self):
+        print("⚠️ Falling back to GPT2 model")
+        model_name = "gpt2"
+        try:
+            tokenizer = AutoTokenizer.from_pretrained(model_name)
+            tokenizer.pad_token = tokenizer.eos_token
+
+            model = AutoModelForCausalLM.from_pretrained(model_name)
+
+            return HuggingFaceLLM(
+                model=model,
+                tokenizer=tokenizer,
+                generate_kwargs={"temperature": 0.7, "max_new_tokens": 256},
+            )
+        except Exception as e:
+            print(f"⚠️ Fallback model also failed: {e}")
+            return self._create_mock_llm()
+
+    def _create_mock_llm(self):
+        print("⚠️ Using mock LLM")
+        class MockLLM:
+            def chat(self, messages, **kwargs):
+                class MockResponse:
+                    def __init__(self, text):
+                        self.message = type('obj', (object,), {'content': text})
+                return MockResponse("Mock chat response: I would analyze this question and provide an answer.")
+            
+            def complete(self, prompt, **kwargs):
+                class MockCompletion:
+                    def __init__(self, text):
+                        self.text = text
+                return MockCompletion("Mock completion response: I would analyze this question and provide an answer.")
+        
+        return MockLLM()
+
+    def get_llm(self):
+        return self.llm    tools.py
+
+--- Contents of .\agent\tools.py ---
+# 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"""
+    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"""
+    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)"""
+    try:
+        # This is a simplified web search - you might want to integrate real search API
+        # For now, return a mock response
+        return f"Search results for '{query}': This is a mock search result. In a real implementation, this would search the web and return relevant information."
+    except Exception as e:
+        return f"Search failed: {str(e)}"
+
+def calculate(expression: str) -> str:
+    """Safely evaluate mathematical expressions"""
+    try:
+        # Only allow safe mathematical operations
+        allowed_chars = set('0123456789+-*/.() ')
+        if not all(c in allowed_chars for c in expression):
+            return "Error: Invalid characters in expression"
+        
+        result = eval(expression)
+        return str(result)
+    except Exception as e:
+        return f"Calculation error: {str(e)}"
+
+def read_file_content(file_path: str) -> str:
+    """Read content from a file (for GAIA tasks that include files)"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        return content[:1000]  # Limit content length
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+def get_current_info(topic: str) -> str:
+    """Get current information about a topic"""
+    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
+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 = []    __init__.py
+
+--- Contents of .\agent\__init__.py ---
+
+--- Contents of .\.git\config ---
+[core]
+	repositoryformatversion = 0
+	filemode = false
+	bare = false
+	logallrefupdates = true
+	symlinks = false
+	ignorecase = true
+[remote "origin"]
+	url = https://huggingface.co/spaces/LamiaYT/Gaia_Llamaindex_Agent
+	fetch = +refs/heads/*:refs/remotes/origin/*
+[branch "main"]
+	remote = origin
+	merge = refs/heads/main
+	vscode-merge-base = origin/main
+	vscode-merge-base = origin/main
+    description
+
+--- Contents of .\.gitattributes ---
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+agent
+    local_llm.py
+
+   tools.py
+
+--- Contents of .\agent\tools.py ---
+# 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"""
+    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"""
+    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)"""
+    try:
+        # This is a simplified web search - you might want to integrate real search API
+        # For now, return a mock response
+        return f"Search results for '{query}': This is a mock search result. In a real implementation, this would search the web and return relevant information."
+    except Exception as e:
+        return f"Search failed: {str(e)}"
+
+def calculate(expression: str) -> str:
+    """Safely evaluate mathematical expressions"""
+    try:
+        # Only allow safe mathematical operations
+        allowed_chars = set('0123456789+-*/.() ')
+        if not all(c in allowed_chars for c in expression):
+            return "Error: Invalid characters in expression"
+        
+        result = eval(expression)
+        return str(result)
+    except Exception as e:
+        return f"Calculation error: {str(e)}"
+
+def read_file_content(file_path: str) -> str:
+    """Read content from a file (for GAIA tasks that include files)"""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            content = f.read()
+        return content[:1000]  # Limit content length
+    except Exception as e:
+        return f"Error reading file: {str(e)}"
+
+def get_current_info(topic: str) -> str:
+    """Get current information about a topic"""
+    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
+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 = []    __init__.py
+
+--- Contents of .\agent\__init__.py ---
+app.py
+
+--- Contents of .\app.py ---
+import os
+import sys
+import json
+import traceback
+from typing import List, Dict
+import warnings
+
+# Suppress warnings for cleaner output
+warnings.filterwarnings("ignore", category=FutureWarning)
+warnings.filterwarnings("ignore", category=UserWarning)
+
+import gradio as gr
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# --- Environment variable setup to fix permission issues ---
+def setup_environment():
+    env_vars = {
+        "NLTK_DATA": "/tmp/nltk_data",
+        "MPLCONFIGDIR": "/tmp/matplotlib_cache",
+        "HF_HOME": "/tmp/huggingface_cache",
+        "TORCH_HOME": "/tmp/torch_cache",
+        "TRANSFORMERS_CACHE": "/tmp/huggingface_cache"
+    }
+
+    for var, path in env_vars.items():
+        os.environ[var] = path
+        os.makedirs(path, exist_ok=True)
+
+    
+    for var, path in env_vars.items():
+        os.environ[var] = path
+        # Create directory if it doesn't exist
+        try:
+            os.makedirs(path, exist_ok=True)
+            print(f"✅ Created/verified directory: {path}")
+        except PermissionError:
+            print(f"⚠️ Permission denied for {path}, using /tmp fallback")
+            fallback_path = f"/tmp/{var.lower()}"
+            os.environ[var] = fallback_path
+            os.makedirs(fallback_path, exist_ok=True)
+        except Exception as e:
+            print(f"❌ Error setting up {var}: {e}")
+
+# Setup environment first
+setup_environment()
+
+# Import nltk AFTER setting environment variables
+try:
+    import nltk
+    # Download required NLTK data upfront
+    nltk.download('punkt', download_dir=os.environ["NLTK_DATA"], quiet=True)
+    nltk.download('stopwords', download_dir=os.environ["NLTK_DATA"], quiet=True)
+    print("✅ NLTK data downloaded successfully")
+except Exception as e:
+    print(f"⚠️ NLTK setup warning: {e}")
+
+# Add current directory to path for local imports
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+# Import dependencies with better error handling
+try:
+    from utils.gaia_api import GaiaAPI
+    print("✅ GaiaAPI imported successfully")
+except ImportError as e:
+    print(f"⚠️ Failed to import GaiaAPI: {e}")
+    # Create a fallback GaiaAPI
+    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?"}
+        @classmethod
+        def submit_answers(cls, username, code_url, answers):
+            return {"error": "GaiaAPI not available", "score": 0}
+
+# Initialize global agent state
+AGENT_READY = False
+agent = None
+initialization_error = None
+agent_info = {}
+
+def initialize_agent():
+    """Initialize the LlamaIndex agent with comprehensive error handling"""
+    global agent, AGENT_READY, initialization_error, agent_info
+    
+    try:
+        print("🔄 Starting agent initialization...")
+        
+        # Import agent-related modules
+        print("📦 Importing modules...")
+        from agent.local_llm import LocalLLM
+        from agent.tools import gaia_tools
+        from llama_index.core.agent import ReActAgent
+        from llama_index.core.memory import ChatMemoryBuffer
+        
+        agent_info["modules_imported"] = True
+        print("✅ All modules imported successfully!")
+
+        print("🤖 Initializing Local LLM...")
+        local_llm = LocalLLM()
+        llm = local_llm.get_llm()
+        agent_info["llm_type"] = llm.__class__.__name__
+        
+        print("🧠 Creating ReAct Agent...")
+        memory = ChatMemoryBuffer.from_defaults(token_limit=2000)
+        
+        # Check if we have a proper LLM or mock
+        if hasattr(llm, 'chat') and llm.__class__.__name__ != 'MockLLM':
+            agent = ReActAgent.from_tools(
+                tools=gaia_tools,
+                llm=llm,
+                memory=memory,
+                verbose=True,
+                max_iterations=3
+            )
+            agent_info["agent_type"] = "ReActAgent"
+            print("✅ ReAct Agent initialized successfully!")
+        else:
+            agent = llm  # Use the mock LLM directly
+            agent_info["agent_type"] = "MockLLM"
+            print("⚠️ Using mock mode - agent partially ready")
+        
+        agent_info["tools_count"] = len(gaia_tools) if 'gaia_tools' in locals() else 0
+        AGENT_READY = True
+        print("🎉 Agent initialization complete!")
+        
+    except Exception as e:
+        error_msg = f"Failed to initialize agent: {str(e)}"
+        print(f"❌ {error_msg}")
+        traceback.print_exc()
+        AGENT_READY = False
+        agent = None
+        initialization_error = error_msg
+        agent_info["error"] = error_msg
+
+# Initialize agent
+initialize_agent()
+
+def process_single_question(question_text: str) -> str:
+    """Process a single GAIA question through the agent"""
+    if not AGENT_READY:
+        error_msg = "❌ Agent not ready. "
+        if initialization_error:
+            error_msg += f"Error: {initialization_error}"
+        return error_msg
+
+    if not question_text.strip():
+        return "❌ Please enter a question."
+
+    try:
+        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}
+"""
+        
+        print(f"🤔 Processing question: {question_text[:50]}...")
+        
+        # FIXED: Use .complete() instead of .chat() to avoid chat template errors
+        if hasattr(agent, 'query'):
+            response = agent.query(enhanced_prompt)
+        elif hasattr(agent, 'complete'):
+            # Use complete() method for models without chat templates
+            response = agent.complete(enhanced_prompt)
+            answer = response.text if hasattr(response, 'text') else str(response)
+        elif hasattr(agent, 'chat'):
+            # Only use chat if it's the MockLLM or a proper chat model
+            try:
+                response = agent.chat([{"role": "user", "content": enhanced_prompt}])
+                answer = response.message.content if hasattr(response, 'message') else str(response)
+            except Exception as chat_error:
+                # Fallback to complete if chat fails
+                print(f"⚠️ Chat method failed, trying complete: {chat_error}")
+                if hasattr(agent, 'complete'):
+                    response = agent.complete(enhanced_prompt)
+                    answer = response.text if hasattr(response, 'text') else str(response)
+                else:
+                    raise chat_error
+        else:
+            answer = "Mock response: I would analyze this question and provide an answer."
+        
+        # Clean up the answer if it wasn't already processed above
+        if 'answer' not in locals():
+            answer = str(response).strip()
+
+        # Remove common prefixes from the answer
+        for prefix in ["FINAL ANSWER:", "Answer:", "The answer is:", "Final answer:"]:
+            if answer.startswith(prefix):
+                answer = answer[len(prefix):].strip()
+
+        print(f"✅ Generated answer: {answer[:50]}...")
+        return answer
+
+    except Exception as e:
+        error_msg = f"❌ Error processing question: {str(e)}"
+        print(error_msg)
+        return error_msg
+
+def process_all_questions() -> str:
+    """Process all GAIA questions and prepare answers for submission"""
+    if not AGENT_READY:
+        return "❌ Agent not ready."
+
+    try:
+        print("📥 Fetching all GAIA questions...")
+        questions = GaiaAPI.get_questions()
+        processed_answers = []
+
+        print(f"🔄 Processing {len(questions)} questions...")
+        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
+        output_file = "/app/gaia_answers.json"
+        with open(output_file, "w") as f:
+            json.dump(processed_answers, f, indent=2)
+
+        summary = f"✅ Processed {len(processed_answers)} questions.\n"
+        summary += f"💾 Answers saved to {output_file}\n"
+        summary += "📋 First 3 answers:\n"
+        for ans in processed_answers[:3]:
+            summary += f"- {ans['task_id']}: {ans['submitted_answer'][:50]}...\n"
+
+        print(summary)
+        return summary
+
+    except Exception as e:
+        error_msg = f"❌ Error processing questions: {str(e)}"
+        print(error_msg)
+        traceback.print_exc()
+        return error_msg
+
+def submit_to_gaia(username: str, code_url: str) -> str:
+    """Submit answers to GAIA benchmark"""
+    if not AGENT_READY:
+        return "❌ Agent not ready."
+
+    if not username or not code_url:
+        return "❌ Please provide both username and code URL."
+
+    try:
+        answers_file = "/app/gaia_answers.json"
+        with open(answers_file, "r") as f:
+            answers = json.load(f)
+        print(f"📤 Submitting {len(answers)} answers...")
+    except FileNotFoundError:
+        return "❌ No processed answers found. Please process them first."
+
+    try:
+        result = GaiaAPI.submit_answers(username, code_url, answers)
+        if "error" in result:
+            return f"❌ Submission failed: {result['error']}"
+        score = result.get("score", "Unknown")
+        success_msg = f"✅ Submission successful!\n📊 Score: {score}"
+        print(success_msg)
+        return success_msg
+    except Exception as e:
+        error_msg = f"❌ Submission error: {str(e)}"
+        print(error_msg)
+        return error_msg
+
+def get_sample_question() -> str:
+    """Load a sample question for testing"""
+    try:
+        question = GaiaAPI.get_random_question()
+        return question['question']
+    except Exception as e:
+        return f"Error loading sample question: {str(e)}"
+
+def get_system_status() -> str:
+    """Get detailed system status for debugging"""
+    status = "🔍 System Status:\n\n"
+    
+    # Agent status
+    status += f"🤖 Agent Ready: {'✅ Yes' if AGENT_READY else '❌ No'}\n"
+    if initialization_error:
+        status += f"❌ Error: {initialization_error}\n"
+    
+    # Agent info
+    status += f"🧠 LLM Type: {agent_info.get('llm_type', 'Unknown')}\n"
+    status += f"🔧 Agent Type: {agent_info.get('agent_type', 'Unknown')}\n"
+    status += f"🛠️ Tools Count: {agent_info.get('tools_count', 0)}\n"
+    
+    # Environment
+    status += "\n📁 Environment Variables:\n"
+    for var in ["NLTK_DATA", "HF_HOME", "MPLCONFIGDIR", "TORCH_HOME"]:
+        path = os.environ.get(var, 'Not set')
+        exists = "✅" if os.path.exists(path) else "❌"
+        status += f"  {var}: {path} {exists}\n"
+    
+    # Directory permissions
+    status += "\n📂 Directory Status:\n"
+    for path in ["/app", "/tmp"]:
+        try:
+            writable = os.access(path, os.W_OK)
+            status += f"  {path}: {'✅ Writable' if writable else '❌ Not writable'}\n"
+        except:
+            status += f"  {path}: ❌ Error checking\n"
+    
+    return status
+
+# ---------- Gradio UI ----------
+with gr.Blocks(title="🦙 GAIA LlamaIndex Agent", theme=gr.themes.Soft()) as demo:
+    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"}
+{f"**Error:** {initialization_error}" if initialization_error else ""}
+""")
+
+    with gr.Tab("🔬 Test Single Question"):
+        gr.Markdown("Test the agent with individual questions")
+
+        with gr.Row():
+            with gr.Column():
+                question_input = gr.Textbox(
+                    label="Question",
+                    placeholder="Enter a GAIA question or click 'Load Sample'",
+                    lines=3
+                )
+                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")
+
+        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-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-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("ℹ️ System Status"):
+        gr.Markdown("## System Information and Debugging")
+        
+        refresh_btn = gr.Button("🔄 Refresh Status")
+        status_output = gr.Textbox(label="System Status", lines=20, interactive=False)
+        
+        # Load initial status
+        demo.load(get_system_status, outputs=status_output)
+        refresh_btn.click(get_system_status, outputs=status_output)
+
+if __name__ == "__main__":
+    print("🚀 Starting Gradio interface...")
+    demo.launch(
+        server_name="0.0.0.0", 
+        server_port=7860, 
+        show_error=True
+        
+    )Dockerfile
+
+--- Contents of .\Dockerfile ---
+# Use a base Python image with better compatibility
+FROM python:3.10-slim
+
+# Set environment variables to fix permission issues (use /tmp paths)
+ENV PYTHONUNBUFFERED=1
+ENV NLTK_DATA=/tmp/nltk_data
+ENV MPLCONFIGDIR=/tmp/matplotlib_cache
+ENV HF_HOME=/tmp/huggingface_cache
+ENV TORCH_HOME=/tmp/torch_cache
+ENV TRANSFORMERS_CACHE=/tmp/huggingface_cache
+ENV GRADIO_SERVER_NAME=0.0.0.0
+ENV GRADIO_SERVER_PORT=7860
+
+# Create app user and group for better security
+RUN groupadd -r appuser && useradd -r -g appuser -u 1000 -m -s /bin/bash appuser
+
+# Set working directory
+WORKDIR /app
+
+# Create cache directories with proper permissions
+RUN mkdir -p /tmp/nltk_data \
+    /tmp/matplotlib_cache \
+    /tmp/huggingface_cache \
+    /tmp/torch_cache \
+    && chown -R appuser:appuser /tmp
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    gcc \
+    g++ \
+    git \
+    curl \
+    && rm -rf /var/lib/apt/lists/*
+
+# Copy requirements first for better Docker layer caching
+COPY requirements.txt .
+
+# Install Python dependencies
+RUN pip install --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy application code
+COPY . .
+
+# Change ownership of app files
+RUN chown -R appuser:appuser /app
+
+# Switch to non-root user
+USER appuser
+
+# Create a startup script
+RUN echo '#!/bin/bash\n\
+echo "Starting GAIA Agent..."\n\
+echo "Environment check:"\n\
+echo "NLTK_DATA: $NLTK_DATA"\n\
+echo "HF_HOME: $HF_HOME"\n\
+echo "MPLCONFIGDIR: $MPLCONFIGDIR"\n\
+echo "Working directory: $(pwd)"\n\
+echo "User: $(whoami)"\n\
+python app.py' > /app/start.sh && chmod +x /app/start.sh
+
+# Expose the port
+EXPOSE 7860
+
+# Health check (optional but helpful)
+HEALTHCHECK --interval=30s --timeout=10s --start-period=60s --retries=3 \
+    CMD curl -f http://localhost:7860/ || exit 1
+
+# Run the application
+CMD ["/app/start.sh"]
+models
+packages.txt
+
+--- Contents of .\packages.txt ---
+libgl1
+libglib2.0-0README.md
+
+--- Contents of .\README.md ---
+---
+title: Gaia Llamaindex Agent
+emoji: 📈
+colorFrom: pink
+colorTo: yellow
+sdk: docker
+pinned: false
+short_description: Gaia Llamaindex Agent
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+requirements.txt
+
+--- Contents of .\requirements.txt ---
+# Core dependencies
+gradio>=4.0.0
+requests>=2.31.0
+
+# LlamaIndex core
+llama-index>=0.10.0
+llama-index-llms-huggingface>=0.2.0
+
+# Transformers and ML libraries
+transformers>=4.35.0
+torch>=2.0.0
+tokenizers>=0.15.0
+
+# NLP dependencies
+nltk>=3.8.1
+
+# Data processing
+numpy>=1.24.0
+pandas>=2.0.0
+
+# Optional: for better model performance
+accelerate>=0.24.0
+bitsandbytes>=0.41.0
+
+# Utilities
+typing-extensions>=4.5.0
+pydantic>=2.0.0str.py
+
+--- Contents of .\str.py ---
+import os
+
+def write_file_contents(file_path, output_file):
+    """Write the contents of a file to the output file."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            output_file.write(f"\n--- Contents of {file_path} ---\n")
+            output_file.write(f.read())
+    except Exception as e:
+        output_file.write(f"Could not read file {file_path}: {e}\n")
+
+def write_structure_and_contents(dir_path, output_file, indent=0):
+    """Recursively write the directory structure and file contents to the output file."""
+    for item in os.listdir(dir_path):
+        path = os.path.join(dir_path, item)
+        output_file.write(' ' * indent + item + '\n')
+        if os.path.isdir(path):
+            write_structure_and_contents(path, output_file, indent + 4)
+        else:
+            write_file_contents(path, output_file)
+
+if __name__ == "__main__":
+    folder_path = '.'  # Change this to your folder path
+    output_file_path = 'directory_structure_and_contents.txt'  # Output file path
+
+    with open(output_file_path, 'w', encoding='utf-8') as output_file:
+        write_structure_and_contents(folder_path, output_file)
+    
+    print(f"Directory structure and contents have been written to {output_file_path}")
+utils
+    gaia_api.py
+
+--- Contents of .\utils\gaia_api.py ---
+# File: utils/gaia_api.py
+import requests
+from typing import List, Dict, Optional
+import json
+
+class GaiaAPI:
+    """Client for interacting with GAIA Benchmark API"""
+    
+    # Fixed API endpoint
+    BASE_URL = "https://agents-course-unit4-scoring.hf.space"
+    
+    @classmethod
+    def get_questions(cls) -> List[Dict]:
+        """Fetch all GAIA questions"""
+        try:
+            response = requests.get(f"{cls.BASE_URL}/questions")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            print(f"Error fetching questions: {str(e)}")
+            # Return sample questions for testing
+            return cls._get_sample_questions()
+    
+    @classmethod
+    def get_random_question(cls) -> Dict:
+        """Get a single random question"""
+        try:
+            response = requests.get(f"{cls.BASE_URL}/random-question")
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            print(f"Error fetching random question: {str(e)}")
+            return cls._get_sample_questions()[0]
+    
+    @classmethod
+    def get_file(cls, task_id: str) -> bytes:
+        """Download file associated with task"""
+        try:
+            response = requests.get(f"{cls.BASE_URL}/files/{task_id}")
+            response.raise_for_status()
+            return response.content
+        except Exception as e:
+            print(f"Error fetching file for task {task_id}: {str(e)}")
+            return b""
+    
+    @classmethod
+    def submit_answers(cls, username: str, agent_code: str, answers: List[Dict]) -> Dict:
+        """Submit answers to GAIA for scoring"""
+        try:
+            payload = {
+                "username": username,
+                "agent_code": agent_code,
+                "answers": answers
+            }
+            response = requests.post(f"{cls.BASE_URL}/submit", json=payload)
+            response.raise_for_status()
+            return response.json()
+        except Exception as e:
+            print(f"Error submitting answers: {str(e)}")
+            return {"error": str(e), "score": 0}
+    
+    @classmethod
+    def _get_sample_questions(cls) -> List[Dict]:
+        """Sample questions for testing when API is unavailable"""
+        return [
+            {
+                "task_id": "sample_001",
+                "question": "What is the capital of France?",
+                "level": 1,
+                "final_answer": "Paris"
+            },
+            {
+                "task_id": "sample_002", 
+                "question": "Calculate 15 * 8 + 7",
+                "level": 1,
+                "final_answer": "127"
+            },
+            {
+                "task_id": "sample_003",
+                "question": "Name three programming languages commonly used for web development",
+                "level": 1,
+                "final_answer": "JavaScript, Python, PHP"
+            }
+        ]    __init__.py
+
+--- Contents of .\utils\__init__.py ---

packages.txt

@@ -0,0 +1,2 @@
+libgl1
+libglib2.0-0

str.py

@@ -0,0 +1,29 @@
+import os
+
+def write_file_contents(file_path, output_file):
+    """Write the contents of a file to the output file."""
+    try:
+        with open(file_path, 'r', encoding='utf-8') as f:
+            output_file.write(f"\n--- Contents of {file_path} ---\n")
+            output_file.write(f.read())
+    except Exception as e:
+        output_file.write(f"Could not read file {file_path}: {e}\n")
+
+def write_structure_and_contents(dir_path, output_file, indent=0):
+    """Recursively write the directory structure and file contents to the output file."""
+    for item in os.listdir(dir_path):
+        path = os.path.join(dir_path, item)
+        output_file.write(' ' * indent + item + '\n')
+        if os.path.isdir(path):
+            write_structure_and_contents(path, output_file, indent + 4)
+        else:
+            write_file_contents(path, output_file)
+
+if __name__ == "__main__":
+    folder_path = '.'  # Change this to your folder path
+    output_file_path = 'directory_structure_and_contents.txt'  # Output file path
+
+    with open(output_file_path, 'w', encoding='utf-8') as output_file:
+        write_structure_and_contents(folder_path, output_file)
+    
+    print(f"Directory structure and contents have been written to {output_file_path}")