Update veryfinal.py

veryfinal.py

@@ -1,6 +1,6 @@
 """
-Enhanced Agno Multi-LLM Agent System with NVIDIA Integration
-Uses open-source models + NVIDIA NIM models available through Agno framework
+Final Working Multi-LLM Agent System
+Robust fallback system that works even when Agno fails
 """
 
 import os
@@ -9,518 +9,333 @@ import random
 import operator
 from typing import List, Dict, Any, TypedDict, Annotated, Optional
 from dotenv import load_dotenv
-from datetime import datetime
-from textwrap import dedent
 
-# Core LangChain imports for compatibility
+# Core LangChain imports
 from langchain_core.tools import tool
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+from langchain_community.tools.tavily_search import TavilySearchResults
+from langchain_community.document_loaders import WikipediaLoader
 from langgraph.graph import StateGraph, END
 from langgraph.checkpoint.memory import MemorySaver
-
-# Agno imports for open-source models + NVIDIA
-try:
-    from agno.agent import Agent
-    from agno.models.groq import Groq
-    from agno.models.ollama import Ollama
-    from agno.models.together import Together
-    from agno.models.anyscale import Anyscale
-    from agno.models.huggingface import HuggingFaceChat
-    from agno.models.nvidia import Nvidia  # NVIDIA NIM integration
-    from agno.tools.duckduckgo import DuckDuckGoTools
-    from agno.tools.wikipedia import WikipediaTools
-    from agno.tools.calculator import Calculator
-    from agno.tools.reasoning import ReasoningTools
-    from agno.memory import AgentMemory
-    from agno.storage import AgentStorage
-    from agno.knowledge import AgentKnowledge
-    AGNO_AVAILABLE = True
-except ImportError:
-    AGNO_AVAILABLE = False
-    print("Agno not available. Install with: pip install agno")
-
-# Vector database imports
-import faiss
-import numpy as np
-from sentence_transformers import SentenceTransformer
-import json
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
+from langchain_groq import ChatGroq
 
 load_dotenv()
 
