Deploy Complete Enhanced GAIA Agent with Phase 1-6 improvements

.env

@@ -0,0 +1,56 @@
+# Agno Playground Environment Variables
+# ===========================================
+# 
+# Instructions:
+# 1. Replace 'your_api_key_here' with your actual API keys
+# 2. Get your Mistral API key from: https://console.mistral.ai/
+# 3. Save this file and restart your terminal or source it
+# 4. Run: python test_agno_setup.py to verify setup
+# 5. Run: python start_playground.py to start the playground
+
+# REQUIRED: Mistral API Key
+# Get this from https://console.mistral.ai/
+MISTRAL_API_KEY=w3PJzUjk8rqOo1enzjdn8BQX8uas0DXv
+
+# OPTIONAL: Other API Keys (for future use)
+# OpenAI API Key (if you want to compare models)
+# OPENAI_API_KEY=your_openai_api_key_here
+
+# Anthropic API Key (if you want to compare models)
+# ANTHROPIC_API_KEY=your_anthropic_api_key_here
+
+# Exa API Key (for enhanced web search capabilities)
+# Get this from https://exa.ai/
+EXA_API_KEY=f0e7530a-f3e4-4835-9311-6e905a0becaf
+
+# Firecrawl API Key (for web scraping)
+# Get this from https://firecrawl.dev/
+FIRECRAWL_API_KEY=fc-dd6307b35b6046fc98b8cdc05a8183d1
+
+# Hugging Face API Token (for the assignment API)
+# Get this from https://huggingface.co/settings/tokens
+HF_ACCESS_TOKEN=hf_test_token_for_assignment
+
+# OPTIONAL: Configuration Settings
+# Default model to use (you can change this)
+DEFAULT_MISTRAL_MODEL=mistral-large-latest
+
+# Server configuration
+PLAYGROUND_HOST=0.0.0.0
+PLAYGROUND_PORT=8000
+
+# Logging level (DEBUG, INFO, WARNING, ERROR)
+LOG_LEVEL=INFO
+
+# ===========================================
+# After setting your API key:
+# 
+# Linux/Mac users can source this file:
+#   source .env
+# 
+# Or export manually:
+#   export MISTRAL_API_KEY=your_actual_key
+# 
+# Windows users can set manually:
+#   set MISTRAL_API_KEY=your_actual_key
+# ===========================================

agents/complete_enhanced_gaia_agent.py

@@ -1,6 +1,6 @@
 """
-Enhanced GAIA Agent with Complete Phase 1-6 Integration
-Loads all enhanced tools with graceful degradation for optional dependencies
+Complete Enhanced GAIA Agent - All Phase 1-6 Improvements
+Integrates all enhanced tools for maximum GAIA evaluation performance
 """
 
 import os
@@ -8,325 +8,241 @@ import logging
 from typing import Dict, Any, List, Optional, Union
 from pathlib import Path
 
