Update veryfinal.py

veryfinal.py

@@ -1,462 +1,360 @@
-"""Enhanced LangGraph + Agno Hybrid Agent System"""
-import os, time, random, asyncio
-from dotenv import load_dotenv
-from typing import List, Dict, Any, TypedDict, Annotated
-import operator
+""" Enhanced Hybrid Agent Evaluation Runner"""
+import os
+import inspect
+import gradio as gr
+import requests
+import pandas as pd
+from langchain_core.messages import HumanMessage
+from agent import HybridLangGraphAgnoSystem
 
-# LangGraph imports
-from langgraph.graph import START, StateGraph, MessagesState
-from langgraph.prebuilt import tools_condition
-from langgraph.prebuilt import ToolNode
-from langgraph.checkpoint.memory import MemorySaver
+# --- Constants ---
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# LangChain imports
-from langchain_core.messages import SystemMessage, HumanMessage, AIMessage
-from langchain_core.tools import tool
-from langchain_groq import ChatGroq
-from langchain_google_genai import ChatGoogleGenerativeAI
-from langchain_nvidia_ai_endpoints import ChatNVIDIA
-from langchain_community.tools.tavily_search import TavilySearchResults
-from langchain_community.document_loaders import WikipediaLoader, ArxivLoader
-from langchain_community.vectorstores import FAISS
-from langchain_nvidia_ai_endpoints import NVIDIAEmbeddings
-from langchain.tools.retriever import create_retriever_tool
-from langchain_text_splitters import RecursiveCharacterTextSplitter
-from langchain_community.document_loaders import JSONLoader
-
-# Agno imports
-from agno.agent import Agent
-from agno.models.groq import GroqChat
-from agno.models.google import GeminiChat
-from agno.tools.duckduckgo import DuckDuckGoTools
-from agno.memory.agent import AgentMemory
-from agno.storage.agent import AgentStorage
-
-load_dotenv()
+# --- Enhanced Basic Agent Definition ---
+class BasicAgent:
+    """A hybrid LangGraph + Agno agent with performance optimization."""
+    def __init__(self):
+        print("BasicAgent initialized with Hybrid LangGraph + Agno System.")
+        self.hybrid_system = HybridLangGraphAgnoSystem()
 
-# Enhanced Rate Limiter with Performance Optimization
-class PerformanceRateLimiter:
-    def __init__(self, requests_per_minute: int, provider_name: str):
-        self.requests_per_minute = requests_per_minute
-        self.provider_name = provider_name
-        self.request_times = []
-        self.consecutive_failures = 0
-        self.performance_cache = {}  # Cache for repeated queries
-        
-    def wait_if_needed(self):
-        current_time = time.time()
-        self.request_times = [t for t in self.request_times if current_time - t < 60]
+    def __call__(self, question: str) -> str:
+        print(f"Agent received question: {question}")
         
