Update app.py

app.py

@@ -1,845 +1,875 @@
-import requests
+#!/usr/bin/env python3
+"""
+GAIA Benchmark AI Agent - Hugging Face Space
+============================================
+
+A Gradio-based web interface for running GAIA benchmark evaluations
+on Hugging Face Spaces with GPU acceleration.
+"""
+
+import gradio as gr
+import torch
 import json
-import re
-import ast
-import operator
-from typing import Dict, List, Any, Optional
+import os
+import logging
 import time
+import re
+from datetime import datetime
+from typing import Dict, List, Optional, Tuple, Any
+from dataclasses import dataclass
+import pandas as pd
+from pathlib import Path
 
-class GAIAAgent:
-    def __init__(self, api_base_url: str):
-        self.api_base_url = api_base_url
-        self.tools = self._initialize_tools()
-        self.max_retries = 3
-        self.timeout = 30
-        
-    def _initialize_tools(self):
-        """Initialize all available tools"""
-        return {
-            'web_search': WebSearchTool(),
-            'calculator': CalculatorTool(),
-            'file_processor': FileProcessorTool(self.api_base_url),
-            'text_analyzer': TextAnalyzerTool()
-        }
+# Core ML libraries
+from transformers import (
+    AutoTokenizer, 
+    AutoModelForCausalLM, 
+    BitsAndBytesConfig,
+    pipeline
+)
+from datasets import load_dataset
+from huggingface_hub import HfApi, hf_hub_download
+
+# Setup logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# ================================
+# CORE DATA STRUCTURES
+# ================================
+
+@dataclass
+class GAIAQuestion:
+    """Structure for GAIA benchmark questions"""
+    task_id: str
+    question: str
+    level: int
+    final_answer: Optional[str] = None
+    file_name: Optional[str] = None
+    annotator_metadata: Optional[Dict] = None
+    
+    @classmethod
+    def from_dict(cls, data: dict):
+        return cls(**{k: v for k, v in data.items() if k in cls.__annotations__})
+
+@dataclass
+class GAIAResponse:
+    """Structure for GAIA responses"""
+    task_id: str
+    model_answer: str
+    reasoning_trace: str
+    final_answer: str
+    processing_time: float = 0.0
+    confidence_score: float = 0.0
+
+# ================================
+# GAIA PROMPT MANAGEMENT
+# ================================
+
+class GAIAPromptManager:
+    """Manages GAIA-specific prompting and formatting"""
     
-    def solve_question(self, question_data: Dict) -> str:
-        """Main pipeline to solve a GAIA question"""
-        try:
-            # Step 1: Analyze the question
-            analysis = self._analyze_question(question_data)
-            print(f"Question analysis: {analysis}")
-            
-            # Step 2: Create execution plan
-            plan = self._create_execution_plan(analysis, question_data)
-            print(f"Execution plan: {[step['action'] for step in plan]}")
-            
-            # Step 3: Execute plan
-            results = self._execute_plan(plan, question_data)
-            print(f"Execution results keys: {list(results.keys())}")
-            
-            # Step 4: Generate final answer
-            final_answer = self._generate_final_answer(results, question_data)
-            
-            # Step 5: Format and validate answer
-            formatted_answer = self._format_final_answer(final_answer)
-            
-            return formatted_answer
+    GAIA_SYSTEM_PROMPT = """You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template:
+
+FINAL ANSWER: [YOUR FINAL ANSWER]
+
+YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither use units such as $ or percent sign unless specified otherwise. If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string."""
+
+    @staticmethod
+    def create_gaia_prompt(question: str) -> str:
+        """Create properly formatted GAIA prompt"""
+        return f"{GAIAPromptManager.GAIA_SYSTEM_PROMPT}\n\nQuestion: {question}\n\nLet me think step by step:"
+
+    @staticmethod
+    def extract_final_answer(response: str) -> Tuple[str, str]:
+        """Extract final answer and reasoning from model response"""
+        final_answer_pattern = r"FINAL ANSWER:\s*(.+?)(?:\n|$)"
+        match = re.search(final_answer_pattern, response, re.IGNORECASE | re.DOTALL)
+        
+        if match:
+            final_answer = match.group(1).strip()
+            reasoning_end = match.start()
+            reasoning = response[:reasoning_end].strip()
+        else:
+            lines = response.strip().split('\n')
+            final_answer = lines[-1].strip() if lines else ""
+            reasoning = '\n'.join(lines[:-1]) if len(lines) > 1 else response
             