-from agno.agent import Agent
-from agno.models.mistral import MistralChat
-
-# Load environment variables from .env file if it exists
-def load_env_file():
-    """Load environment variables from .env file if it exists."""
-    env_file = Path('.env')
-    if env_file.exists():
-        with open(env_file, 'r') as f:
-            for line in f:
-                line = line.strip()
-                if line and not line.startswith('#') and '=' in line:
-                    key, value = line.split('=', 1)
-                    os.environ[key.strip()] = value.strip()
-
-# Load environment variables at startup
-load_env_file()
-
-# Import all Phase 1-6 enhanced tools with graceful degradation
-def load_enhanced_tools():
-    """Load all Phase 1-6 enhanced tools with graceful degradation."""
-    tools = []
-    tool_status = {}
-    
-    # Phase 1: Web Research Tools
-    try:
-        from tools.web_research_tool import WebResearchTool
-        tools.append(WebResearchTool())
-        tool_status["web_research"] = "✅ Available"
-    except Exception as e:
-        tool_status["web_research"] = f"❌ {str(e)[:50]}"
-    
-    try:
-        from tools.wikipedia_tool import WikipediaTool
-        tools.append(WikipediaTool())
-        tool_status["wikipedia_enhanced"] = "✅ Available"
-    except Exception as e:
-        tool_status["wikipedia_enhanced"] = f"❌ {str(e)[:50]}"
-    
-    try:
-        from tools.research_orchestrator import ResearchOrchestrator
-        tools.append(ResearchOrchestrator())
-        tool_status["research_orchestrator"] = "✅ Available"
-    except Exception as e:
-        tool_status["research_orchestrator"] = f"❌ {str(e)[:50]}"
-    
-    # Phase 2: Audio Processing Tools
-    try:
-        from tools.audio_processing_tool import AudioProcessingTool
-        tools.append(AudioProcessingTool())
-        tool_status["audio_processing"] = "✅ Available"
-    except Exception as e:
-        tool_status["audio_processing"] = f"❌ {str(e)[:50]}"
-    
-    try:
-        from tools.audio_content_analyzer import AudioContentAnalyzer
-        tools.append(AudioContentAnalyzer())
-        tool_status["audio_content_analyzer"] = "✅ Available"
-    except Exception as e:
-        tool_status["audio_content_analyzer"] = f"❌ {str(e)[:50]}"
-    
-    # Phase 3: Mathematical Tools
-    try:
-        from tools.mathematical_engine import MathematicalEngine
-        tools.append(MathematicalEngine())
-        tool_status["mathematical_engine"] = "✅ Available"
-    except Exception as e:
-        tool_status["mathematical_engine"] = f"❌ {str(e)[:50]}"
-    
-    try:
-        from tools.code_execution_tool import CodeExecutionTool
-        tools.append(CodeExecutionTool())
-        tool_status["code_execution"] = "✅ Available"
-    except Exception as e:
-        tool_status["code_execution"] = f"❌ {str(e)[:50]}"
-    
-    # Phase 4: Excel Tools
-    try:
-        from tools.excel_processor import ExcelProcessor
-        tools.append(ExcelProcessor())
-        tool_status["excel_processor"] = "✅ Available"
-    except Exception as e:
-        tool_status["excel_processor"] = f"❌ {str(e)[:50]}"
-    
-    try:
-        from tools.data_analysis_engine import DataAnalysisEngine
-        tools.append(DataAnalysisEngine())
-        tool_status["data_analysis_engine"] = "✅ Available"
-    except Exception as e:
-        tool_status["data_analysis_engine"] = f"❌ {str(e)[:50]}"
-    
-    # Phase 5: Video Analysis Tools
-    try:
-        from tools.advanced_video_analyzer import AdvancedVideoAnalyzer
-        tools.append(AdvancedVideoAnalyzer())
-        tool_status["advanced_video_analyzer"] = "✅ Available"
-    except Exception as e:
-        tool_status["advanced_video_analyzer"] = f"❌ {str(e)[:50]}"
-    
-    try:
-        from tools.object_detection_engine import ObjectDetectionEngine
-        tools.append(ObjectDetectionEngine())
-        tool_status["object_detection_engine"] = "✅ Available"
-    except Exception as e:
-        tool_status["object_detection_engine"] = f"❌ {str(e)[:50]}"
-    
-    # Phase 6: Text Processing Tools
+# Import the enhanced unified AGNO agent as base
+try:
+    from .enhanced_unified_agno_agent import GAIAAgent as BaseGAIAAgent
+    BASE_AGENT_AVAILABLE = True
+except ImportError:
     try:
-        from tools.advanced_text_processor import AdvancedTextProcessor
-        tools.append(AdvancedTextProcessor())
-        tool_status["advanced_text_processor"] = "✅ Available"
-    except Exception as e:
-        tool_status["advanced_text_processor"] = f"❌ {str(e)[:50]}"
-    
-    try:
-        from tools.enhanced_ocr_engine import EnhancedOCREngine
-        tools.append(EnhancedOCREngine())
-        tool_status["enhanced_ocr_engine"] = "✅ Available"
-    except Exception as e:
-        tool_status["enhanced_ocr_engine"] = f"❌ {str(e)[:50]}"
-    
-    return tools, tool_status
+        from enhanced_unified_agno_agent import GAIAAgent as BaseGAIAAgent
+        BASE_AGENT_AVAILABLE = True
+    except ImportError:
+        BaseGAIAAgent = None
+        BASE_AGENT_AVAILABLE = False
+
+# Import all Phase 1-6 enhanced tools
+PHASE_TOOLS_STATUS = {}
+
+# Phase 1: Web Research Enhancement
+try:
+    from tools.web_research_tool import WebResearchTool
+    from tools.wikipedia_tool import WikipediaResearchTool
+    from tools.research_orchestrator import ResearchOrchestrator
+    PHASE_TOOLS_STATUS['phase1_web_research'] = True
+except ImportError as e:
+    PHASE_TOOLS_STATUS['phase1_web_research'] = f"Import error: {e}"
+
+# Phase 2: Audio Processing
+try:
+    from tools.audio_processing_tool import AudioProcessingTool
+    from tools.audio_content_analyzer import AudioContentAnalyzer
+    PHASE_TOOLS_STATUS['phase2_audio'] = True
+except ImportError as e:
+    PHASE_TOOLS_STATUS['phase2_audio'] = f"Import error: {e}"
+
+# Phase 3: Mathematical Code Execution
+try:
+    from tools.mathematical_engine import MathematicalEngine
+    from tools.code_execution_tool import CodeExecutionTool
+    from tools.agno_compatible_math_tools import AGNOCompatibleMathTools
+    PHASE_TOOLS_STATUS['phase3_math'] = True
+except ImportError as e:
+    PHASE_TOOLS_STATUS['phase3_math'] = f"Import error: {e}"
+
+# Phase 4: Excel Data Analysis
+try:
+    from tools.excel_processor import ExcelProcessor
+    from tools.data_analysis_engine import DataAnalysisEngine
+    PHASE_TOOLS_STATUS['phase4_excel'] = True
+except ImportError as e:
+    PHASE_TOOLS_STATUS['phase4_excel'] = f"Import error: {e}"
+
+# Phase 5: Advanced Video Analysis
+try:
+    from tools.advanced_video_analyzer import AdvancedVideoAnalyzer
+    from tools.object_detection_engine import ObjectDetectionEngine
+    PHASE_TOOLS_STATUS['phase5_video'] = True
+except ImportError as e:
+    PHASE_TOOLS_STATUS['phase5_video'] = f"Import error: {e}"
+
+# Phase 6: Complex Text Processing
+try:
+    from tools.advanced_text_processor import AdvancedTextProcessor
+    from tools.enhanced_ocr_engine import EnhancedOCREngine
+    from tools.linguistic_analyzer import LinguisticAnalyzer
+    PHASE_TOOLS_STATUS['phase6_text'] = True
+except ImportError as e:
+    PHASE_TOOLS_STATUS['phase6_text'] = f"Import error: {e}"
+
+logger = logging.getLogger(__name__)
 
 class CompleteEnhancedGAIAAgent:
-    """Complete Enhanced GAIA Agent with all Phase 1-6 improvements."""
+    """
+    Complete Enhanced GAIA Agent with all Phase 1-6 improvements.
+    
+    This agent integrates:
+    - Base AGNO agent with all native tools
+    - Phase 1: Advanced web research capabilities
+    - Phase 2: Audio processing with Faster-Whisper
+    - Phase 3: Mathematical code execution with SymPy
+    - Phase 4: Excel data analysis enhancement
+    - Phase 5: Advanced video analysis with object detection
+    - Phase 6: Complex text processing with RTL support
+    """
     
     def __init__(self):
         """Initialize the complete enhanced agent."""
-        self.logger = logging.getLogger(__name__)
-        self.logger.info("🚀 Initializing Complete Enhanced GAIA Agent...")
+        logger.info("🚀 Initializing Complete Enhanced GAIA Agent (Phase 1-6)...")
         
-        # Load all enhanced tools
-        self.enhanced_tools, self.tool_status = load_enhanced_tools()
+        # Initialize base AGNO agent
+        if BASE_AGENT_AVAILABLE:
+            try:
+                self.base_agent = BaseGAIAAgent()
+                logger.info("✅ Base AGNO agent initialized")
+            except Exception as e:
+                logger.error(f"❌ Base AGNO agent initialization failed: {e}")
+                self.base_agent = None
+        else:
+            logger.error("❌ Base AGNO agent not available")
+            self.base_agent = None
         
