Update veryfinal.py

veryfinal.py

@@ -1,6 +1,6 @@
 """
-Open-Source Multi-LLM Agent System
-Uses only free and open-source models - no paid APIs required
+Enhanced Agno Multi-LLM Agent System with NVIDIA Integration
+Uses open-source models + NVIDIA NIM models available through Agno framework
 """
 
 import os
@@ -9,27 +9,35 @@ 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
+# Core LangChain imports for compatibility
 from langchain_core.tools import tool
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.document_loaders import WikipediaLoader
+from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
 from langgraph.graph import StateGraph, END
 from langgraph.checkpoint.memory import MemorySaver
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
 
-# Open-source model integrations
-from langchain_groq import ChatGroq  # Free tier available
-from langchain_community.llms import Ollama
-from langchain_community.chat_models import ChatOllama
-
-# Hugging Face integration for open-source models
+# Agno imports for open-source models + NVIDIA
 try:
-    from langchain_huggingface import HuggingFacePipeline
-    from transformers import AutoTokenizer, AutoModelForCausalLM, pipeline
-    HF_AVAILABLE = True
+    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:
-    HF_AVAILABLE = False
+    AGNO_AVAILABLE = False
+    print("Agno not available. Install with: pip install agno")
 
 # Vector database imports
 import faiss
@@ -39,171 +47,109 @@ import json
 
 load_dotenv()
 
-# Enhanced system prompt
-ENHANCED_SYSTEM_PROMPT = (
-    "You are a helpful assistant tasked with answering questions using available tools. "
-    "You must provide accurate, comprehensive answers based on available information. "
-    "When answering questions, follow these guidelines:\n"
-    "1. Use available tools to gather information when needed\n"
-    "2. Provide precise, factual answers\n"
-    "3. For numbers: don't use commas or units unless specified\n"
-    "4. For strings: don't use articles or abbreviations, write digits in plain text\n"
-    "5. For lists: apply above rules based on element type\n"
-    "6. Always end with 'FINAL ANSWER: [YOUR ANSWER]'\n"
-    "7. Be concise but thorough in your reasoning\n"
-    "8. 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
+# 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.
 
-@tool
-def add(a: int, b: int) -> int:
-    """Add two integers and return the sum."""
-    return a + b
+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
 
-@tool
-def subtract(a: int, b: int) -> int:
-    """Subtract the second integer from the first and return the difference."""
-    return a - b
+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
+""")
 
-@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
-
-@tool
-def modulus(a: int, b: int) -> int:
-    """Return the remainder when dividing the first integer by the second."""
-    return a % b
-
-@tool
-def optimized_web_search(query: str) -> str:
-    """Perform web search using free DuckDuckGo (fallback if Tavily not available)."""
-    try:
-        # Try Tavily first (free tier)
-        if os.getenv("TAVILY_API_KEY"):
-            time.sleep(random.uniform(0.7, 1.5))
-            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','')[:800]}</Doc>"
-                for d in docs
-            )
-        else:
-            # Fallback to DuckDuckGo (completely free)
-            try:
-                from duckduckgo_search import DDGS
-                with DDGS() as ddgs:
-                    results = list(ddgs.text(query, max_results=3))
-                    return "\n\n---\n\n".join(
-                        f"<Doc url='{r.get('href','')}'>{r.get('body','')[:800]}</Doc>"
-                        for r in results
-                    )
-            except ImportError:
-                return "Web search not available - install duckduckgo-search for free web search"
-    except Exception as e:
-        return f"Web search failed: {e}"
-
-@tool
-def optimized_wiki_search(query: str) -> str:
-    """Perform Wikipedia search - completely free."""
-    try:
-        time.sleep(random.uniform(0.3, 1))
-        docs = WikipediaLoader(query=query, load_max_docs=2).load()
-        return "\n\n---\n\n".join(
-            f"<Doc src='{d.metadata.get('source','Wikipedia')}'>{d.page_content[:1000]}</Doc>"
-            for d in docs
-        )
-    except Exception as e:
-        return f"Wikipedia search failed: {e}"
-
-# ---- Open-Source Model Manager ----
-class OpenSourceModelManager:
-    """Manages only open-source and free models"""
+# ---- Enhanced Model Manager with NVIDIA Support ----
+class AgnoEnhancedModelManager:
+    """Manages open-source models + NVIDIA NIM models available through Agno"""
     
     def __init__(self):
         self.available_models = {}
-        self._initialize_models()
+        self._initialize_all_models()
     
-    def _initialize_models(self):
-        """Initialize only open-source 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}")
         