-        except Exception as e:
-            print(f"Error solving question: {e}")
-            return "Unable to determine answer"
-    
-    def _analyze_question(self, question_data: Dict) -> Dict:
-        """Analyze question to determine approach and required tools"""
-        question = question_data.get('question', '')
-        has_file = bool(question_data.get('file_name'))
-        
-        # Classify question type
-        question_lower = question.lower()
-        
-        analysis = {
-            'needs_calculation': any(word in question_lower for word in 
-                                   ['calculate', 'compute', 'sum', 'total', 'average', 'count', 'multiply', 'divide']),
-            'needs_web_search': any(word in question_lower for word in 
-                                  ['who', 'what', 'when', 'where', 'find', 'search', 'latest', 'current']),
-            'needs_file_processing': has_file,
-            'is_factual_question': any(word in question_lower for word in 
-                                     ['who is', 'what is', 'when was', 'where is']),
-            'needs_analysis': any(word in question_lower for word in 
-                                ['analyze', 'compare', 'determine', 'evaluate']),
-            'question_text': question,
-            'has_file': has_file,
-            'file_name': question_data.get('file_name', '')
+        return final_answer, reasoning
+
+# ================================
+# HF SPACES OPTIMIZED MODEL MANAGER
+# ================================
+
+class HFSpaceModelManager:
+    """Hugging Face Spaces optimized model manager"""
+    
+    # Space-friendly models with different capabilities
+    SPACE_MODELS = {
+        "Fast & Light": {
+            "name": "microsoft/DialoGPT-medium",
+            "size": "~345MB",
+            "speed": "Fast",
+            "quality": "Good",
+            "gpu_required": False
+        },
+        "Balanced": {
+            "name": "stabilityai/stablelm-zephyr-3b", 
+            "size": "~3GB",
+            "speed": "Medium", 
+            "quality": "Better",
+            "gpu_required": True
+        },
+        "High Quality": {
+            "name": "HuggingFaceH4/zephyr-7b-beta",
+            "size": "~7GB",
+            "speed": "Slower",
+            "quality": "Best", 
+            "gpu_required": True
+        },
+        "Instruction Following": {
+            "name": "mistralai/Mistral-7B-Instruct-v0.1",
+            "size": "~7GB", 
+            "speed": "Medium",
+            "quality": "Excellent",
+            "gpu_required": True
         }
-        
-        return analysis
-    
-    def _create_execution_plan(self, analysis: Dict, question_data: Dict) -> List[Dict]:
-        """Create step-by-step execution plan"""
-        plan = []
-        
-        # Priority 1: Process files if they exist
-        if analysis['needs_file_processing']:
-            plan.append({
-                'action': 'process_file',
-                'tool': 'file_processor',
-                'priority': 1,
-                'params': {
-                    'task_id': question_data.get('task_id'),
-                    'file_name': question_data.get('file_name')
-                }
-            })
-        
-        # Priority 2: Web search for factual information
-        if analysis['needs_web_search'] or analysis['is_factual_question']:
-            plan.append({
-                'action': 'web_search',
-                'tool': 'web_search',
-                'priority': 2,
-                'params': {
-                    'query': self._extract_search_query(analysis['question_text'])
-                }
-            })
-        
-        # Priority 3: Calculations
-        if analysis['needs_calculation']:
-            plan.append({
-                'action': 'calculate',
-                'tool': 'calculator',
-                'priority': 3,
-                'params': {}
-            })
-        
-        # Priority 4: Text analysis
-        plan.append({
-            'action': 'analyze_text',
-            'tool': 'text_analyzer',
-            'priority': 4,
-            'params': {
-                'text': analysis['question_text']
-            }
-        })
-        
-        return sorted(plan, key=lambda x: x['priority'])
-    
-    def _execute_plan(self, plan: List[Dict], question_data: Dict) -> Dict:
-        """Execute the planned steps"""
-        results = {}
-        
-        for step in plan:
-            tool_name = step['tool']
-            action = step['action']
+    }
+    
+    def __init__(self, model_choice: str = "Fast & Light"):
+        self.model_config = self.SPACE_MODELS[model_choice]
+        self.model_name = self.model_config["name"]
+        self.tokenizer = None
+        self.model = None
+        self.pipeline = None
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        
+    def load_model(self, progress_callback=None) -> str:
+        """Load model with progress updates"""
+        try:
+            if progress_callback:
+                progress_callback(0.1, "Loading tokenizer...")
             
-            try:
-                print(f"Executing: {action}")
+            # Load tokenizer
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            if self.tokenizer.pad_token is None:
+                self.tokenizer.pad_token = self.tokenizer.eos_token
                 
-                if action == 'process_file':
-                    results['file_data'] = self.tools[tool_name].process_file(
-                        step['params']['task_id'],
-                        step['params']['file_name']
-                    )
+            if progress_callback:
+                progress_callback(0.3, "Configuring model...")
+            
+            # Configure quantization for GPU spaces
+            quantization_config = None
+            if self.device == "cuda" and "7b" in self.model_name.lower():
+                quantization_config = BitsAndBytesConfig(
+                    load_in_4bit=True,
+                    bnb_4bit_compute_dtype=torch.float16,
+                    bnb_4bit_use_double_quant=True,
+                    bnb_4bit_quant_type="nf4"
+                )
+            
+            if progress_callback:
+                progress_callback(0.6, "Loading model weights...")
+            
+            # Load model
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                quantization_config=quantization_config,
+                device_map="auto" if self.device == "cuda" else None,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                trust_remote_code=True
+            )
+            
+            if progress_callback:
+                progress_callback(0.9, "Creating pipeline...")
+            
+            # Create pipeline
+            self.pipeline = pipeline(
+                "text-generation",
+                model=self.model,
+                tokenizer=self.tokenizer,
+                max_new_tokens=384,
+                temperature=0.7,
+                do_sample=True,
+                pad_token_id=self.tokenizer.eos_token_id,
+                device=0 if self.device == "cuda" else -1
+            )
+            
+            if progress_callback:
+                progress_callback(1.0, "Model loaded successfully!")
                 
-                elif action == 'web_search':
-                    results['search_data'] = self.tools[tool_name].search(
-                        step['params']['query']
-                    )
-                
-                elif action == 'calculate':
-                    # Extract numbers and operations from question and file data
-                    calculation_input = self._prepare_calculation_input(
-                        question_data, results
-                    )
-                    if calculation_input:
-                        results['calculation'] = self.tools[tool_name].calculate(
-                            calculation_input
-                        )
-                
-                elif action == 'analyze_text':
-                    results['text_analysis'] = self.tools[tool_name].analyze(
-                        step['params']['text'],
-                        context=results
-                    )
-                
-            except Exception as e:
-                print(f"Error in {action}: {e}")
-                results[f'{action}_error'] = str(e)
-        
-        return results
-    
-    def _extract_search_query(self, question: str) -> str:
-        """Extract relevant search query from question"""
-        # Remove question words and extract key terms
-        question_words = ['what', 'who', 'when', 'where', 'how', 'why', 'is', 'are', 'was', 'were']
-        words = question.lower().split()
-        
-        # Keep important words, remove common question words
-        filtered_words = [word for word in words if word not in question_words and len(word) > 2]
-        
-        return ' '.join(filtered_words[:6])  # Limit to 6 words
-    
-    def _prepare_calculation_input(self, question_data: Dict, results: Dict) -> Optional[str]:
-        """Prepare input for calculator based on question and available data"""
-        question = question_data.get('question', '')
-        
-        # Extract numbers from question
-        numbers = re.findall(r'\d+\.?\d*', question)
-        
-        # Look for mathematical operations
-        if 'sum' in question.lower() or 'total' in question.lower():
-            if numbers:
-                return '+'.join(numbers)
-        elif 'multiply' in question.lower() or 'product' in question.lower():
-            if numbers:
-                return '*'.join(numbers)
-        elif 'average' in question.lower():
-            if numbers:
-                return f"({'+'.join(numbers)})/{len(numbers)}"
-        
-        # Check if file data contains numbers for calculation
-        if 'file_data' in results and isinstance(results['file_data'], dict):
-            file_numbers = results['file_data'].get('numbers', [])
-            if file_numbers and ('sum' in question.lower() or 'total' in question.lower()):
-                return '+'.join(map(str, file_numbers))
-        
-        return None
-    
-    def _generate_final_answer(self, results: Dict, question_data: Dict) -> str:
-        """Generate final answer based on execution results"""
-        question = question_data.get('question', '').lower()
-        
-        # Priority order for answer selection
-        if 'calculation' in results and results['calculation'] is not None:
-            return str(results['calculation'])
-        
-        if 'file_data' in results and isinstance(results['file_data'], dict):
-            # Look for specific answer in file data
-            if 'answer' in results['file_data']:
-                return str(results['file_data']['answer'])
-            elif 'summary' in results['file_data']:
-                return str(results['file_data']['summary'])
-        
-        if 'search_data' in results and results['search_data']:
-            # Extract answer from search results
-            for result in results['search_data']:
-                if isinstance(result, dict) and 'summary' in result:
-                    return result['summary']
-        
-        if 'text_analysis' in results:
-            return str(results['text_analysis'])
-        
-        return "Unable to determine answer"
+            return f"✅ Model '{self.model_name}' loaded successfully on {self.device.upper()}"
+            
+        except Exception as e:
+            error_msg = f"❌ Error loading model: {str(e)}"
+            logger.error(error_msg)
+            return error_msg
     