-        if len(self.request_times) >= self.requests_per_minute:
-            wait_time = 60 - (current_time - self.request_times[0]) + random.uniform(1, 3)
-            time.sleep(wait_time)
-        
-        if self.consecutive_failures > 0:
-            backoff_time = min(2 ** self.consecutive_failures, 30) + random.uniform(0.5, 1.5)
-            time.sleep(backoff_time)
-        
-        self.request_times.append(current_time)
-    
-    def record_success(self):
-        self.consecutive_failures = 0
-    
-    def record_failure(self):
-        self.consecutive_failures += 1
-
-# Initialize optimized rate limiters
-gemini_limiter = PerformanceRateLimiter(requests_per_minute=28, provider_name="Gemini")
-groq_limiter = PerformanceRateLimiter(requests_per_minute=28, provider_name="Groq")
-nvidia_limiter = PerformanceRateLimiter(requests_per_minute=4, provider_name="NVIDIA")
-
-# Agno Agent Setup with Performance Optimization
-def create_agno_agents():
-    """Create high-performance Agno agents"""
-    
-    # Storage for persistent memory
-    storage = AgentStorage(
-        table_name="agent_sessions",
-        db_file="tmp/agent_storage.db"
-    )
-    
-    # Math specialist using Groq (fastest)
-    math_agent = Agent(
-        name="MathSpecialist",
-        model=GroqChat(
-            model="llama-3.3-70b-versatile",
-            api_key=os.getenv("GROQ_API_KEY"),
-            temperature=0
-        ),
-        description="Expert mathematical problem solver",
-        instructions=[
-            "Solve mathematical problems with precision",
-            "Show step-by-step calculations",
-            "Use tools for complex computations",
-            "Always provide numerical answers"
-        ],
-        memory=AgentMemory(
-            db=storage,
-            create_user_memories=True,
-            create_session_summary=True
-        ),
-        show_tool_calls=False,
-        markdown=False
-    )
-    
-    # Research specialist using Gemini (most capable)
-    research_agent = Agent(
-        name="ResearchSpecialist",
-        model=GeminiChat(
-            model="gemini-2.0-flash-lite",
-            api_key=os.getenv("GOOGLE_API_KEY"),
-            temperature=0
-        ),
-        description="Expert research and information gathering specialist",
-        instructions=[
-            "Conduct thorough research using available tools",
-            "Synthesize information from multiple sources",
-            "Provide comprehensive, well-cited answers",
-            "Focus on accuracy and relevance"
-        ],
-        tools=[DuckDuckGoTools()],
-        memory=AgentMemory(
-            db=storage,
-            create_user_memories=True,
-            create_session_summary=True
-        ),
-        show_tool_calls=False,
-        markdown=False
-    )
-    
-    return {
-        "math": math_agent,
-        "research": research_agent
-    }
-
-# LangGraph Tools (optimized)
-@tool
-def multiply(a: int, b: int) -> int:
-    """Multiply two numbers."""
-    return a * b
-
-@tool
-def add(a: int, b: int) -> int:
-    """Add two numbers."""
-    return a + b
-
-@tool
-def subtract(a: int, b: int) -> int:
-    """Subtract two numbers."""
-    return a - b
+        try:
+            # Process query using hybrid system
+            result = self.hybrid_system.process_query(question)
+            
+            # Extract final answer
+            answer = result.get("answer", "No response generated")
+            
+            # Clean up the answer - extract only final answer if present
+            if "FINAL ANSWER:" in answer:
+                final_answer = answer.split("FINAL ANSWER:")[-1].strip()
+            else:
+                final_answer = answer.strip()
+            
+            # Log performance metrics for debugging
+            metrics = result.get("performance_metrics", {})
+            provider = result.get("provider_used", "Unknown")
+            processing_time = metrics.get("total_time", 0)
+            
+            print(f"Provider used: {provider}, Processing time: {processing_time:.2f}s")
+            
+            return final_answer
+            
+        except Exception as e:
+            print(f"Error in agent processing: {e}")
+            return f"Error: {str(e)}"
 
-@tool
-def divide(a: int, b: int) -> float:
-    """Divide two numbers."""
-    if b == 0:
-        raise ValueError("Cannot divide by zero.")
-    return a / b
+def run_and_submit_all(profile: gr.OAuthProfile | None):
+    """
+    Fetches all questions, runs the Enhanced Hybrid Agent on them, submits all answers,
+    and displays the results with performance metrics.
+    """
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
-@tool
-def modulus(a: int, b: int) -> int:
-    """Get the modulus of two numbers."""
-    return a % b
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button.", None
 
-@tool
-def optimized_web_search(query: str) -> str:
-    """Optimized web search with caching."""
-    try:
-        time.sleep(random.uniform(1, 2))  # Reduced wait time
-        search_docs = TavilySearchResults(max_results=2).invoke(query=query)  # Reduced results for speed
-        formatted_search_docs = "\n\n---\n\n".join([
-            f'<Document source="{doc.get("url", "")}" />\n{doc.get("content", "")[:500]}\n</Document>'  # Truncated for speed
-            for doc in search_docs
-        ])
-        return formatted_search_docs
-    except Exception as e:
-        return f"Web search failed: {str(e)}"
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
 
-@tool
-def optimized_wiki_search(query: str) -> str:
-    """Optimized Wikipedia search."""
+    # 1. Instantiate Enhanced Hybrid Agent
     try:
-        time.sleep(random.uniform(0.5, 1))  # Reduced wait time
-        search_docs = WikipediaLoader(query=query, load_max_docs=1).load()
-        formatted_search_docs = "\n\n---\n\n".join([
-            f'<Document source="{doc.metadata["source"]}" />\n{doc.page_content[:800]}\n</Document>'  # Truncated for speed
-            for doc in search_docs
-        ])
-        return formatted_search_docs
+        agent = BasicAgent()
+        print("✅ Hybrid LangGraph + Agno Agent initialized successfully")
     except Exception as e:
-        return f"Wikipedia search failed: {str(e)}"
+        print(f"❌ Error instantiating hybrid agent: {e}")
+        return f"Error initializing hybrid agent: {e}", None
+    
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+    print(f"🔗 Agent code repository: {agent_code}")
 
-# Optimized FAISS setup
-def setup_optimized_faiss():
-    """Setup optimized FAISS vector store"""
+    # 2. Fetch Questions
+    print(f"📥 Fetching questions from: {questions_url}")
     try:
-        jq_schema = """
-        {
-          page_content: .Question,
-          metadata: {
-            task_id: .task_id,
-            Final_answer: ."Final answer"
-          }
-        }
-        """
-        
-        json_loader = JSONLoader(file_path="metadata.jsonl", jq_schema=jq_schema, json_lines=True, text_content=False)
-        json_docs = json_loader.load()
-        
-        # Smaller chunks for faster processing
-        text_splitter = RecursiveCharacterTextSplitter(chunk_size=256, chunk_overlap=50)
-        json_chunks = text_splitter.split_documents(json_docs)
-        
-        embeddings = NVIDIAEmbeddings(
-            model="nvidia/nv-embedqa-e5-v5",
-            api_key=os.getenv("NVIDIA_API_KEY")
-        )
-        vector_store = FAISS.from_documents(json_chunks, embeddings)
-        
-        return vector_store
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_data = response.json()
+        if not questions_data:
+             print("❌ Fetched questions list is empty.")
+             return "Fetched questions list is empty or invalid format.", None
+        print(f"✅ Fetched {len(questions_data)} questions successfully.")
+    except requests.exceptions.RequestException as e:
+        print(f"❌ Error fetching questions: {e}")
+        return f"Error fetching questions: {e}", None
     except Exception as e:
-        print(f"FAISS setup failed: {e}")
-        return None
+        print(f"❌ An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
 
-# Enhanced State with Performance Tracking
-class EnhancedAgentState(TypedDict):
-    messages: Annotated[List[HumanMessage | AIMessage], operator.add]
-    query: str
-    agent_type: str
-    final_answer: str
-    performance_metrics: Dict[str, Any]
-    agno_response: str
-
-# Hybrid LangGraph + Agno System
-class HybridLangGraphAgnoSystem:
-    def __init__(self):
-        self.agno_agents = create_agno_agents()
-        self.vector_store = setup_optimized_faiss()
-        self.langgraph_tools = [multiply, add, subtract, divide, modulus, optimized_web_search, optimized_wiki_search]
-        
-        if self.vector_store:
-            retriever = self.vector_store.as_retriever(search_type="similarity", search_kwargs={"k": 2})
-            retriever_tool = create_retriever_tool(
-                retriever=retriever,
-                name="Question_Search",
-                description="Retrieve similar questions from knowledge base."
-            )
-            self.langgraph_tools.append(retriever_tool)
-        
-        self.graph = self._build_hybrid_graph()
+    # 3. Run Enhanced Hybrid Agent with Performance Tracking
+    results_log = []
+    answers_payload = []
+    performance_stats = {
+        "langgraph_math": 0,
+        "agno_research": 0,
+        "langgraph_retrieval": 0,
+        "agno_general": 0,
+        "errors": 0,
+        "total_processing_time": 0
+    }
     
-    def _build_hybrid_graph(self):
-        """Build hybrid LangGraph with Agno integration"""
-        
-        # LangGraph LLMs
-        groq_llm = ChatGroq(model="llama-3.3-70b-versatile", temperature=0)
-        gemini_llm = ChatGoogleGenerativeAI(model="gemini-2.0-flash-lite", temperature=0)
+    print(f"🚀 Running Enhanced Hybrid Agent on {len(questions_data)} questions...")
+    
+    for i, item in enumerate(questions_data, 1):
+        task_id = item.get("task_id")
+        question_text = item.get("question")
         
-        def router_node(state: EnhancedAgentState) -> EnhancedAgentState:
-            """Smart routing between LangGraph and Agno"""
-            query = state["query"].lower()
-            
-            # Route math to LangGraph (faster for calculations)
-            if any(word in query for word in ['calculate', 'math', 'multiply', 'add', 'subtract', 'divide']):
-                agent_type = "langgraph_math"
-            # Route complex research to Agno (better reasoning)
-            elif any(word in query for word in ['research', 'analyze', 'explain', 'compare']):
-                agent_type = "agno_research"
-            # Route factual queries to LangGraph (faster retrieval)
-            elif any(word in query for word in ['what is', 'who is', 'when', 'where']):
-                agent_type = "langgraph_retrieval"
-            else:
-                agent_type = "agno_general"
+        if not task_id or question_text is None:
+            print(f"⚠️ Skipping item {i} with missing task_id or question: {item}")
+            continue
             
-            return {**state, "agent_type": agent_type}
+        print(f"🔄 Processing question {i}/{len(questions_data)}: {task_id}")
         
-        def langgraph_math_node(state: EnhancedAgentState) -> EnhancedAgentState:
-            """LangGraph math processing (optimized for speed)"""
-            groq_limiter.wait_if_needed()
+        try:
+            # Get detailed result from hybrid system
+            detailed_result = agent.hybrid_system.process_query(question_text)
+            submitted_answer = detailed_result.get("answer", "No response")
             
-            start_time = time.time()
-            llm_with_tools = groq_llm.bind_tools([multiply, add, subtract, divide, modulus])
+            # Extract final answer
+            if "FINAL ANSWER:" in submitted_answer:
+                clean_answer = submitted_answer.split("FINAL ANSWER:")[-1].strip()
+            else:
+                clean_answer = submitted_answer.strip()
             
-            system_msg = SystemMessage(content="You are a fast mathematical calculator. Use tools for calculations. Provide precise numerical answers. Format: FINAL ANSWER: [result]")
-            messages = [system_msg, HumanMessage(content=state["query"])]
+            # Track performance metrics
+            provider = detailed_result.get("provider_used", "Unknown")
+            processing_time = detailed_result.get("performance_metrics", {}).get("total_time", 0)
             
-            try:
-                response = llm_with_tools.invoke(messages)
-                processing_time = time.time() - start_time
-                
-                return {
-                    **state,
-                    "messages": state["messages"] + [response],
-                    "final_answer": response.content,
-                    "performance_metrics": {"processing_time": processing_time, "provider": "LangGraph-Groq"}
-                }
-            except Exception as e:
-                return {**state, "final_answer": f"Math processing error: {str(e)}"}
-        
-        def agno_research_node(state: EnhancedAgentState) -> EnhancedAgentState:
-            """Agno research processing (optimized for quality)"""
-            gemini_limiter.wait_if_needed()
+            # Update performance stats
+            if "LangGraph" in provider:
+                if "Math" in provider:
+                    performance_stats["langgraph_math"] += 1
+                else:
+                    performance_stats["langgraph_retrieval"] += 1
+            elif "Agno" in provider:
+                if "Research" in provider:
+                    performance_stats["agno_research"] += 1
+                else:
+                    performance_stats["agno_general"] += 1
             
-            start_time = time.time()
-            try:
-                # Use Agno's research agent for complex reasoning
-                response = self.agno_agents["research"].run(state["query"], stream=False)
-                processing_time = time.time() - start_time
-                
-                return {
-                    **state,
-                    "agno_response": response,
-                    "final_answer": response,
-                    "performance_metrics": {"processing_time": processing_time, "provider": "Agno-Gemini"}
-                }
-            except Exception as e:
-                return {**state, "final_answer": f"Research processing error: {str(e)}"}
-        
-        def langgraph_retrieval_node(state: EnhancedAgentState) -> EnhancedAgentState:
-            """LangGraph retrieval processing (optimized for speed)"""
-            groq_limiter.wait_if_needed()
+            performance_stats["total_processing_time"] += processing_time
             
-            start_time = time.time()
-            llm_with_tools = groq_llm.bind_tools(self.langgraph_tools)
+            answers_payload.append({"task_id": task_id, "submitted_answer": clean_answer})
+            results_log.append({
+                "Task ID": task_id, 
+                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
+                "Submitted Answer": clean_answer,
+                "Provider": provider,
+                "Processing Time (s)": f"{processing_time:.2f}"
+            })
             
-            system_msg = SystemMessage(content="You are a fast information retrieval assistant. Use search tools efficiently. Provide concise, accurate answers. Format: FINAL ANSWER: [answer]")
-            messages = [system_msg, HumanMessage(content=state["query"])]
+            print(f"✅ Question {i} processed successfully using {provider}")
             
-            try:
-                response = llm_with_tools.invoke(messages)
-                processing_time = time.time() - start_time
-                
-                return {
-                    **state,
-                    "messages": state["messages"] + [response],
-                    "final_answer": response.content,
-                    "performance_metrics": {"processing_time": processing_time, "provider": "LangGraph-Retrieval"}
-                }
-            except Exception as e:
-                return {**state, "final_answer": f"Retrieval processing error: {str(e)}"}
+        except Exception as e:
+             print(f"❌ Error running agent on task {task_id}: {e}")
+             performance_stats["errors"] += 1
+             results_log.append({
+                 "Task ID": task_id, 
+                 "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
+                 "Submitted Answer": f"AGENT ERROR: {e}",
+                 "Provider": "Error",
+                 "Processing Time (s)": "0.00"
+             })
+
+    if not answers_payload:
+        print("❌ Agent did not produce any answers to submit.")
+        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
+
+    # 4. Performance Summary
+    avg_processing_time = performance_stats["total_processing_time"] / len(answers_payload) if answers_payload else 0
+    performance_summary = f"""
+    📊 Performance Summary:
+    • LangGraph Math: {performance_stats['langgraph_math']} queries
+    • Agno Research: {performance_stats['agno_research']} queries  
+    • LangGraph Retrieval: {performance_stats['langgraph_retrieval']} queries
+    • Agno General: {performance_stats['agno_general']} queries
+    • Errors: {performance_stats['errors']} queries
+    • Average Processing Time: {avg_processing_time:.2f}s
+    • Total Processing Time: {performance_stats['total_processing_time']:.2f}s
+    """
+    print(performance_summary)
+
+    # 5. Prepare Submission 
+    submission_data = {
+        "username": username.strip(), 
+        "agent_code": agent_code, 
+        "answers": answers_payload
+    }
+    status_update = f"🎯 Hybrid Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    print(status_update)
+
+    # 6. Submit Results
+    print(f"📤 Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=120)  # Increased timeout
+        response.raise_for_status()
+        result_data = response.json()
         
-        def agno_general_node(state: EnhancedAgentState) -> EnhancedAgentState:
-            """Agno general processing"""
-            gemini_limiter.wait_if_needed()
-            
-            start_time = time.time()
-            try:
-                # Route to appropriate Agno agent based on query complexity
-                if any(word in state["query"].lower() for word in ['calculate', 'compute']):
-                    response = self.agno_agents["math"].run(state["query"], stream=False)
-                else:
-                    response = self.agno_agents["research"].run(state["query"], stream=False)
-                
-                processing_time = time.time() - start_time
-                
-                return {
-                    **state,
-                    "agno_response": response,
-                    "final_answer": response,
-                    "performance_metrics": {"processing_time": processing_time, "provider": "Agno-General"}
-                }
-            except Exception as e:
-                return {**state, "final_answer": f"General processing error: {str(e)}"}
+        final_status = (
+            f"🎉 Submission Successful!\n"
+            f"👤 User: {result_data.get('username')}\n"
+            f"🏆 Overall Score: {result_data.get('score', 'N/A')}% "
+            f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
+            f"💬 Message: {result_data.get('message', 'No message received.')}\n"
+            f"{performance_summary}"
+        )
+        print("✅ Submission successful.")
+        results_df = pd.DataFrame(results_log)
+        return final_status, results_df
         
-        def route_agent(state: EnhancedAgentState) -> str:
-            """Route to appropriate processing node"""
-            agent_type = state.get("agent_type", "agno_general")
-            return agent_type
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            error_detail += f" Response: {e.response.text[:500]}"
+        status_message = f"❌ Submission Failed: {error_detail}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
         
-        # Build the graph
-        builder = StateGraph(EnhancedAgentState)
-        builder.add_node("router", router_node)
-        builder.add_node("langgraph_math", langgraph_math_node)
-        builder.add_node("agno_research", agno_research_node)
-        builder.add_node("langgraph_retrieval", langgraph_retrieval_node)
-        builder.add_node("agno_general", agno_general_node)
+    except requests.exceptions.Timeout:
+        status_message = "❌ Submission Failed: The request timed out."
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
         
-        builder.set_entry_point("router")
-        builder.add_conditional_edges(
-            "router",
-            route_agent,
-            {
-                "langgraph_math": "langgraph_math",
-                "agno_research": "agno_research",
-                "langgraph_retrieval": "langgraph_retrieval",
-                "agno_general": "agno_general"
-            }
-        )
+    except requests.exceptions.RequestException as e:
+        status_message = f"❌ Submission Failed: Network error - {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
         
-        # All nodes end the workflow
-        for node in ["langgraph_math", "agno_research", "langgraph_retrieval", "agno_general"]:
-            builder.add_edge(node, "END")
+    except Exception as e:
+        status_message = f"❌ An unexpected error occurred during submission: {e}"
+        print(status_message)
+        results_df = pd.DataFrame(results_log)
+        return status_message, results_df
+
+# --- Enhanced Gradio Interface ---
+with gr.Blocks(title="Enhanced Hybrid Agent Evaluation") as demo:
+    gr.Markdown("# 🚀 Enhanced Hybrid LangGraph + Agno Agent Evaluation Runner")
+    gr.Markdown(
+        """
+        ## 🎯 **Advanced AI Agent System**
         
-        memory = MemorySaver()
-        return builder.compile(checkpointer=memory)
-    
-    def process_query(self, query: str) -> Dict[str, Any]:
-        """Process query with performance optimization"""
-        start_time = time.time()
+        This evaluation runner uses a **Hybrid LangGraph + Agno Agent System** that combines the best of both frameworks:
         
-        initial_state = {
-            "messages": [HumanMessage(content=query)],
-            "query": query,
-            "agent_type": "",
-            "final_answer": "",
-            "performance_metrics": {},
-            "agno_response": ""
-        }
+        ### 🧠 **Intelligent Routing System**
+        - **🔢 Mathematical Queries** → LangGraph (Groq Llama 3.3 70B) - *Optimized for speed*
+        - **🔍 Complex Research** → Agno (Gemini 2.0 Flash-Lite) - *Optimized for reasoning*
+        - **📚 Factual Retrieval** → LangGraph + FAISS Vector Store - *Optimized for accuracy*
+        - **🎭 General Queries** → Agno Multi-Agent System - *Optimized for comprehensiveness*
         
-        config = {"configurable": {"thread_id": f"hybrid_{hash(query)}"}}
+        ### ⚡ **Performance Features**
+        - **Rate Limiting**: Intelligent rate management for free tier models
+        - **Caching**: Performance optimization with query caching
+        - **Fallback Systems**: Automatic provider switching on failures
+        - **Performance Tracking**: Real-time metrics and provider usage stats
         
-        try:
-            result = self.graph.invoke(initial_state, config)
-            total_time = time.time() - start_time
-            
-            return {
-                "answer": result.get("final_answer", "No response generated"),
-                "performance_metrics": {
-                    **result.get("performance_metrics", {}),
-                    "total_time": total_time
-                },
-                "provider_used": result.get("performance_metrics", {}).get("provider", "Unknown")
-            }
-        except Exception as e:
-            return {
-                "answer": f"Error: {str(e)}",
-                "performance_metrics": {"total_time": time.time() - start_time, "error": True},
-                "provider_used": "Error"
-            }
+        ### 🛠 **Tools & Capabilities**
+        - Mathematical calculations (add, subtract, multiply, divide, modulus)
+        - Web search (Tavily, Wikipedia, ArXiv)
+        - FAISS vector database for similar question retrieval
+        - Memory persistence across sessions
+        
+        ---
+        
+        **Instructions:**
+        1. 🔐 Log in to your Hugging Face account using the button below
+        2. 🚀 Click 'Run Evaluation & Submit All Answers' to start the evaluation
+        3. 📊 Monitor real-time performance metrics and provider usage
+        4. 🏆 View your final score and detailed results
+        
+        **Note:** The hybrid system automatically selects the optimal AI provider for each question type to maximize both speed and accuracy.
+        """
+    )
 
-# Build graph function for compatibility
-def build_graph(provider: str = "hybrid"):
-    """Build the hybrid graph system"""
-    if provider == "hybrid":
-        system = HybridLangGraphAgnoSystem()
-        return system.graph
-    else:
-        # Fallback to original implementation
-        return build_original_graph(provider)
+    gr.LoginButton()
+
+    with gr.Row():
+        run_button = gr.Button(
+            "🚀 Run Evaluation & Submit All Answers", 
+            variant="primary", 
+            size="lg"
+        )
+
+    status_output = gr.Textbox(
+        label="📊 Run Status / Submission Result", 
+        lines=10, 
+        interactive=False,
+        placeholder="Status updates will appear here..."
+    )
+    
+    results_table = gr.DataFrame(
+        label="📋 Questions, Answers & Performance Metrics", 
+        wrap=True,
+        height=400
+    )
+
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
 
-def build_original_graph(provider: str):
-    """Original graph implementation for fallback"""
-    # Implementation of original graph...
-    pass
+    # Add footer with system info
+    gr.Markdown(
+        """
+        ---
+        ### 🔧 **System Information**
+        - **Primary Models**: Groq Llama 3.3 70B, Gemini 2.0 Flash-Lite, NVIDIA Llama 3.1 70B
+        - **Frameworks**: LangGraph + Agno Hybrid Architecture
+        - **Vector Store**: FAISS with NVIDIA Embeddings
+        - **Rate Limiting**: Advanced rate management with exponential backoff
+        - **Memory**: Persistent agent memory with session summaries
+        """
+    )
 
-# Main execution
 if __name__ == "__main__":
-    # Test the hybrid system
-    hybrid_system = HybridLangGraphAgnoSystem()
+    print("\n" + "="*80)
+    print("🚀 ENHANCED HYBRID AGENT EVALUATION RUNNER")
+    print("="*80)
     
-    test_queries = [
-        "What is 25 * 4 + 10?",  # Should route to LangGraph math
-        "Explain the economic impacts of AI automation",  # Should route to Agno research
-        "What are the names of US presidents who were assassinated?",  # Should route to LangGraph retrieval
-        "Compare quantum computing with classical computing"  # Should route to Agno general
-    ]
+    # Check for environment variables
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID")
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   🌐 Runtime URL: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup:
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   📁 Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        print(f"   🌳 Repo Tree URL: https://huggingface.co/spaces/{space_id_startup}/tree/main")
+    else:
+        print("ℹ️  SPACE_ID environment variable not found (running locally?).")
+
+    print("\n🎯 System Features:")
+    print("   • Hybrid LangGraph + Agno Architecture")
+    print("   • Intelligent Query Routing")
+    print("   • Performance Optimization")
+    print("   • Advanced Rate Limiting")
+    print("   • FAISS Vector Database")
+    print("   • Multi-Provider Fallbacks")
     
-    for query in test_queries:
-        print(f"\nQuery: {query}")
-        result = hybrid_system.process_query(query)
-        print(f"Answer: {result['answer']}")
-        print(f"Provider: {result['provider_used']}")
-        print(f"Processing Time: {result['performance_metrics'].get('total_time', 0):.2f}s")
-        print("-" * 80)
+    print("\n" + "="*80)
+    print("🎉 Launching Enhanced Gradio Interface...")
+    print("="*80 + "\n")
+
+    demo.launch(debug=True, share=False)