-        # 1. Groq (Free tier with open-source models)
+        # 2. Groq (Free tier with open-source models)
         if os.getenv("GROQ_API_KEY"):
             try:
-                self.available_models['groq_llama3_70b'] = ChatGroq(
-                    model="llama3-70b-8192", 
-                    temperature=0, 
-                    api_key=os.getenv("GROQ_API_KEY")
-                )
-                self.available_models['groq_llama3_8b'] = ChatGroq(
-                    model="llama3-8b-8192", 
-                    temperature=0, 
-                    api_key=os.getenv("GROQ_API_KEY")
-                )
-                self.available_models['groq_mixtral'] = ChatGroq(
-                    model="mixtral-8x7b-32768", 
-                    temperature=0, 
-                    api_key=os.getenv("GROQ_API_KEY")
-                )
-                self.available_models['groq_gemma'] = ChatGroq(
-                    model="gemma-7b-it", 
-                    temperature=0, 
-                    api_key=os.getenv("GROQ_API_KEY")
-                )
-                print("Groq models initialized (free tier)")
+                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")
             except Exception as e:
                 print(f"Groq models not available: {e}")
         
-        # 2. Ollama (Completely free local models)
+        # 3. Ollama (Completely free local models)
         try:
-            # Test if Ollama is running
-            test_model = ChatOllama(model="llama3", base_url="http://localhost:11434")
-            # If no error, add Ollama models
-            self.available_models['ollama_llama3'] = ChatOllama(model="llama3")
-            self.available_models['ollama_llama3_70b'] = ChatOllama(model="llama3:70b")
-            self.available_models['ollama_mistral'] = ChatOllama(model="mistral")
-            self.available_models['ollama_phi3'] = ChatOllama(model="phi3")
-            self.available_models['ollama_codellama'] = ChatOllama(model="codellama")
-            self.available_models['ollama_gemma'] = ChatOllama(model="gemma")
-            self.available_models['ollama_qwen'] = ChatOllama(model="qwen")
-            print("Ollama models initialized (local)")
+            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 not available: {e}")
+            print(f"Ollama models not available: {e}")
         
-        # 3. Hugging Face Transformers (Completely free)
-        if HF_AVAILABLE:
+        # 4. Together AI (Open-source models)
+        if os.getenv("TOGETHER_API_KEY"):
             try:
-                # Small models that can run on CPU
-                self.available_models['hf_gpt2'] = self._create_hf_model("gpt2")
-                self.available_models['hf_distilgpt2'] = self._create_hf_model("distilgpt2")
-                print("Hugging Face models initialized (local)")
+                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")
             except Exception as e:
-                print(f"Hugging Face models not available: {e}")
+                print(f"Together AI models not available: {e}")
         
-        print(f"Total available open-source models: {len(self.available_models)}")
-    
-    def _create_hf_model(self, model_name: str):
-        """Create Hugging Face pipeline model"""
+        # 5. Anyscale (Open-source models)
+        if os.getenv("ANYSCALE_API_KEY"):
+            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")
+            except Exception as e:
+                print(f"Anyscale models not available: {e}")
+        
+        # 6. Hugging Face (Open-source models)
         try:
-            pipe = pipeline(
-                "text-generation",
-                model=model_name,
-                max_length=512,
-                do_sample=True,
-                temperature=0.7,
-                pad_token_id=50256
-            )
-            return HuggingFacePipeline(pipeline=pipe)
+            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"Failed to create HF model {model_name}: {e}")
-            return None
+            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"""
@@ -216,20 +162,26 @@ class OpenSourceModelManager:
     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 models for reasoning
-            for model_name in ['groq_llama3_70b', 'ollama_llama3_70b', 'groq_mixtral', 'ollama_llama3']:
+            # 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 ['ollama_codellama', 'groq_llama3_70b', 'ollama_llama3']:
+            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', 'groq_gemma', 'ollama_phi3', 'hf_distilgpt2']:
+            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]
         
@@ -238,246 +190,333 @@ class OpenSourceModelManager:
             return list(self.available_models.values())[0]
         return None
 
-# ---- Enhanced Agent State ----
-class EnhancedAgentState(TypedDict):
-    """State structure for the enhanced multi-LLM agent 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
-
-# ---- Open-Source Multi-LLM System ----
-class OpenSourceMultiLLMSystem:
-    """
-    Multi-LLM system using only open-source and free models
-    """
+# ---- Enhanced Specialized Agno Agents with NVIDIA ----
+class AgnoEnhancedAgentSystem:
+    """System of specialized Agno agents using open-source + NVIDIA models"""
     
     def __init__(self):