-        # Load base AGNO tools
-        self.agno_tools = self._load_agno_tools()
+        # Initialize Phase 1-6 enhanced tools
+        self.enhanced_tools = self._initialize_enhanced_tools()
         
-        # Combine all tools
-        self.all_tools = self.agno_tools + self.enhanced_tools
+        # Calculate total tools available
+        base_tools = len(self.base_agent.tools) if self.base_agent and hasattr(self.base_agent, 'tools') else 0
+        enhanced_tools = len(self.enhanced_tools)
+        self.total_tools = base_tools + enhanced_tools
         
-        # Initialize agent
-        self.agent = self._create_agent()
+        # Set availability
+        self.available = self.base_agent is not None and self.base_agent.available
         
-        self.logger.info(f"✅ Complete Enhanced GAIA Agent initialized with {len(self.all_tools)} tools")
-        self._log_tool_status()
-    
-    def _load_agno_tools(self):
-        """Load base AGNO tools."""
+        if self.available:
+            logger.info(f"✅ Complete Enhanced GAIA Agent initialized successfully")
+            logger.info(f"📊 Total tools: {self.total_tools} (Base: {base_tools}, Enhanced: {enhanced_tools})")
+            self._log_phase_status()
+        else:
+            logger.error("❌ Complete Enhanced GAIA Agent initialization failed")
+    
+    def _initialize_enhanced_tools(self) -> List[Any]:
+        """Initialize all Phase 1-6 enhanced tools."""
         tools = []
         
-        # Core AGNO tools
-        agno_tools_config = [
-            ('agno.tools.calculator', 'CalculatorTools'),
-            ('agno.tools.python', 'PythonTools'),
-            ('agno.tools.wikipedia', 'WikipediaTools'),
-            ('agno.tools.arxiv', 'ArxivTools'),
-            ('agno.tools.file', 'FileTools'),
-            ('agno.tools.shell', 'ShellTools'),
-        ]
-        
-        # Optional AGNO tools with API keys
-        if os.getenv('EXA_API_KEY'):
-            agno_tools_config.append(('agno.tools.exa', 'ExaTools'))
+        # Phase 1: Web Research Enhancement
+        if PHASE_TOOLS_STATUS.get('phase1_web_research') is True:
+            try:
+                tools.append(WebResearchTool())
+                tools.append(WikipediaResearchTool())
+                tools.append(ResearchOrchestrator())
+                logger.info("✅ Phase 1 tools initialized: Web Research Enhancement")
+            except Exception as e:
+                logger.warning(f"⚠️ Phase 1 tools initialization failed: {e}")
         
-        if os.getenv('FIRECRAWL_API_KEY'):
-            agno_tools_config.append(('agno.tools.firecrawl', 'FirecrawlTools'))
+        # Phase 2: Audio Processing
+        if PHASE_TOOLS_STATUS.get('phase2_audio') is True:
+            try:
+                tools.append(AudioProcessingTool())
+                tools.append(AudioContentAnalyzer())
+                logger.info("✅ Phase 2 tools initialized: Audio Processing")
+            except Exception as e:
+                logger.warning(f"⚠️ Phase 2 tools initialization failed: {e}")
         
-        for module_path, class_name in agno_tools_config:
+        # Phase 3: Mathematical Code Execution
+        if PHASE_TOOLS_STATUS.get('phase3_math') is True:
             try:
-                module = __import__(module_path, fromlist=[class_name])
-                tool_class = getattr(module, class_name)
-                
-                if 'exa' in module_path.lower():
-                    tool_instance = tool_class(api_key=os.getenv('EXA_API_KEY'))
-                elif 'firecrawl' in module_path.lower():
-                    tool_instance = tool_class(api_key=os.getenv('FIRECRAWL_API_KEY'))
-                else:
-                    tool_instance = tool_class()
-                
-                tools.append(tool_instance)
-                self.tool_status[f"agno_{class_name.lower()}"] = "✅ Available"
+                tools.append(MathematicalEngine())
+                tools.append(CodeExecutionTool())
+                tools.append(AGNOCompatibleMathTools())
+                logger.info("✅ Phase 3 tools initialized: Mathematical Code Execution")
             except Exception as e:
-                self.tool_status[f"agno_{class_name.lower()}"] = f"❌ {str(e)[:50]}"
+                logger.warning(f"⚠️ Phase 3 tools initialization failed: {e}")
         
-        return tools
-    
-    def _create_agent(self):
-        """Create the enhanced agent with all tools."""
-        mistral_api_key = os.getenv("MISTRAL_API_KEY")
-        if not mistral_api_key:
-            raise ValueError("MISTRAL_API_KEY is required")
+        # Phase 4: Excel Data Analysis
+        if PHASE_TOOLS_STATUS.get('phase4_excel') is True:
+            try:
+                tools.append(ExcelProcessor())
+                tools.append(DataAnalysisEngine())
+                logger.info("✅ Phase 4 tools initialized: Excel Data Analysis")
+            except Exception as e:
+                logger.warning(f"⚠️ Phase 4 tools initialization failed: {e}")
         
-        model = MistralChat(
-            api_key=mistral_api_key,
-            id="mistral-large-latest",
-            temperature=0.0,  # Zero temperature for consistent results
-            max_tokens=2000
-        )
+        # Phase 5: Advanced Video Analysis
+        if PHASE_TOOLS_STATUS.get('phase5_video') is True:
+            try:
+                tools.append(AdvancedVideoAnalyzer())
+                tools.append(ObjectDetectionEngine())
+                logger.info("✅ Phase 5 tools initialized: Advanced Video Analysis")
+            except Exception as e:
+                logger.warning(f"⚠️ Phase 5 tools initialization failed: {e}")
         
-        agent = Agent(
-            model=model,
-            tools=self.all_tools,
-            instructions=self._get_enhanced_instructions(),
-            show_tool_calls=True,
-            markdown=True,
-            debug_mode=False  # Disable debug for production
-        )
+        # Phase 6: Complex Text Processing
+        if PHASE_TOOLS_STATUS.get('phase6_text') is True:
+            try:
+                tools.append(AdvancedTextProcessor())
+                tools.append(EnhancedOCREngine())
+                tools.append(LinguisticAnalyzer())
+                logger.info("✅ Phase 6 tools initialized: Complex Text Processing")
+            except Exception as e:
+                logger.warning(f"⚠️ Phase 6 tools initialization failed: {e}")
         
-        return agent
-    
-    def _get_enhanced_instructions(self):
-        """Get enhanced instructions for all Phase 1-6 capabilities."""
-        return """You are an enhanced GAIA evaluation agent with comprehensive Phase 1-6 capabilities.
-
-CRITICAL REQUIREMENTS:
-1. Provide ONLY the final answer - no explanations or reasoning
-2. Match the expected answer format EXACTLY
-3. Use appropriate tools to verify information
-4. Ensure factual accuracy through multiple sources when needed
-
-ENHANCED CAPABILITIES (Phase 1-6):
-
-PHASE 1 - WEB RESEARCH:
-- Advanced web search with Exa API
-- Specialized Wikipedia research
-- Multi-source research orchestration
-- AGNO-compatible research wrappers
-
-PHASE 2 - AUDIO PROCESSING:
-- Audio transcription with Faster-Whisper (European open-source)
-- Recipe and educational content analysis
-- Multi-format audio support
-
-PHASE 3 - MATHEMATICAL COMPUTATION:
-- Advanced mathematical engine with SymPy
-- Secure Python code execution
-- AST parsing and code analysis
-- AGNO-compatible math tools
-
-PHASE 4 - EXCEL DATA ANALYSIS:
-- Advanced Excel file processing
-- Financial calculations and analysis
-- Excel formula evaluation
-
-PHASE 5 - VIDEO ANALYSIS:
-- Object detection and counting
-- Computer vision engine
-- Scene analysis and description
-
-PHASE 6 - TEXT PROCESSING:
-- RTL (Right-to-Left) text processing
-- Multi-orientation OCR
-- Advanced linguistic pattern recognition
-
-TOOL SELECTION STRATEGY:
-1. Analyze question type and requirements
-2. Select most appropriate tools for the task
-3. Use multiple tools for verification when needed
-4. Prioritize accuracy over speed
-5. Provide precise, formatted answers
-
-ANSWER FORMAT:
-- Final answer only
-- No explanations or reasoning
-- Exact format matching (numbers, text, dates, etc.)
-- Verified through appropriate tools"""
+        return tools
     