-    def _format_final_answer(self, answer: str) -> str:
-        """Format the final answer for exact match scoring"""
-        if not answer:
-            return "No answer found"
+    def generate_response(self, prompt: str, max_tokens: int = 384) -> str:
+        """Generate response with error handling"""
+        if self.pipeline is None:
+            return "❌ Model not loaded. Please load a model first."
         
-        # Convert to string and strip whitespace
-        answer = str(answer).strip()
-        
-        # Remove common prefixes that might cause exact match failures
-        prefixes_to_remove = [
-            'the answer is: ',
-            'answer: ',
-            'final answer: ',
-            'result: ',
-            'solution: '
-        ]
-        
-        answer_lower = answer.lower()
-        for prefix in prefixes_to_remove:
-            if answer_lower.startswith(prefix):
-                answer = answer[len(prefix):].strip()
-                break
-        
-        # Handle numeric answers
-        if self._is_numeric_answer(answer):
-            return self._format_numeric_answer(answer)
-        
-        # Handle yes/no answers
-        if answer.lower() in ['yes', 'no', 'true', 'false']:
-            return answer.lower()
-        
-        # Return cleaned text answer
-        return answer
-    
-    def _is_numeric_answer(self, answer: str) -> bool:
-        """Check if answer is numeric"""
         try:
-            float(answer)
-            return True
-        except ValueError:
-            return False
-    
-    def _format_numeric_answer(self, answer: str) -> str:
-        """Format numeric answers consistently"""
-        try:
-            num = float(answer)
-            if num.is_integer():
-                return str(int(num))
-            else:
-                # Round to 6 decimal places to avoid floating point issues
-                return str(round(num, 6)).rstrip('0').rstrip('.')
-        except ValueError:
-            return answer
-
-
-class WebSearchTool:
-    """Simple web search tool (implement with your preferred search API)"""
-    
-    def search(self, query: str, max_results: int = 3) -> List[Dict]:
-        """Perform web search - implement with your preferred search service"""
-        print(f"Web search: {query}")
-        
-        # Placeholder implementation
-        # Replace with actual search API (DuckDuckGo, Google Custom Search, etc.)
-        return [
-            {
-                'title': f'Search result for: {query}',
-                'summary': f'Information about {query}',
-                'url': 'https://example.com'
-            }
-        ]
+            # Truncate prompt if too long
+            max_input_length = 1000
+            if len(prompt) > max_input_length:
+                prompt = prompt[:max_input_length] + "..."
+            
+            outputs = self.pipeline(
+                prompt,
+                max_new_tokens=max_tokens,
+                temperature=0.7,
+                do_sample=True,
+                return_full_text=False,
+                pad_token_id=self.tokenizer.eos_token_id
+            )
+            
+            response = outputs[0]['generated_text'].strip()
+            return response
+            
+        except Exception as e:
+            return f"❌ Error generating response: {str(e)}"
 
+# ================================
+# DATASET MANAGEMENT
+# ================================
 
-class CalculatorTool:
-    """Safe calculator for mathematical expressions"""
+class GAIADatasetManager:
+    """Manages GAIA dataset loading and sample generation"""
     
-    def calculate(self, expression: str) -> Optional[float]:
-        """Safely evaluate mathematical expressions"""
+    @staticmethod
+    def load_gaia_dataset(split: str = "test", max_questions: int = None) -> Tuple[List[GAIAQuestion], str]:
+        """Load GAIA dataset from Hugging Face Hub"""
         try:
-            # Remove whitespace
-            expression = expression.replace(' ', '')
+            dataset = load_dataset("gaia-benchmark/GAIA", split=split, trust_remote_code=True)
             
-            # Basic safety check
-            allowed_chars = set('0123456789+-*/().e')
-            if not all(c in allowed_chars for c in expression):
-                raise ValueError("Invalid characters in expression")
+            questions = []
+            items = dataset[:max_questions] if max_questions else dataset
             
-            # Use ast for safe evaluation
-            node = ast.parse(expression, mode='eval')
-            result = self._eval_node(node.body)
+            for i, item in enumerate(items):
+                question = GAIAQuestion(
+                    task_id=item.get('task_id', f'gaia_{split}_{i:03d}'),
+                    question=item['Question'],
+                    level=item['Level'],
+                    final_answer=item.get('Final answer', None),
+                    file_name=item.get('file_name', None),
+                    annotator_metadata=item.get('Annotator Metadata', None)
+                )
+                questions.append(question)
             
-            return result
+            status = f"✅ Loaded {len(questions)} questions from GAIA {split} split"
+            return questions, status
             
         except Exception as e:
-            print(f"Calculation error: {e}")
-            return None
+            error_msg = f"❌ Error loading GAIA dataset: {str(e)}"
+            return GAIADatasetManager.get_sample_questions(), error_msg
     
-    def _eval_node(self, node):
-        """Recursively evaluate AST node"""
-        if isinstance(node, ast.Constant):
-            return node.value
-        elif isinstance(node, ast.Num):  # Python < 3.8
-            return node.n
-        elif isinstance(node, ast.BinOp):
-            left = self._eval_node(node.left)
-            right = self._eval_node(node.right)
-            
-            if isinstance(node.op, ast.Add):
-                return left + right
-            elif isinstance(node.op, ast.Sub):
-                return left - right
-            elif isinstance(node.op, ast.Mult):
-                return left * right
-            elif isinstance(node.op, ast.Div):
-                return left / right
-            elif isinstance(node.op, ast.Pow):
-                return left ** right
-        elif isinstance(node, ast.UnaryOp):
-            operand = self._eval_node(node.operand)
-            if isinstance(node.op, ast.USub):
-                return -operand
-            elif isinstance(node.op, ast.UAdd):
-                return +operand
+    @staticmethod
+    def get_sample_questions() -> List[GAIAQuestion]:
+        """Get sample questions for testing"""
+        sample_data = [
+            {
+                "task_id": "sample_001",
+                "question": "What is the capital of France?",
+                "level": 1,
+                "final_answer": "Paris"
+            },
+            {
+                "task_id": "sample_002", 
+                "question": "Calculate 144 divided by 12.",
+                "level": 1,
+                "final_answer": "12"
+            },
+            {
+                "task_id": "sample_003",
+                "question": "What is the largest planet in our solar system?",
+                "level": 1,
+                "final_answer": "Jupiter"
+            },
+            {
+                "task_id": "sample_004",
+                "question": "Convert 100 degrees Celsius to Fahrenheit.",
+                "level": 2,
+                "final_answer": "212"
+            },
+            {
+                "task_id": "sample_005",
+                "question": "List the first three even numbers greater than zero.",
+                "level": 1,
+                "final_answer": "2, 4, 6"
+            },
+            {
+                "task_id": "sample_006",
+                "question": "What year did the Berlin Wall fall?",
+                "level": 1,
+                "final_answer": "1989"
+            },
+            {
+                "task_id": "sample_007",
+                "question": "What is the chemical symbol for water?",
+                "level": 1,
+                "final_answer": "H2O"
+            },
+            {
+                "task_id": "sample_008",
+                "question": "How many continents are there?",
+                "level": 1,
+                "final_answer": "7"
+            }
+        ]
         