-        self.model_manager = OpenSourceModelManager()
-        self.tools = [
-            multiply, add, subtract, divide, modulus,
-            optimized_web_search, optimized_wiki_search
-        ]
-        self.graph = self._build_graph()
+        self.model_manager = AgnoEnhancedModelManager()
+        self.agents = {}
+        self._create_specialized_agents()
     
-    def _build_graph(self) -> StateGraph:
-        """Build the LangGraph state machine with open-source models."""
+    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
         
-        def router(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Route queries to appropriate model based on complexity and content analysis."""
-            q = st["query"].lower()
-            
-            # Enhanced routing logic
-            if any(keyword in q for keyword in ["calculate", "compute", "math", "multiply", "add", "subtract", "divide"]):
-                model_type = "reasoning"
-                agent_type = "math"
-            elif any(keyword in q for keyword in ["search", "find", "lookup", "wikipedia", "information about"]):
-                model_type = "fast"
-                agent_type = "search_enhanced"
-            elif any(keyword in q for keyword in ["code", "programming", "function", "algorithm"]):
-                model_type = "coding"
-                agent_type = "coding"
-            elif len(q.split()) > 20:  # Complex queries
-                model_type = "reasoning"
-                agent_type = "complex"
-            else:
-                model_type = "fast"
-                agent_type = "simple"
-            
-            # Get the best model for this task
-            selected_model = self.model_manager.get_best_model_for_task(model_type)
-            model_name = "unknown"
-            for name, model in self.model_manager.available_models.items():
-                if model == selected_model:
-                    model_name = name
-                    break
-            
-            return {**st, "agent_type": agent_type, "tools_used": [], "reasoning": "", "model_used": model_name}
-
-        def math_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process mathematical queries."""
-            return self._process_with_model(st, "reasoning", "Mathematical calculation using open-source model")
-
-        def search_enhanced_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process query with search enhancement."""
-            t0 = time.time()
-            tools_used = []
-            
-            try:
-                # Determine search strategy
-                query = st["query"]
-                search_results = ""
+        # 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.
                 
-                if any(keyword in query.lower() for keyword in ["wikipedia", "wiki"]):
-                    search_results = optimized_wiki_search.invoke({"query": query})
-                    tools_used.append("wikipedia_search")
-                else:
-                    search_results = optimized_web_search.invoke({"query": query})
-                    tools_used.append("web_search")
-                
-                enhanced_query = f"""
-                Original Question: {query}
+                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.
                 
-                Search Results:
-                {search_results}
+                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.
                 
-                Based on the search results above, provide a direct answer to the original 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.
                 
-                # Use fast model for search-enhanced queries
-                model = self.model_manager.get_best_model_for_task("fast")
-                if model:
-                    sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-                    res = model.invoke([sys, HumanMessage(content=enhanced_query)])
-                    
-                    answer = res.content.strip() if hasattr(res, 'content') else str(res).strip()
-                    if "FINAL ANSWER:" in answer:
-                        answer = answer.split("FINAL ANSWER:")[-1].strip()
-                    
-                    return {**st,
-                            "final_answer": answer,
-                            "tools_used": tools_used,
-                            "reasoning": "Used search enhancement with open-source model",
-                            "perf": {"time": time.time() - t0, "prov": "Search-Enhanced"}}
-                else:
-                    return {**st, "final_answer": "No models available", "perf": {"error": "No models"}}
-            except Exception as e:
-                return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
-
-        def coding_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process coding-related queries."""
-            return self._process_with_model(st, "coding", "Code generation using open-source model")
-
-        def complex_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process complex queries."""
-            return self._process_with_model(st, "reasoning", "Complex reasoning using open-source model")
-
-        def simple_node(st: EnhancedAgentState) -> EnhancedAgentState:
-            """Process simple queries."""
-            return self._process_with_model(st, "fast", "Simple query using fast open-source model")
-
-        # Build graph
-        g = StateGraph(EnhancedAgentState)
-        g.add_node("router", router)
-        g.add_node("math", math_node)
-        g.add_node("search_enhanced", search_enhanced_node)
-        g.add_node("coding", coding_node)
-        g.add_node("complex", complex_node)
-        g.add_node("simple", simple_node)
+                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
+            )
         
-        g.set_entry_point("router")
-        g.add_conditional_edges("router", lambda s: s["agent_type"], {
-            "math": "math",
-            "search_enhanced": "search_enhanced",
-            "coding": "coding",
-            "complex": "complex",
-            "simple": "simple"
-        })
+        # 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
+            )
         
-        for node in ["math", "search_enhanced", "coding", "complex", "simple"]:
-            g.add_edge(node, END)
-            
-        return g.compile(checkpointer=MemorySaver())
+        print(f"Created {len(self.agents)} specialized Agno agents with enhanced models")
     