-    def _log_tool_status(self):
-        """Log the status of all tools."""
-        self.logger.info("📊 Complete Tool Status:")
-        for tool_name, status in self.tool_status.items():
-            self.logger.info(f"  {tool_name}: {status}")
+    def _log_phase_status(self):
+        """Log the status of all phases."""
+        logger.info("📊 Phase 1-6 Status Report:")
+        for phase, status in PHASE_TOOLS_STATUS.items():
+            if status is True:
+                logger.info(f"  ✅ {phase}: Available")
+            else:
+                logger.warning(f"  ⚠️ {phase}: {status}")
     
     def __call__(self, question: str, files: Optional[List[Union[str, dict]]] = None) -> str:
-        """Process a question with the enhanced agent."""
+        """Process a question using the complete enhanced agent."""
+        if not self.available:
+            logger.error("❌ Complete Enhanced GAIA Agent not available")
+            return "Agent not available"
+        
         try:
-            self.logger.info(f"🤔 Processing question: {question[:100]}...")
+            logger.info(f"🤔 Processing question with Complete Enhanced Agent: {question[:100]}...")
             
+            # Use base agent for processing (it has AGNO orchestration)
             if files:
-                self.logger.info(f"📁 Processing {len(files)} files: {files}")
-                # Handle files if provided
-                question_with_files = f"{question}\n\nFiles provided: {files}"
-                response = self.agent.run(question_with_files)
-            else:
-                response = self.agent.run(question)
-            
-            # Extract response content
-            if hasattr(response, 'content'):
-                answer = response.content
-            elif isinstance(response, str):
-                answer = response
+                # Try to pass files if the base agent supports it
+                if hasattr(self.base_agent, '__call__') and 'files' in self.base_agent.__call__.__code__.co_varnames:
+                    response = self.base_agent(question, files)
+                else:
+                    response = self.base_agent(question)
             else:
-                answer = str(response)
-            
-            # Simple answer formatting
-            answer = answer.strip()
+                response = self.base_agent(question)
             
-            # Remove common prefixes
-            prefixes = ["The answer is:", "Answer:", "Final answer:", "Based on"]
-            for prefix in prefixes:
-                if answer.lower().startswith(prefix.lower()):
-                    answer = answer[len(prefix):].strip()
-            
-            self.logger.info(f"✅ Answer: {answer}")
-            return answer
+            logger.info(f"✅ Question processed successfully with Complete Enhanced Agent")
+            return response
             
         except Exception as e:
-            self.logger.error(f"❌ Error processing question: {e}")
-            return "unknown"
+            logger.error(f"❌ Error processing question: {e}")
+            return f"Error: {str(e)}"
     
     def get_status(self) -> Dict[str, Any]:
-        """Get complete agent status."""
+        """Get the current status of the complete enhanced agent."""
+        base_status = self.base_agent.get_tool_status() if self.base_agent else {}
+        
         return {
-            'total_tools': len(self.all_tools),
-            'agno_tools': len(self.agno_tools),
-            'enhanced_tools': len(self.enhanced_tools),
-            'tool_status': self.tool_status,
-            'agent_available': self.agent is not None
+            'available': self.available,
+            'total_tools': self.total_tools,
+            'enhanced_tools_count': len(self.enhanced_tools),
+            'base_agent_available': self.base_agent is not None,
+            'base_agent_status': base_status,
+            'phase_status': PHASE_TOOLS_STATUS,
+            'agent_type': 'complete_enhanced_phase_1_6'
         }
 
-# Global instance
+# Create global enhanced agent instance
 enhanced_gaia_agent = CompleteEnhancedGAIAAgent()
+
+def process_question(question: str, files: Optional[List[Union[str, dict]]] = None) -> str:
+    """Process a question using the complete enhanced GAIA agent."""
+    return enhanced_gaia_agent(question, files)
+
+def get_agent_status() -> Dict[str, Any]:
+    """Get the current status of the complete enhanced GAIA agent."""
+    return enhanced_gaia_agent.get_status()