-        raise ValueError(f"Unsupported operation: {type(node)}")
+        return [GAIAQuestion.from_dict(data) for data in sample_data]
 
+# ================================
+# MAIN GAIA AGENT FOR HF SPACES
+# ================================
 
-class FileProcessorTool:
-    """Tool for processing files from GAIA tasks"""
-    
-    def __init__(self, api_base_url: str):
-        self.api_base_url = api_base_url
+class GAIASpaceAgent:
+    """Main GAIA agent optimized for Hugging Face Spaces"""
     
-    def process_file(self, task_id: str, file_name: str) -> Dict:
-        """Process file associated with a task"""
-        try:
-            # Download file
-            file_content = self._download_file(task_id)
-            
-            # Process based on file extension
-            if file_name.endswith('.csv'):
-                return self._process_csv(file_content)
-            elif file_name.endswith('.txt'):
-                return self._process_text(file_content)
-            elif file_name.endswith('.json'):
-                return self._process_json(file_content)
-            else:
-                return self._process_generic(file_content)
-                
-        except Exception as e:
-            print(f"File processing error: {e}")
-            return {'error': str(e)}
-    
-    def _download_file(self, task_id: str) -> bytes:
-        """Download file from API"""
-        response = requests.get(f"{self.api_base_url}/files/{task_id}")
-        response.raise_for_status()
-        return response.content
-    
-    def _process_csv(self, content: bytes) -> Dict:
-        """Process CSV file"""
+    def __init__(self):
+        self.model_manager = None
+        self.prompt_manager = GAIAPromptManager()
+        self.current_model = None
+        self.evaluation_results: List[GAIAResponse] = []
+        
+    def initialize_model(self, model_choice: str, progress=gr.Progress()) -> str:
+        """Initialize model with progress tracking"""
         try:
-            import io
-            import csv
-            
-            # Convert bytes to string
-            text_content = content.decode('utf-8')
-            
-            # Parse CSV
-            reader = csv.reader(io.StringIO(text_content))
-            rows = list(reader)
-            
-            if not rows:
-                return {'error': 'Empty CSV file'}
-            
-            headers = rows[0] if rows else []
-            data_rows = rows[1:] if len(rows) > 1 else []
-            
-            # Extract numbers for potential calculations
-            numbers = []
-            for row in data_rows:
-                for cell in row:
-                    try:
-                        numbers.append(float(cell))
-                    except ValueError:
-                        continue
-            
-            return {
-                'type': 'csv',
-                'headers': headers,
-                'rows': data_rows,
-                'row_count': len(data_rows),
-                'numbers': numbers,
-                'summary': f'CSV with {len(headers)} columns and {len(data_rows)} rows'
-            }
+            progress(0, desc="Initializing model manager...")
+            self.model_manager = HFSpaceModelManager(model_choice)
+            self.current_model = model_choice
             
-        except Exception as e:
-            return {'error': f'CSV processing failed: {e}'}
-    
-    def _process_text(self, content: bytes) -> Dict:
-        """Process text file"""
-        try:
-            text = content.decode('utf-8')
-            
-            # Extract numbers from text
-            numbers = [float(match) for match in re.findall(r'\d+\.?\d*', text)]
-            
-            # Basic text analysis
-            lines = text.split('\n')
-            words = text.split()
-            
-            return {
-                'type': 'text',
-                'content': text,
-                'line_count': len(lines),
-                'word_count': len(words),
-                'numbers': numbers,
-                'summary': f'Text file with {len(lines)} lines and {len(words)} words'
-            }
+            # Load model with progress updates
+            def progress_callback(value, desc):
+                progress(value, desc=desc)
             
-        except Exception as e:
-            return {'error': f'Text processing failed: {e}'}
-    
-    def _process_json(self, content: bytes) -> Dict:
-        """Process JSON file"""
-        try:
-            data = json.loads(content.decode('utf-8'))
+            result = self.model_manager.load_model(progress_callback)
             
-            # Extract numbers from JSON structure
-            numbers = self._extract_numbers_from_json(data)
+            # Clear any previous results when changing models
+            self.evaluation_results = []
             
-            return {
-                'type': 'json',
-                'data': data,
-                'numbers': numbers,
-                'summary': f'JSON file with {len(data) if isinstance(data, (list, dict)) else 1} items'
-            }
+            return result
             
         except Exception as e:
-            return {'error': f'JSON processing failed: {e}'}
+            return f"❌ Failed to initialize model: {str(e)}"
     
-    def _process_generic(self, content: bytes) -> Dict:
-        """Process generic file"""
-        try:
-            # Try to decode as text first
-            try:
-                text = content.decode('utf-8')
-                return self._process_text(content)
-            except UnicodeDecodeError:
-                # Binary file
-                return {
-                    'type': 'binary',
-                    'size': len(content),
-                    'summary': f'Binary file of {len(content)} bytes'
-                }
-                
-        except Exception as e:
-            return {'error': f'Generic processing failed: {e}'}
-    
-    def _extract_numbers_from_json(self, data, numbers=None):
-        """Recursively extract numbers from JSON structure"""
-        if numbers is None:
-            numbers = []
+    def process_single_question(self, question_text: str, progress=gr.Progress()) -> Tuple[str, str, str, float]:
+        """Process a single question with detailed output"""
+        if self.model_manager is None or self.model_manager.pipeline is None:
+            return "❌ No model loaded", "", "", 0.0
         
-        if isinstance(data, (int, float)):
-            numbers.append(float(data))
-        elif isinstance(data, dict):
-            for value in data.values():
-                self._extract_numbers_from_json(value, numbers)
-        elif isinstance(data, list):
-            for item in data:
-                self._extract_numbers_from_json(item, numbers)
+        start_time = time.time()
         
-        return numbers
-
-
-class TextAnalyzerTool:
-    """Tool for analyzing and extracting information from text"""
-    
-    def analyze(self, text: str, context: Dict = None) -> str:
-        """Analyze text and extract relevant information"""
         try:
-            # Basic keyword extraction
-            keywords = self._extract_keywords(text)
+            progress(0.2, desc="Creating GAIA prompt...")
+            
+            # Create GAIA prompt
+            prompt = self.prompt_manager.create_gaia_prompt(question_text)
+            
+            progress(0.4, desc="Generating response...")
             
-            # Look for specific patterns based on question type
-            if any(word in text.lower() for word in ['who', 'what', 'when', 'where']):
-                return self._analyze_question_pattern(text, context)
+            # Generate response
+            raw_response = self.model_manager.generate_response(prompt)
             