-    def _process_with_model(self, st: EnhancedAgentState, model_type: str, reasoning: str) -> EnhancedAgentState:
-        """Process query with specified model type"""
-        t0 = time.time()
-        try:
-            model = self.model_manager.get_best_model_for_task(model_type)
-            if not model:
-                return {**st, "final_answer": "No suitable model available", "perf": {"error": "No model"}}
-            
-            enhanced_query = f"""
-            Question: {st["query"]}
-            
-            Please provide a direct, accurate answer to this question.
-            """
-            
-            sys = SystemMessage(content=ENHANCED_SYSTEM_PROMPT)
-            res = model.invoke([sys, HumanMessage(content=enhanced_query)])
-            
-            answer = res.content.strip() if hasattr(res, 'content') else str(res).strip()
-            if "FINAL ANSWER:" in answer:
-                answer = answer.split("FINAL ANSWER:")[-1].strip()
-            
-            return {**st,
-                    "final_answer": answer,
-                    "reasoning": reasoning,
-                    "perf": {"time": time.time() - t0, "prov": f"OpenSource-{model_type}"}}
-        except Exception as e:
-            return {**st, "final_answer": f"Error: {e}", "perf": {"error": str(e)}}
-
-    def process_query(self, q: str) -> str:
-        """Process a query through the open-source multi-LLM system."""
-        state = {
-            "messages": [HumanMessage(content=q)],
-            "query": q,
-            "agent_type": "",
-            "final_answer": "",
-            "perf": {},
-            "tools_used": [],
-            "reasoning": "",
-            "model_used": ""
-        }
-        cfg = {"configurable": {"thread_id": f"opensource_qa_{hash(q)}"}}
+    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)
+        
+        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)
         
+        # 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)
+        
+        return "No agents available"
+    
+    def _query_agent(self, agent_name: str, query: str) -> str:
+        """Query a specific agent"""
         try:
-            out = self.graph.invoke(state, cfg)
-            answer = out.get("final_answer", "").strip()
+            agent = self.agents[agent_name]
+            response = agent.run(query)
             
-            # Ensure we don't return the question as the answer
-            if answer == q or answer.startswith(q):
-                return "Information not available"
+            # Extract final answer if present
+            if "FINAL ANSWER:" in response:
+                return response.split("FINAL ANSWER:")[-1].strip()
             
-            return answer if answer else "No answer generated"
+            return response.strip()
         except Exception as e:
-            return f"Error processing query: {e}"
+            return f"Error with {agent_name} agent: {e}"
     
     def get_system_info(self) -> Dict[str, Any]:
-        """Get information about available open-source models"""
+        """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),
-            "model_types": {
-                "groq_free_tier": [m for m in self.model_manager.list_available_models() if m.startswith("groq_")],
-                "ollama_local": [m for m in self.model_manager.list_available_models() if m.startswith("ollama_")],
-                "huggingface_local": [m for m in self.model_manager.list_available_models() if m.startswith("hf_")]
-            }
+            "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
+
+# ---- Unified System with Enhanced NVIDIA Integration ----
+class UnifiedAgnoEnhancedSystem:
+    """Unified system that integrates Agno agents with NVIDIA + open-source models"""
+    
+    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())
+    
+    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"
+    
+    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}
+
 # ---- Build Graph Function (for compatibility) ----
-def build_graph(provider: str = "opensource"):
-    """Build graph using only open-source models"""
-    return OpenSourceMultiLLMSystem().graph
+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
 
 # ---- Main execution ----
 if __name__ == "__main__":
-    # Initialize the open-source system
-    system = OpenSourceMultiLLMSystem()
+    # Initialize the enhanced unified system
+    system = UnifiedAgnoEnhancedSystem()
     
     # Print system information
     info = system.get_system_info()
-    print("Open-Source System Information:")
-    print(f"Total Models Available: {info['total_models']}")
-    for category, models in info['model_types'].items():
-        if models:
-            print(f"  {category}: {models}")
+    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 queries
     test_questions = [
-        "What is 25 multiplied by 17?",
-        "Find information about Mercedes Sosa albums between 2000-2009",
-        "Write a simple Python function to calculate factorial",
-        "Explain quantum computing in simple terms",
-        "What is the capital of France?"
+        "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?"
     ]
     
     print("\n" + "="*60)
-    print("Testing Open-Source Multi-LLM System")
+    print("Testing Enhanced Agno Multi-LLM System with NVIDIA")
     print("="*60)
     
     for i, question in enumerate(test_questions, 1):