-# Enhanced system prompt for Agno agents
-AGNO_SYSTEM_PROMPT = dedent("""\
-You are a helpful assistant tasked with answering questions using available tools.
-You must provide accurate, comprehensive answers based on available information.
-
-Your capabilities include:
-- Using search tools to find current information
-- Performing mathematical calculations
-- Reasoning through complex problems step by step
-- Accessing Wikipedia for encyclopedic knowledge
+# System prompt for proper question answering
+SYSTEM_PROMPT = """You are a helpful assistant tasked with answering questions using available tools.
 
 Guidelines:
 1. Use available tools to gather information when needed
 2. Provide precise, factual answers
 3. For numbers: don't use commas or units unless specified
 4. For strings: don't use articles or abbreviations, write digits in plain text
-5. For lists: apply above rules based on element type
-6. Always end with 'FINAL ANSWER: [YOUR ANSWER]'
-7. Be concise but thorough in your reasoning
-8. If you cannot find the answer, state that clearly
-""")
+5. Always end with 'FINAL ANSWER: [YOUR ANSWER]'
+6. Be concise but thorough
+7. If you cannot find the answer, state that clearly"""
+
+# ---- Tool Definitions ----
+@tool
+def multiply(a: int, b: int) -> int:
+    """Multiply two integers and return the product."""
+    return a * b
+
+@tool
+def add(a: int, b: int) -> int:
+    """Add two integers and return the sum."""
+    return a + b
+
+@tool
+def subtract(a: int, b: int) -> int:
+    """Subtract the second integer from the first and return the difference."""
+    return a - b
+
+@tool
+def divide(a: int, b: int) -> float:
+    """Divide the first integer by the second and return the quotient."""
+    if b == 0:
+        raise ValueError("Cannot divide by zero.")
+    return a / b
 
-# ---- Enhanced Model Manager with NVIDIA Support ----
-class AgnoEnhancedModelManager:
-    """Manages open-source models + NVIDIA NIM models available through Agno"""
+@tool
+def modulus(a: int, b: int) -> int:
+    """Return the remainder when dividing the first integer by the second."""
+    return a % b
+
+@tool
+def web_search(query: str) -> str:
+    """Search the web for information."""
+    try:
+        if os.getenv("TAVILY_API_KEY"):
+            time.sleep(random.uniform(0.5, 1.0))
+            search_tool = TavilySearchResults(max_results=3)
+            docs = search_tool.invoke({"query": query})
+            return "\n\n---\n\n".join(
+                f"<Doc url='{d.get('url','')}'>{d.get('content','')[:600]}</Doc>"
+                for d in docs
+            )
+        else:
+            return "Web search not available - no API key"
+    except Exception as e:
+        return f"Web search failed: {e}"
+
+@tool
+def wiki_search(query: str) -> str:
+    """Search Wikipedia for information."""
+    try:
+        time.sleep(random.uniform(0.3, 0.8))
+        docs = WikipediaLoader(query=query, load_max_docs=2).load()
+        return "\n\n---\n\n".join(
+            f"<Doc src='Wikipedia'>{d.page_content[:800]}</Doc>"
+            for d in docs
+        )
+    except Exception as e:
+        return f"Wikipedia search failed: {e}"
+
+# ---- Enhanced Agent State ----
+class EnhancedAgentState(TypedDict):
+    messages: Annotated[List[HumanMessage | AIMessage], operator.add]
+    query: str
+    agent_type: str
+    final_answer: str
+    perf: Dict[str, Any]
+    tools_used: List[str]
+
+# ---- Working Multi-LLM System ----
+class WorkingMultiLLMSystem:
+    """Reliable multi-LLM system that actually works"""
     
     def __init__(self):
-        self.available_models = {}
-        self._initialize_all_models()
-    
-    def _initialize_all_models(self):
-        """Initialize open-source models + NVIDIA NIM models through Agno"""
-        if not AGNO_AVAILABLE:
-            return
-        
-        # 1. NVIDIA NIM Models (Enterprise-grade open-source models)
-        if os.getenv("NVIDIA_API_KEY"):
-            try:
-                # NVIDIA NIM provides access to optimized open-source models
-                self.available_models['nvidia_llama3_70b'] = Nvidia(id="meta/llama3-70b-instruct")
-                self.available_models['nvidia_llama3_8b'] = Nvidia(id="meta/llama3-8b-instruct")
-                self.available_models['nvidia_mixtral'] = Nvidia(id="mistralai/mixtral-8x7b-instruct-v0.1")
-                self.available_models['nvidia_codellama'] = Nvidia(id="meta/codellama-70b-instruct")
-                self.available_models['nvidia_gemma'] = Nvidia(id="google/gemma-7b-it")
-                self.available_models['nvidia_yi'] = Nvidia(id="01-ai/yi-34b-chat")
-                print("NVIDIA NIM models initialized")
-            except Exception as e:
-                print(f"NVIDIA models not available: {e}")
+        self.tools = [multiply, add, subtract, divide, modulus, web_search, wiki_search]
+        self.graph = self._build_graph()
+        print("✅ Working Multi-LLM System initialized")
+
+    def _get_llm(self, model_name: str = "llama3-70b-8192"):
+        """Get Groq LLM instance"""
+        return ChatGroq(
+            model=model_name,
+            temperature=0,
+            api_key=os.getenv("GROQ_API_KEY")
+        )
+
+    def _build_graph(self) -> StateGraph:
+        """Build the working LangGraph system"""
         
-        # 2. Groq (Free tier with open-source models)
-        if os.getenv("GROQ_API_KEY"):
+        def router(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Route queries to appropriate processing"""
+            q = st["query"].lower()
+            
+            if any(keyword in q for keyword in ["calculate", "multiply", "add", "subtract", "divide", "math"]):
+                agent_type = "math"
+            elif any(keyword in q for keyword in ["search", "find", "information", "about"]):
+                agent_type = "search"
+            elif any(keyword in q for keyword in ["wikipedia", "wiki"]):
+                agent_type = "wiki"
+            else:
+                agent_type = "general"
+            
+            return {**st, "agent_type": agent_type, "tools_used": []}
+
+        def math_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Handle mathematical queries"""
+            t0 = time.time()
             try:
-                self.available_models['groq_llama3_70b'] = Groq(id="llama3-70b-8192")
-                self.available_models['groq_llama3_8b'] = Groq(id="llama3-8b-8192")
-                self.available_models['groq_mixtral'] = Groq(id="mixtral-8x7b-32768")
-                self.available_models['groq_gemma'] = Groq(id="gemma-7b-it")
-                print("Groq open-source models initialized")
+                llm = self._get_llm("llama3-70b-8192")
+                
+                enhanced_query = f"""
+                Question: {st["query"]}
+                
+                This is a mathematical question. Please solve it step by step and provide the exact numerical answer.
+                """
+                
+                sys_msg = SystemMessage(content=SYSTEM_PROMPT)
+                response = llm.invoke([sys_msg, HumanMessage(content=enhanced_query)])
+                
+                answer = response.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
+                
+                return {**st, 
+                       "final_answer": answer,
+                       "perf": {"time": time.time() - t0, "provider": "Groq-Math"}}
             except Exception as e:
-                print(f"Groq models not available: {e}")
-        
-        # 3. Ollama (Completely free local models)
-        try:
-            self.available_models['ollama_llama3'] = Ollama(id="llama3")
-            self.available_models['ollama_llama3_70b'] = Ollama(id="llama3:70b")
-            self.available_models['ollama_mistral'] = Ollama(id="mistral")
-            self.available_models['ollama_phi3'] = Ollama(id="phi3")
-            self.available_models['ollama_codellama'] = Ollama(id="codellama")
-            self.available_models['ollama_gemma'] = Ollama(id="gemma")
-            self.available_models['ollama_qwen'] = Ollama(id="qwen")
-            print("Ollama local models initialized")
-        except Exception as e:
-            print(f"Ollama models not available: {e}")
-        
-        # 4. Together AI (Open-source models)
-        if os.getenv("TOGETHER_API_KEY"):
+                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
+
+        def search_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Handle search queries"""
+            t0 = time.time()
             try:
-                self.available_models['together_llama3_70b'] = Together(id="meta-llama/Llama-3-70b-chat-hf")
-                self.available_models['together_llama3_8b'] = Together(id="meta-llama/Llama-3-8b-chat-hf")
-                self.available_models['together_mistral'] = Together(id="mistralai/Mistral-7B-Instruct-v0.1")
-                self.available_models['together_qwen'] = Together(id="Qwen/Qwen2-72B-Instruct")
-                print("Together AI open-source models initialized")
+                # Perform web search
+                search_results = web_search.invoke({"query": st["query"]})
+                
+                llm = self._get_llm("llama3-70b-8192")
+                
+                enhanced_query = f"""
+                Question: {st["query"]}
+                
+                Search Results:
+                {search_results}
+                
+                Based on the search results above, provide a direct answer to the question.
+                """
+                
+                sys_msg = SystemMessage(content=SYSTEM_PROMPT)
+                response = llm.invoke([sys_msg, HumanMessage(content=enhanced_query)])
+                
+                answer = response.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
+                
+                return {**st, 
+                       "final_answer": answer,
+                       "tools_used": ["web_search"],
+                       "perf": {"time": time.time() - t0, "provider": "Groq-Search"}}
             except Exception as e:
-                print(f"Together AI models not available: {e}")
-        
-        # 5. Anyscale (Open-source models)
-        if os.getenv("ANYSCALE_API_KEY"):
+                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
+
+        def wiki_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Handle Wikipedia queries"""
+            t0 = time.time()
             try:
-                self.available_models['anyscale_llama3_70b'] = Anyscale(id="meta-llama/Llama-3-70b-chat-hf")
-                self.available_models['anyscale_mistral'] = Anyscale(id="mistralai/Mistral-7B-Instruct-v0.1")
-                print("Anyscale open-source models initialized")
+                # Perform Wikipedia search
+                wiki_results = wiki_search.invoke({"query": st["query"]})
+                
+                llm = self._get_llm("llama3-70b-8192")
+                
+                enhanced_query = f"""
+                Question: {st["query"]}
+                
+                Wikipedia Results:
+                {wiki_results}
+                
+                Based on the Wikipedia information above, provide a direct answer to the question.
+                """
+                
+                sys_msg = SystemMessage(content=SYSTEM_PROMPT)
+                response = llm.invoke([sys_msg, HumanMessage(content=enhanced_query)])
+                
+                answer = response.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
+                
+                return {**st, 
+                       "final_answer": answer,
+                       "tools_used": ["wiki_search"],
+                       "perf": {"time": time.time() - t0, "provider": "Groq-Wiki"}}
             except Exception as e:
-                print(f"Anyscale models not available: {e}")
-        
-        # 6. Hugging Face (Open-source models)
-        try:
-            if os.getenv("HUGGINGFACE_API_KEY"):
-                self.available_models['hf_llama3_8b'] = HuggingFaceChat(id="meta-llama/Meta-Llama-3-8B-Instruct")
-                self.available_models['hf_mistral'] = HuggingFaceChat(id="mistralai/Mistral-7B-Instruct-v0.1")
-                print("Hugging Face open-source models initialized")
-        except Exception as e:
-            print(f"Hugging Face models not available: {e}")
-        
-        print(f"Total available models: {len(self.available_models)}")
-    
-    def get_model(self, model_name: str):
-        """Get a specific model by name"""
-        return self.available_models.get(model_name)
-    
-    def list_available_models(self) -> List[str]:
-        """List all available model names"""
-        return list(self.available_models.keys())
-    
-    def get_best_model_for_task(self, task_type: str):
-        """Get the best available model for a specific task type"""
-        if task_type == "reasoning":
-            # Prefer larger, more capable models for reasoning
-            for model_name in ['nvidia_llama3_70b', 'groq_llama3_70b', 'together_llama3_70b', 'anyscale_llama3_70b', 'ollama_llama3_70b']:
-                if model_name in self.available_models:
-                    return self.available_models[model_name]
-        
-        elif task_type == "coding":
-            # Prefer code-specialized models
-            for model_name in ['nvidia_codellama', 'ollama_codellama', 'nvidia_llama3_70b', 'groq_llama3_70b']:
-                if model_name in self.available_models:
-                    return self.available_models[model_name]
-        
-        elif task_type == "fast":
-            # Prefer fast, smaller models
-            for model_name in ['groq_llama3_8b', 'nvidia_llama3_8b', 'groq_gemma', 'ollama_phi3', 'hf_llama3_8b']:
-                if model_name in self.available_models:
-                    return self.available_models[model_name]
-        
-        elif task_type == "enterprise":
-            # Prefer NVIDIA NIM for enterprise-grade tasks
-            for model_name in ['nvidia_llama3_70b', 'nvidia_mixtral', 'nvidia_codellama']:
-                if model_name in self.available_models:
-                    return self.available_models[model_name]
-        
-        # Default fallback to first available
-        if self.available_models:
-            return list(self.available_models.values())[0]
-        return None
+                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
 
-# ---- Enhanced Specialized Agno Agents with NVIDIA ----
-class AgnoEnhancedAgentSystem:
-    """System of specialized Agno agents using open-source + NVIDIA models"""
-    
-    def __init__(self):
-        self.model_manager = AgnoEnhancedModelManager()
-        self.agents = {}
-        self._create_specialized_agents()
-    
-    def _create_specialized_agents(self):
-        """Create specialized agents for different tasks using best available models"""
-        if not AGNO_AVAILABLE:
-            print("Agno not available, agents cannot be created")
-            return
-        
-        # Enterprise Research Agent (NVIDIA preferred)
-        enterprise_model = self.model_manager.get_best_model_for_task("enterprise")
-        if enterprise_model:
-            self.agents['enterprise_research'] = Agent(
-                model=enterprise_model,
-                tools=[DuckDuckGoTools(), WikipediaTools(), ReasoningTools()],
-                description=dedent("""\
-                You are an enterprise-grade research specialist with access to optimized models.
-                Your expertise lies in comprehensive analysis, fact-checking, and providing
-                detailed, accurate responses for complex research tasks.
+        def general_node(st: EnhancedAgentState) -> EnhancedAgentState:
+            """Handle general queries"""
+            t0 = time.time()
+            try:
+                llm = self._get_llm("llama3-70b-8192")
                 
-                Your approach is:
-                - Enterprise-level accuracy and reliability
-                - Comprehensive and thorough analysis
-                - Multi-source verification
-                - Professional-grade output quality
-                """),
-                instructions=dedent("""\
-                1. Use advanced reasoning capabilities for complex analysis
-                2. Cross-reference multiple sources for maximum accuracy
-                3. Provide comprehensive, well-structured responses
-                4. Include confidence levels and source reliability assessment
-                5. Always end with 'FINAL ANSWER: [your comprehensive answer]'
-                6. Prioritize accuracy and completeness over speed
-                """),
-                memory=AgentMemory(),
-                markdown=True,
-                show_tool_calls=True,
-                add_datetime_to_instructions=True
-            )
-        
-        # Advanced Math Agent (Best reasoning model)
-        math_model = self.model_manager.get_best_model_for_task("reasoning")
-        if math_model:
-            self.agents['advanced_math'] = Agent(
-                model=math_model,
-                tools=[Calculator(), ReasoningTools()],
-                description=dedent("""\
-                You are an advanced mathematics expert with access to powerful reasoning models.
-                You excel at complex mathematical problem solving, statistical analysis,
-                and providing step-by-step solutions with high accuracy.
+                enhanced_query = f"""
+                Question: {st["query"]}
                 
-                Your approach is:
-                - Rigorous mathematical methodology
-                - Step-by-step problem decomposition
-                - High-precision calculations
-                - Clear mathematical communication
-                """),
-                instructions=dedent("""\
-                1. Break down complex mathematical problems systematically
-                2. Use advanced reasoning for multi-step problems
-                3. Show detailed work and methodology
-                4. Verify calculations using multiple approaches when possible
-                5. Provide exact numerical answers without commas or units unless specified
-                6. Always end with 'FINAL ANSWER: [precise numerical result]'
-                """),
-                memory=AgentMemory(),
-                markdown=True,
-                show_tool_calls=True
-            )
-        
-        # Fast Response Agent (Optimized for speed)
-        fast_model = self.model_manager.get_best_model_for_task("fast")
-        if fast_model:
-            self.agents['fast_response'] = Agent(
-                model=fast_model,
-                tools=[DuckDuckGoTools(), WikipediaTools()],
-                description=dedent("""\
-                You are a rapid response specialist optimized for quick, accurate answers.
-                You provide concise, direct responses while maintaining high quality standards.
+                Please provide a direct, accurate answer to this question.
+                """
                 
-                Your approach is:
-                - Speed-optimized processing
-                - Direct and concise communication
-                - Efficient tool usage
-                - Quality maintained at high speed
-                """),
-                instructions=dedent("""\
-                1. Provide quick, accurate answers
-                2. Use tools efficiently - only when necessary
-                3. Be direct and avoid unnecessary elaboration
-                4. Maintain accuracy despite speed focus
-                5. Always end with 'FINAL ANSWER: [your concise answer]'
-                6. Prioritize clarity and correctness
-                """),
-                markdown=True,
-                show_tool_calls=False
-            )
-        
-        # Advanced Coding Agent (Code-specialized model)
-        coding_model = self.model_manager.get_best_model_for_task("coding")
-        if coding_model:
-            self.agents['advanced_coding'] = Agent(
-                model=coding_model,
-                tools=[ReasoningTools()],
-                description=dedent("""\
-                You are an advanced programming expert with access to code-specialized models.
-                You excel at complex code generation, algorithm design, debugging, and
-                software architecture recommendations.
+                sys_msg = SystemMessage(content=SYSTEM_PROMPT)
+                response = llm.invoke([sys_msg, HumanMessage(content=enhanced_query)])
                 
-                Your approach is:
-                - Advanced programming methodologies
-                - Clean, efficient code generation
-                - Comprehensive error handling
-                - Best practices implementation
-                """),
-                instructions=dedent("""\
-                1. Write production-quality, well-documented code
-                2. Follow industry best practices and design patterns
-                3. Include comprehensive error handling and edge cases
-                4. Provide clear explanations of code logic
-                5. Consider performance, security, and maintainability
-                6. Always end with 'FINAL ANSWER: [your code solution]'
-                """),
-                memory=AgentMemory(),
-                markdown=True,
-                show_tool_calls=True
-            )
-        
-        # Standard Research Agent (Fallback)
-        research_model = self.model_manager.get_best_model_for_task("reasoning")
-        if research_model and 'enterprise_research' not in self.agents:
-            self.agents['research'] = Agent(
-                model=research_model,
-                tools=[DuckDuckGoTools(), WikipediaTools(), ReasoningTools()],
-                description=dedent("""\
-                You are a research specialist with expertise in finding and analyzing information.
-                Your specialty lies in gathering comprehensive data from multiple sources.
-                """),
-                instructions=dedent("""\
-                1. Use search tools to find current and relevant information
-                2. Apply systematic reasoning to analyze findings
-                3. Provide comprehensive answers with sources
-                4. Always end with 'FINAL ANSWER: [your answer]'
-                """),
-                memory=AgentMemory(),
-                markdown=True,
-                show_tool_calls=True
-            )
-        
-        print(f"Created {len(self.agents)} specialized Agno agents with enhanced models")
-    
-    def route_query(self, query: str) -> str:
-        """Route query to the most appropriate agent"""
-        q_lower = query.lower()
-        
-        # Route to specialized agents
-        if any(keyword in q_lower for keyword in ["calculate", "math", "multiply", "add", "subtract", "divide", "compute", "statistical"]):
-            if 'advanced_math' in self.agents:
-                return self._query_agent('advanced_math', query)
-            elif 'math' in self.agents:
-                return self._query_agent('math', query)
-        
-        elif any(keyword in q_lower for keyword in ["code", "programming", "function", "algorithm", "python", "javascript", "debug"]):
-            if 'advanced_coding' in self.agents:
-                return self._query_agent('advanced_coding', query)
-            elif 'coding' in self.agents:
-                return self._query_agent('coding', query)
-        
-        elif any(keyword in q_lower for keyword in ["enterprise", "analysis", "comprehensive", "detailed", "professional"]):
-            if 'enterprise_research' in self.agents:
-                return self._query_agent('enterprise_research', query)
-        
-        elif any(keyword in q_lower for keyword in ["research", "find", "search", "information", "study", "analyze"]):
-            if 'enterprise_research' in self.agents:
-                return self._query_agent('enterprise_research', query)
-            elif 'research' in self.agents:
-                return self._query_agent('research', query)
+                answer = response.content.strip()
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
+                
+                return {**st, 
+                       "final_answer": answer,
+                       "perf": {"time": time.time() - t0, "provider": "Groq-General"}}
+            except Exception as e:
+                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
+
+        # Build graph
+        g = StateGraph(EnhancedAgentState)
+        g.add_node("router", router)
+        g.add_node("math", math_node)
+        g.add_node("search", search_node)
+        g.add_node("wiki", wiki_node)
+        g.add_node("general", general_node)
         
-        elif len(query.split()) < 10:  # Simple queries
-            if 'fast_response' in self.agents:
-                return self._query_agent('fast_response', query)
-            elif 'fast' in self.agents:
-                return self._query_agent('fast', query)
+        g.set_entry_point("router")
+        g.add_conditional_edges("router", lambda s: s["agent_type"], {
+            "math": "math",
+            "search": "search", 
+            "wiki": "wiki",
+            "general": "general"
+        })
         
-        # Default to best available agent
-        if 'enterprise_research' in self.agents:
-            return self._query_agent('enterprise_research', query)
-        elif 'research' in self.agents:
-            return self._query_agent('research', query)
-        elif self.agents:
-            agent_name = list(self.agents.keys())[0]
-            return self._query_agent(agent_name, query)
+        for node in ["math", "search", "wiki", "general"]:
+            g.add_edge(node, END)
+            
+        return g.compile(checkpointer=MemorySaver())
+
+    def process_query(self, query: str) -> str:
+        """Process a query through the working system"""
+        state = {
+            "messages": [HumanMessage(content=query)],
+            "query": query,
+            "agent_type": "",
+            "final_answer": "",
+            "perf": {},
+            "tools_used": []
+        }
+        config = {"configurable": {"thread_id": f"working_{hash(query)}"}}
         
-        return "No agents available"
-    
-    def _query_agent(self, agent_name: str, query: str) -> str:
-        """Query a specific agent"""
         try:
-            agent = self.agents[agent_name]
-            response = agent.run(query)
+            result = self.graph.invoke(state, config)
+            answer = result.get("final_answer", "").strip()
             
-            # Extract final answer if present
-            if "FINAL ANSWER:" in response:
-                return response.split("FINAL ANSWER:")[-1].strip()
+            # Validation
+            if not answer or answer == query or len(answer.strip()) == 0:
+                return "Information not available"
             
-            return response.strip()
+            return answer
         except Exception as e:
-            return f"Error with {agent_name} agent: {e}"
-    
-    def get_system_info(self) -> Dict[str, Any]:
-        """Get information about available agents and models"""
-        model_breakdown = {
-            "nvidia_models": [m for m in self.model_manager.list_available_models() if m.startswith("nvidia_")],
-            "groq_models": [m for m in self.model_manager.list_available_models() if m.startswith("groq_")],
-            "ollama_models": [m for m in self.model_manager.list_available_models() if m.startswith("ollama_")],
-            "together_models": [m for m in self.model_manager.list_available_models() if m.startswith("together_")],
-            "anyscale_models": [m for m in self.model_manager.list_available_models() if m.startswith("anyscale_")],
-            "hf_models": [m for m in self.model_manager.list_available_models() if m.startswith("hf_")]
-        }
-        
-        return {
-            "available_models": self.model_manager.list_available_models(),
-            "model_breakdown": model_breakdown,
-            "active_agents": list(self.agents.keys()),
-            "agno_available": AGNO_AVAILABLE,
-            "total_models": len(self.model_manager.available_models),
-            "nvidia_available": len(model_breakdown["nvidia_models"]) > 0
-        }
-
-# ---- Enhanced Agent State for LangGraph compatibility ----
-class EnhancedAgentState(TypedDict):
-    """State structure for compatibility with existing system."""
-    messages: Annotated[List[HumanMessage | AIMessage], operator.add]
-    query: str
-    agent_type: str
-    final_answer: str
-    perf: Dict[str, Any]
-    tools_used: List[str]
-    reasoning: str
-    model_used: str
+            return f"Error processing query: {e}"
 
-# ---- Unified System with Enhanced NVIDIA Integration ----
+# ---- Compatibility Classes ----
 class UnifiedAgnoEnhancedSystem:
-    """Unified system that integrates Agno agents with NVIDIA + open-source models"""
+    """Compatibility wrapper for the working system"""
     
     def __init__(self):
-        if AGNO_AVAILABLE:
-            print("Using enhanced Agno-based system with NVIDIA + open-source models")
-            self.agno_system = AgnoEnhancedAgentSystem()
-            self.graph = self._build_compatibility_graph()
-        else:
-            print("Agno not available")
-            self.agno_system = None
-            self.graph = None
-    
-    def _build_compatibility_graph(self):
-        """Build LangGraph for compatibility with existing app.py"""
-        def process_node(state: EnhancedAgentState) -> EnhancedAgentState:
-            """Process query through enhanced Agno system"""
-            query = state.get("query", "")
-            
-            if self.agno_system:
-                answer = self.agno_system.route_query(query)
-                return {**state, "final_answer": answer}
-            else:
-                return {**state, "final_answer": "Enhanced Agno system not available"}
-        
-        g = StateGraph(EnhancedAgentState)
-        g.add_node("process", process_node)
-        g.set_entry_point("process")
-        g.add_edge("process", END)
-        
-        return g.compile(checkpointer=MemorySaver())
+        print("Initializing working system...")
+        self.agno_system = None  # Not using Agno
+        self.working_system = WorkingMultiLLMSystem()
+        self.graph = self.working_system.graph
     
     def process_query(self, query: str) -> str:
-        """Process query through the unified enhanced system"""
-        if self.agno_system:
-            return self.agno_system.route_query(query)
-        else:
-            return "Enhanced Agno system not available"
+        return self.working_system.process_query(query)
     
     def get_system_info(self) -> Dict[str, Any]:
-        """Get information about the current enhanced system"""
-        if self.agno_system:
-            return self.agno_system.get_system_info()
-        else:
-            return {"system": "agno_unavailable", "agno_available": False}
+        return {
+            "system": "working_multi_llm",
+            "agno_available": False,
+            "total_models": 1,
+            "active_agents": ["math", "search", "wiki", "general"]
+        }
 
-# ---- Build Graph Function (for compatibility) ----
-def build_graph(provider: str = "agno_enhanced"):
-    """Build graph using enhanced Agno models including NVIDIA"""
-    system = UnifiedAgnoEnhancedSystem()
-    return system.graph if system.graph else None
+# For backward compatibility
+AgnoEnhancedAgentSystem = WorkingMultiLLMSystem
+AgnoEnhancedModelManager = WorkingMultiLLMSystem
+
+def build_graph(provider: str = "working"):
+    """Build working graph"""
+    system = WorkingMultiLLMSystem()
+    return system.graph
 
-# ---- Main execution ----
 if __name__ == "__main__":
-    # Initialize the enhanced unified system
-    system = UnifiedAgnoEnhancedSystem()
-    
-    # Print system information
-    info = system.get_system_info()
-    print("Enhanced Agno System Information:")
-    for key, value in info.items():
-        if isinstance(value, dict):
-            print(f"  {key}:")
-            for subkey, subvalue in value.items():
-                print(f"    {subkey}: {subvalue}")
-        else:
-            print(f"  {key}: {value}")
+    # Test the working system
+    system = WorkingMultiLLMSystem()
     
-    # Test queries
     test_questions = [
-        "Enterprise analysis: What is 25 multiplied by 17?",
-        "Research the latest developments in quantum computing",
-        "Write an advanced Python function to calculate factorial with error handling",
-        "Find comprehensive information about Mercedes Sosa albums between 2000-2009",
-        "Quick answer: What is the capital of France?"
+        "How many studio albums were published by Mercedes Sosa between 2000 and 2009?",
+        "What is 25 multiplied by 17?",
+        "Who nominated the only Featured Article on English Wikipedia about a dinosaur?"
     ]
     
-    print("\n" + "="*60)
-    print("Testing Enhanced Agno Multi-LLM System with NVIDIA")
-    print("="*60)
-    
+    print("Testing Working Multi-LLM System:")
     for i, question in enumerate(test_questions, 1):
         print(f"\nQuestion {i}: {question}")
-        print("-" * 50)
         answer = system.process_query(question)
         print(f"Answer: {answer}")