-            # Look for calculations
-            if any(word in text.lower() for word in ['calculate', 'sum', 'total', 'average']):
-                return self._analyze_calculation_pattern(text, context)
+            progress(0.8, desc="Extracting final answer...")
             
-            # Default analysis
-            return f"Analysis of text with keywords: {', '.join(keywords[:5])}"
+            # Extract final answer and reasoning
+            final_answer, reasoning = self.prompt_manager.extract_final_answer(raw_response)
+            
+            processing_time = time.time() - start_time
+            
+            progress(1.0, desc="Complete!")
+            
+            return final_answer, raw_response, reasoning, processing_time
             
         except Exception as e:
-            return f"Analysis failed: {e}"
-    
-    def _extract_keywords(self, text: str) -> List[str]:
-        """Extract important keywords from text"""
-        # Simple keyword extraction
-        words = re.findall(r'\b[A-Za-z]{3,}\b', text.lower())
-        
-        # Remove common stop words
-        stop_words = {'the', 'and', 'for', 'are', 'but', 'not', 'you', 'all', 'can', 'had', 'her', 'was', 'one', 'our', 'out', 'day', 'get', 'has', 'him', 'his', 'how', 'man', 'new', 'now', 'old', 'see', 'two', 'way', 'who', 'boy', 'did', 'its', 'let', 'put', 'say', 'she', 'too', 'use'}
-        
-        keywords = [word for word in words if word not in stop_words]
-        
-        # Return most frequent keywords
-        from collections import Counter
-        return [word for word, count in Counter(keywords).most_common(10)]
-    
-    def _analyze_question_pattern(self, text: str, context: Dict) -> str:
-        """Analyze question patterns to extract answers"""
-        # This is where you'd implement more sophisticated NLP
-        # For now, return a simple analysis
-        
-        if context and 'search_data' in context:
-            search_results = context['search_data']
-            if search_results and isinstance(search_results, list) and len(search_results) > 0:
-                return search_results[0].get('summary', 'No summary available')
-        
-        return "Unable to extract specific answer from question pattern"
-    
-    def _analyze_calculation_pattern(self, text: str, context: Dict) -> str:
-        """Analyze calculation patterns"""
-        if context and 'calculation' in context:
-            return str(context['calculation'])
-        
-        # Extract numbers for potential calculation
-        numbers = re.findall(r'\d+\.?\d*', text)
-        if numbers:
-            return f"Found numbers: {', '.join(numbers)}"
-        
-        return "No calculation pattern found"
-
-
-# Main execution functions
-def test_agent_on_random_question(api_base_url: str):
-    """Test the agent on a random question"""
-    agent = GAIAAgent(api_base_url)
+            processing_time = time.time() - start_time
+            error_msg = f"❌ Error processing question: {str(e)}"
+            return error_msg, "", "", processing_time
     
-    try:
-        # Get random question
-        response = requests.get(f"{api_base_url}/random-question")
-        question = response.json()
+    def batch_evaluate(self, questions: List[GAIAQuestion], progress=gr.Progress()) -> Tuple[str, str, str]:
+        """Evaluate multiple questions with progress tracking"""
+        if self.model_manager is None:
+            return "❌ No model loaded", "", ""
         
-        print("=" * 50)
-        print("TESTING RANDOM QUESTION")
-        print("=" * 50)
-        print(f"Task ID: {question.get('task_id')}")
-        print(f"Question: {question.get('question')}")
-        print(f"File: {question.get('file_name', 'None')}")
-        print("-" * 50)
+        results = []
+        total_questions = len(questions)
         
-        # Solve question
-        start_time = time.time()
-        answer = agent.solve_question(question)
-        end_time = time.time()
-        
-        print(f"Agent Answer: {answer}")
-        print(f"Processing Time: {end_time - start_time:.2f} seconds")
-        print("=" * 50)
-        
-        return {
-            'task_id': question.get('task_id'),
-            'question': question.get('question'),
-            'agent_answer': answer,
-            'processing_time': end_time - start_time
-        }
-        
-    except Exception as e:
-        print(f"Error testing random question: {e}")
-        return None
-
-
-def run_full_evaluation(api_base_url: str, username: str, agent_code_url: str):
-    """Run the complete evaluation on all 20 questions"""
-    agent = GAIAAgent(api_base_url)
-    
-    try:
-        # Get all questions
-        response = requests.get(f"{api_base_url}/questions")
-        questions = response.json()
-        
-        print(f"Starting evaluation on {len(questions)} questions...")
-        
-        answers = []
-        successful_answers = 0
+        progress(0, desc=f"Starting evaluation of {total_questions} questions...")
         
         for i, question in enumerate(questions):
-            print(f"\n{'='*60}")
-            print(f"PROCESSING QUESTION {i+1}/{len(questions)}")
-            print(f"{'='*60}")
-            print(f"Task ID: {question.get('task_id')}")
-            print(f"Question: {question.get('question')[:100]}...")
-            
             try:
+                progress((i + 1) / total_questions, 
+                        desc=f"Processing question {i + 1}/{total_questions}: {question.task_id}")
+                
                 start_time = time.time()
-                answer = agent.solve_question(question)
-                end_time = time.time()
                 
-                answers.append({
-                    'task_id': question['task_id'],
-                    'submitted_answer': answer
-                })
+                # Create prompt and generate response
+                prompt = self.prompt_manager.create_gaia_prompt(question.question)
+                raw_response = self.model_manager.generate_response(prompt)
+                
+                # Extract final answer
+                final_answer, reasoning = self.prompt_manager.extract_final_answer(raw_response)
                 
-                print(f"Answer: {answer}")
-                print(f"Time: {end_time - start_time:.2f}s")
+                processing_time = time.time() - start_time
                 
-                if answer and answer != "Unable to determine answer":
-                    successful_answers += 1
+                # Create response object
+                response = GAIAResponse(
+                    task_id=question.task_id,
+                    model_answer=raw_response,
+                    reasoning_trace=reasoning,
+                    final_answer=final_answer,
+                    processing_time=processing_time
+                )
+                
+                results.append(response)
+                self.evaluation_results.append(response)
                 
             except Exception as e:
-                print(f"Error processing question {i+1}: {e}")
-                answers.append({
-                    'task_id': question['task_id'],
-                    'submitted_answer': "Processing error"
-                })
-        
-        print(f"\n{'='*60}")
-        print(f"EVALUATION COMPLETE")
-        print(f"{'='*60}")
-        print(f"Successfully processed: {successful_answers}/{len(questions)} questions")
-        print(f"Success rate: {(successful_answers/len(questions)*100):.1f}%")
-        
-        # Submit results
-        print(f"\nSubmitting results...")
-        submission_result = submit_results(api_base_url, username, agent_code_url, answers)
-        
-        return {
-            'answers': answers,
-            'successful_answers': successful_answers,
-            'total_questions': len(questions),
-            'submission_result': submission_result
-        }
-        
-    except Exception as e:
-        print(f"Error in full evaluation: {e}")
-        return None
-
-
-def submit_results(api_base_url: str, username: str, agent_code_url: str, answers: List[Dict]):
-    """Submit results to the leaderboard"""
-    try:
-        submission_data = {
-            'username': username,
-            'agent_code': agent_code_url,
-            'answers': answers
-        }
-        
-        response = requests.post(f"{api_base_url}/submit", json=submission_data)
-        
-        if response.status_code == 200:
-            result = response.json()
-            print(f"✅ Submission successful!")
-            print(f"Score: {result.get('score', 'N/A')}%")
-            print(f"Rank: {result.get('rank', 'N/A')}")
-            return result
-        else:
-            print(f"❌ Submission failed: {response.status_code}")
-            print(f"Response: {response.text}")
-            return None
-            
-    except Exception as e:
-        print(f"Error submitting results: {e}")
-        return None
+                logger.error(f"Error processing {question.task_id}: {e}")
+                error_response = GAIAResponse(
+                    task_id=question.task_id,
+                    model_answer=f"Error: {str(e)}",
+                    reasoning_trace="Processing failed",
+                    final_answer="ERROR",
+                    processing_time=0.0
+                )
+                results.append(error_response)
+                self.evaluation_results.append(error_response)
+        
+        # Generate summary
+        summary = self._generate_summary(results)
+        
+        # Generate detailed results
+        detailed_results = self._generate_detailed_results(results, questions)
+        
+        # Generate downloadable JSONL
+        jsonl_content = self._generate_jsonl(results)
+        
+        return summary, detailed_results, jsonl_content
+    
+    def _generate_summary(self, results: List[GAIAResponse]) -> str:
+        """Generate evaluation summary"""
+        total = len(results)
+        errors = sum(1 for r in results if r.final_answer == "ERROR")
+        successful = total - errors
+        avg_time = sum(r.processing_time for r in results) / total if total > 0 else 0
+        total_time = sum(r.processing_time for r in results)
+        
+        summary = f"""
+# 📊 GAIA Evaluation Summary
 
+## Overall Statistics
+- **Total Questions**: {total}
+- **Successful**: {successful}
+- **Errors**: {errors}  
+- **Success Rate**: {(successful/total*100):.1f}%
 
-# Example usage and testing functions
-if __name__ == "__main__":
-    # Configuration - Replace with actual values
-    API_BASE_URL = "https://your-api-endpoint.com"  # Replace with actual API URL
-    USERNAME = "your-huggingface-username"  # Replace with your username
-    AGENT_CODE_URL = "https://huggingface.co/spaces/your-username/gaia-agent/tree/main"  # Replace with your space URL
-    
-    print("GAIA Agent Implementation")
-    print("=" * 40)
-    
-    # Test on a few random questions first
-    print("1. Testing on random questions...")
-    for i in range(3):
-        print(f"\n--- Random Test {i+1} ---")
-        test_result = test_agent_on_random_question(API_BASE_URL)
-        if test_result:
-            print(f"✅ Test {i+1} completed")
-        else:
-            print(f"❌ Test {i+1} failed")
-    
-    # Ask user if they want to run full evaluation
-    user_input = input("\nRun full evaluation on all 20 questions? (y/n): ")
+## Performance Metrics
+- **Average Processing Time**: {avg_time:.2f}s
+- **Total Processing Time**: {total_time:.2f}s
+- **Questions per Minute**: {(total/(total_time/60)):.1f}
+
+## Model Information
+- **Model**: {self.current_model}
+- **Device**: {self.model_manager.device.upper() if self.model_manager else 'Unknown'}
+"""
+        return summary
     
-    if user_input.lower() == 'y':
-        print("\n" + "=" * 60)
-        print("STARTING FULL EVALUATION")
-        print("=" * 60)
+    def _generate_detailed_results(self, results: List[GAIAResponse], questions: List[GAIAQuestion]) -> str:
+        """Generate detailed results breakdown"""
+        detailed = "# 📋 Detailed Results\n\n"
         
-        evaluation_result = run_full_evaluation(API_BASE_URL, USERNAME, AGENT_CODE_URL)
+        for i, (result, question) in enumerate(zip(results, questions), 1):
+            status = "✅" if result.final_answer != "ERROR" else "❌"
+            
+            detailed += f"""
+## Question {i}: {question.task_id} {status}
+
+**Question**: {question.question}
+
+**Model Answer**: {result.final_answer}
+
+**Expected Answer**: {question.final_answer if question.final_answer else 'N/A'}
+
+**Processing Time**: {result.processing_time:.2f}s
+
+**Level**: {question.level}
+
+---
+"""
+        
+        return detailed
+    
+    def _generate_jsonl(self, results: List[GAIAResponse]) -> str:
+        """Generate JSONL format for download"""
+        jsonl_lines = []
+        for result in results:
+            line = {
+                "task_id": result.task_id,
+                "model_answer": result.model_answer,
+                "reasoning_trace": result.reasoning_trace
+            }
+            jsonl_lines.append(json.dumps(line))
         
-        if evaluation_result:
-            print(f"\n🎉 Evaluation completed!")
-            print(f"Final score: {evaluation_result.get('submission_result', {}).get('score', 'N/A')}%")
-            
-            if evaluation_result.get('submission_result', {}).get('score', 0) >= 30:
-                print(f"🏆 CONGRATULATIONS! You've achieved the 30% threshold!")
-                print(f"🎓 You've earned your Certificate of Completion!")
-            else:
-                print(f"📈 Keep improving! You need 30% to earn the certificate.")
-        else:
-            print(f"❌ Evaluation failed. Please check your implementation.")
-    
-    else:
-        print("Evaluation cancelled. Use the test functions to debug your agent first.")
+        return '\n'.join(jsonl_lines)
+
+# ================================
+# GLOBAL AGENT INSTANCE
+# ================================
+
+# Initialize global agent
+gaia_agent = GAIASpaceAgent()
 
+# ================================
+# GRADIO INTERFACE FUNCTIONS
+# ================================
 
-# Additional utility functions for development and debugging
+def load_model_interface(model_choice: str, progress=gr.Progress()):
+    """Interface function for model loading"""
+    return gaia_agent.initialize_model(model_choice, progress)
 
-def debug_question_analysis(api_base_url: str, task_id: str = None):
-    """Debug question analysis for a specific question"""
-    agent = GAIAAgent(api_base_url)
+def single_question_interface(question: str, progress=gr.Progress()):
+    """Interface function for single question processing"""
+    if not question.strip():
+        return "Please enter a question", "", "", "0.00s"
+    
+    final_answer, full_response, reasoning, proc_time = gaia_agent.process_single_question(question, progress)
+    
+    return (
+        final_answer, 
+        full_response, 
+        reasoning, 
+        f"{proc_time:.2f}s"
+    )
+
+def batch_evaluate_interface(dataset_choice: str, max_questions: int, progress=gr.Progress()):
+    """Interface function for batch evaluation"""
+    if gaia_agent.model_manager is None:
+        return "❌ Please load a model first", "", ""
     
-    if task_id:
-        # Get specific question (you'd need to implement this endpoint or find the question in the list)
-        response = requests.get(f"{api_base_url}/questions")
-        questions = response.json()
-        question = next((q for q in questions if q.get('task_id') == task_id), None)
-    else:
-        # Get random question
-        response = requests.get(f"{api_base_url}/random-question")
-        question = response.json()
+    progress(0.1, desc="Loading dataset...")
     
-    if not question:
-        print("Question not found")
-        return
+    # Load questions based on choice
+    if dataset_choice == "Sample Questions":
+        questions = GAIADatasetManager.get_sample_questions()
+        status_msg = f"✅ Loaded {len(questions)} sample questions"
+    else:
+        questions, status_msg = GAIADatasetManager.load_gaia_dataset("test", max_questions)
     
-    print("QUESTION ANALYSIS DEBUG")
-    print("=" * 40)
-    print(f"Task ID: {question.get('task_id')}")
-    print(f"Question: {question.get('question')}")
-    print(f"File: {question.get('file_name', 'None')}")
-    print("-" * 40)
+    # Limit questions
+    if max_questions and len(questions) > max_questions:
+        questions = questions[:max_questions]
     
-    # Analyze question
-    analysis = agent._analyze_question(question)
-    print("Analysis Results:")
-    for key, value in analysis.items():
-        print(f"  {key}: {value}")
+    progress(0.2, desc=f"{status_msg}. Starting evaluation...")
     
-    # Create plan
-    plan = agent._create_execution_plan(analysis, question)
-    print(f"\nExecution Plan:")
-    for i, step in enumerate(plan):
-        print(f"  {i+1}. {step['action']} (priority: {step['priority']})")
+    # Run evaluation
+    summary, detailed, jsonl = gaia_agent.batch_evaluate(questions, progress)
     
-    return question, analysis, plan
+    return summary, detailed, jsonl
 
+def get_model_info(model_choice: str):
+    """Get information about selected model"""
+    if model_choice in HFSpaceModelManager.SPACE_MODELS:
+        config = HFSpaceModelManager.SPACE_MODELS[model_choice]
+        return f"""
+**Model**: {config['name']}
+**Size**: {config['size']}
+**Speed**: {config['speed']}
+**Quality**: {config['quality']}
+**GPU Required**: {'Yes' if config['gpu_required'] else 'No'}
+"""
+    return "Model information not available"
 
-def benchmark_agent_performance(api_base_url: str, num_tests: int = 10):
-    """Benchmark agent performance on multiple random questions"""
-    agent = GAIAAgent(api_base_url)
-    
-    results = []
-    total_time = 0
-    successful_answers = 0
-    
-    print(f"BENCHMARKING AGENT ({num_tests} questions)")
-    print("=" * 50)
-    
-    for i in range(num_tests):
-        try:
-            response = requests.get(f"{api_base_url}/random-question")
-            question = response.json()
-            
-            start_time = time.time()
-            answer = agent.solve_question(question)
-            end_time = time.time()
-            
-            processing_time = end_time - start_time
-            total_time += processing_time
-            
-            if answer and answer != "Unable to determine answer":
-                successful_answers += 1
-                status = "✅"
-            else:
-                status = "❌"
-            
-            print(f"{status} Question {i+1}: {processing_time:.2f}s - {answer[:50]}...")
-            
-            results.append({
-                'question_id': i+1,
-                'task_id': question.get('task_id'),
-                'answer': answer,
-                'processing_time': processing_time,
-                'success': answer != "Unable to determine answer"
-            })
-            
-        except Exception as e:
-            print(f"❌ Question {i+1}: Error - {e}")
-            results.append({
-                'question_id': i+1,
-                'error': str(e),
-                'success': False
-            })
-    
-    # Print summary
-    print("\n" + "=" * 50)
-    print("BENCHMARK RESULTS")
-    print("=" * 50)
-    print(f"Successful answers: {successful_answers}/{num_tests} ({successful_answers/num_tests*100:.1f}%)")
-    print(f"Average processing time: {total_time/num_tests:.2f}s")
-    print(f"Total time: {total_time:.2f}s")
-    
-    return results
+# ================================
+# GRADIO APP CREATION
+# ================================
+
+def create_gaia_app():
+    """Create the main Gradio application"""
+    
+    with gr.Blocks(
+        title="GAIA Benchmark AI Agent",
+        theme=gr.themes.Soft(),
+        css="""
+        .gradio-container {
+            font-family: 'Arial', sans-serif;
+        }
+        .main-header {
+            text-align: center;
+            background: linear-gradient(45deg, #2196F3, #21CBF3);
+            -webkit-background-clip: text;
+            -webkit-text-fill-color: transparent;
+            font-size: 2.5em;
+            font-weight: bold;
+            margin-bottom: 20px;
+        }
+        """
+    ) as app:
+        
+        # Header
+        gr.HTML("""
+        <div class="main-header">
+            🧠 GAIA Benchmark AI Agent
+        </div>
+        <p style="text-align: center; font-size: 1.2em; color: #666;">
+            Evaluate AI models on the GAIA benchmark with step-by-step reasoning
+        </p>
+        """)
+        
+        with gr.Tabs():
+            
+            # ===============================
+            # TAB 1: MODEL SETUP
+            # ===============================
+            with gr.Tab("🔧 Model Setup"):
+                gr.Markdown("## Choose and Load Your Model")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        model_dropdown = gr.Dropdown(
+                            choices=list(HFSpaceModelManager.SPACE_MODELS.keys()),
+                            value="Fast & Light",
+                            label="Select Model",
+                            info="Choose based on your quality vs speed preference"
+                        )
+                        
+                        model_info = gr.Markdown(
+                            value=get_model_info("Fast & Light"),
+                            label="Model Information"
+                        )
+                        
+                        load_btn = gr.Button("🚀 Load Model", variant="primary", size="lg")
+                        
+                    with gr.Column(scale=1):
+                        gpu_info = gr.Markdown(f"""
+                        ### 🖥️ System Info
+                        **CUDA Available**: {torch.cuda.is_available()}
+                        {f"**GPU**: {torch.cuda.get_device_name(0)}" if torch.cuda.is_available() else "**Device**: CPU"}
+                        """)
+                
+                model_status = gr.Textbox(
+                    label="Model Status",
+                    value="No model loaded",
+                    interactive=False
+                )
+                
+                # Update model info when selection changes
+                model_dropdown.change(
+                    fn=get_model_info,
+                    inputs=[model_dropdown],
+                    outputs=[model_info]
+                )
+                
+                # Load model when button clicked
+                load_btn.click(
+                    fn=load_model_interface,
+                    inputs=[model_dropdown],
+                    outputs=[model_status]
+                )
+            
+            # ===============================
+            # TAB 2: SINGLE QUESTION
+            # ===============================
+            with gr.Tab("❓ Single Question"):
+                gr.Markdown("## Test Individual Questions")
+                
+                with gr.Row():
+                    with gr.Column():
+                        question_input = gr.Textbox(
+                            label="Enter your question",
+                            placeholder="e.g., What is the capital of France?",
+                            lines=3
+                        )
+                        
+                        process_btn = gr.Button("🤔 Process Question", variant="primary")
+                        
+                        # Example questions
+                        gr.Markdown("### 💡 Example Questions:")
+                        example_questions = [
+                            "What is the capital of France?",
+                            "Calculate 144 divided by 12",
+                            "What is the largest planet in our solar system?",
+                            "Convert 100 degrees Celsius to Fahrenheit"
+                        ]
+                        
+                        for i, example in enumerate(example_questions):
+                            gr.Button(
+                                f"📝 {example}",
+                                size="sm"
+                            ).click(
+                                lambda x=example: x,
+                                outputs=[question_input]
+                            )
+                    
+                    with gr.Column():
+                        final_answer_output = gr.Textbox(
+                            label="🎯 Final Answer",
+                            interactive=False
+                        )
+                        
+                        processing_time = gr.Textbox(
+                            label="⏱️ Processing Time",
+                            interactive=False
+                        )
+                        
+                        with gr.Accordion("🧠 Full Response", open=False):
+                            full_response = gr.Textbox(
+                                label="Complete Model Response",
+                                lines=8,
+                                interactive=False
+                            )
+                        
+                        with gr.Accordion("🔍 Reasoning Trace", open=False):
+                            reasoning_trace = gr.Textbox(
+                                label="Step-by-step Reasoning",
+                                lines=6,
+                                interactive=False
+                            )
+                
+                # Process single question
+                process_btn.click(
+                    fn=single_question_interface,
+                    inputs=[question_input],
+                    outputs=[final_answer_output, full_response, reasoning_trace, processing_time]
+                )
+            
+            # ===============================
+            # TAB 3: BATCH EVALUATION
+            # ===============================
+            with gr.Tab("📊 Batch Evaluation"):
+                gr.Markdown("## Evaluate Multiple Questions")
+                
+                with gr.Row():
+                    dataset_choice = gr.Radio(
+                        choices=["Sample Questions", "GAIA Test Set"],
+                        value="Sample Questions",
+                        label="Dataset Choice",
+                        info="Start with sample questions to test your setup"
+                    )
+                    
+                    max_questions = gr.Slider(
+                        minimum=1,
+                        maximum=50,
+                        value=5,
+                        step=1,
+                        label="Max Questions",
+                        info="Number of questions to evaluate"
+                    )
+                
+                evaluate_btn = gr.Button("🚀 Start Batch Evaluation", variant="primary", size="lg")
+                
+                with gr.Row():
+                    with gr.Column():
+                        summary_output = gr.Markdown(
+                            label="📊 Evaluation Summary",
+                            value="No evaluation completed yet"
+                        )
+                    
+                    with gr.Column():
+                        download_output = gr.File(
+                            label="💾 Download Results (JSONL)",
+                            visible=False
+                        )
+                
+                with gr.Accordion("📋 Detailed Results", open=False):
+                    detailed_output = gr.Markdown(
+                        value="Run an evaluation to see detailed results"
+                    )
+                
+                # Batch evaluation
+                def batch_eval_with_download(*args):
+                    summary, detailed, jsonl_content = batch_evaluate_interface(*args)
+                    
+                    # Save JSONL for download
+                    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+                    filename = f"gaia_results_{timestamp}.jsonl"
+                    
+                    with open(filename, 'w') as f:
+                        f.write(jsonl_content)
+                    
+                    return summary, detailed, filename
+                
+                evaluate_btn.click(
+                    fn=batch_eval_with_download,
+                    inputs=[dataset_choice, max_questions],
+                    outputs=[summary_output, detailed_output, download_output]
+                ).then(
+                    lambda: gr.update(visible=True),
+                    outputs=[download_output]
+                )
+            
+            # ===============================
+            # TAB 4: INFORMATION
+            # ===============================
+            with gr.Tab("ℹ️ Information"):
+                gr.Markdown("""
+                # 🧠 GAIA Benchmark AI Agent
+                
+                ## What is GAIA?
+                GAIA (General AI Assistant) is a benchmark designed to test AI assistants on real-world questions that require:
+                - **Reasoning**: Multi-step logical thinking
+                - **Multi-modality**: Handling text, images, and other file types  
+                - **Web browsing**: Finding and using external information
+                - **Tool use**: Calculator, code execution, etc.
+                
+                ## 🎯 How to Use This Space
+                
+                ### 1. Model Setup
+                - Choose a model based on your needs (speed vs quality)
+                - Load the model (this may take a few minutes)
+                - Wait for "Model loaded successfully" message
+                
+                ### 2. Test Single Questions  
+                - Start with the "Single Question" tab
+                - Try example questions to verify everything works
+                - Enter your own questions to test model capabilities
+                
+                ### 3. Batch Evaluation
+                - Use "Sample Questions" first to test your setup
+                - Then try "GAIA Test Set" for real benchmark evaluation
+                - Download results in JSONL format for submission
+                
+                ## 📊 Model Recommendations
+                
+                | Model | Best For | Memory | Speed | Quality |
+                |-------|----------|---------|-------|---------|
+                | Fast & Light | Quick testing | Low | Fast | Good |
+                | Balanced | General use | Medium | Medium | Better |  
+                | High Quality | Best results | High | Slow | Best |
+                | Instruction Following | Complex reasoning | High | Medium | Excellent |
+                
+                ## 🔗 Resources
+                - [GAIA Paper](https://arxiv.org/abs/2311.12983)
+                - [GAIA Leaderboard](https://huggingface.co/spaces/gaia-benchmark/leaderboard)
+                - [Hugging Face Spaces Documentation](https://huggingface.co/docs/hub/spaces)
+                
+                ## 🚀 Output Format
+                Results are saved in GAIA leaderboard format:
+                ```json
+                {"task_id": "gaia_001", "model_answer": "[FULL RESPONSE]", "reasoning_trace": "[REASONING]"}
+                ```
+                
+                ## ⚡ Tips for Best Results
+                1. **Start Small**: Test with sample questions first
+                2. **Choose Right Model**: Balance speed vs quality for your needs
+                3. **Monitor GPU**: Larger models need GPU acceleration
+                4. **Download Results**: Save JSONL files for leaderboard submission
+                """)
+        
+        return app
+
+# ================================
+# MAIN APPLICATION
+# ================================
+
+if __name__ == "__main__":
+    # Create and launch the Gradio app
+    app = create_gaia_app()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False
+    )