Update app.py

app.py

@@ -1,87 +1,48 @@
-""" Enhanced Multi-LLM Agent Evaluation Runner with Agno Integration"""
+""" Working Multi-LLM Agent Evaluation Runner"""
 import os
 import gradio as gr
 import requests
 import pandas as pd
 from langchain_core.messages import HumanMessage
 
-# Import the enhanced classes from veryfinal.py in the same directory
-try:
-    from veryfinal import (
-        build_graph, 
-        UnifiedAgnoEnhancedSystem,
-        AgnoEnhancedAgentSystem,
-        AgnoEnhancedModelManager
-    )
-    VERYFINAL_AVAILABLE = True
-except ImportError as e:
-    print(f"Error importing from veryfinal.py: {e}")
-    VERYFINAL_AVAILABLE = False
+# Import from veryfinal.py
+from veryfinal import UnifiedAgnoEnhancedSystem
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Enhanced Agent Definition ---
-class EnhancedMultiLLMAgent:
-    """A multi-provider Agno agent with NVIDIA + open-source model integration."""
+# --- Working Agent Definition ---
+class WorkingMultiLLMAgent:
+    """A working multi-LLM agent that actually answers questions"""
     def __init__(self):
-        print("Enhanced Multi-LLM Agent with Agno Integration initialized.")
-        
-        if not VERYFINAL_AVAILABLE:
-            print("Error: veryfinal.py not properly imported")
-            self.system = None
-            self.graph = None
-            return
-        
+        print("Working Multi-LLM Agent initialized.")
         try:
-            # Use the unified Agno enhanced system
             self.system = UnifiedAgnoEnhancedSystem()
-            self.graph = self.system.graph
-            
-            # Display system information
-            if self.system.agno_system:
-                info = self.system.get_system_info()
-                print(f"System initialized with {info.get('total_models', 0)} models")
-                if info.get('nvidia_available'):
-                    print("✅ NVIDIA NIM models available")
-                print(f"Active agents: {info.get('active_agents', [])}")
-            
-            print("Enhanced Agno Multi-LLM System built successfully.")
+            print("✅ Working system built successfully.")
         except Exception as e:
-            print(f"Error building enhanced system: {e}")
-            self.graph = None
+            print(f"❌ Error building system: {e}")
             self.system = None
 
     def __call__(self, question: str) -> str:
-        print(f"Agent received question: {question[:100]}...")
+        print(f"Processing: {question[:100]}...")
         
         if self.system is None:
-            return "Error: Agent not properly initialized"
+            return "Error: System not initialized"
         
         try:
-            # Use the enhanced system's process_query method
             answer = self.system.process_query(question)
             
-            # Additional validation
+            # Validation
             if not answer or answer == question or len(answer.strip()) == 0:
                 return "Information not available"
             
-            # Clean up the answer
-            answer = answer.strip()
-            
-            # Ensure proper formatting for evaluation
-            if "FINAL ANSWER:" in answer:
-                answer = answer.split("FINAL ANSWER:")[-1].strip()
-            
-            return answer
+            return answer.strip()
                 
         except Exception as e:
-            error_msg = f"Error: {str(e)}"
-            print(error_msg)
-            return error_msg
+            return f"Error: {str(e)}"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
-    """Fetch questions, run enhanced Agno agent, and submit answers."""
+    """Run evaluation with working agent"""
     space_id = os.getenv("SPACE_ID")
     
     if profile:
@@ -95,146 +56,115 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
-    # 1. Instantiate Enhanced Agent
+    # 1. Instantiate Working Agent
     try:
-        agent = EnhancedMultiLLMAgent()
+        agent = WorkingMultiLLMAgent()
         if agent.system is None:
-            return "Error: Failed to initialize enhanced agent properly", None
+            return "Error: Failed to initialize working agent", None
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
     
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "No space ID available"
-    print(f"Agent code URL: {agent_code}")
+    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "No space ID"
 
     # 2. Fetch Questions
-    print(f"Fetching questions from: {questions_url}")
     try:
         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.")
+            return "No questions fetched", None
+        print(f"✅ Fetched {len(questions_data)} questions")
     except Exception as e:
-        print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
 
-    # 3. Run Enhanced Agno Agent
+    # 3. Process Questions
     results_log = []
     answers_payload = []
-    print(f"Running Enhanced Agno Multi-LLM agent on {len(questions_data)} questions...")
     
     for i, item in enumerate(questions_data):
         task_id = item.get("task_id")
         question_text = item.get("question")
         
         if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
             continue
             
-        print(f"Processing question {i+1}/{len(questions_data)}: {task_id}")
+        print(f"Processing {i+1}/{len(questions_data)}: {task_id}")
         
         try:
-            submitted_answer = agent(question_text)
+            answer = agent(question_text)
             
-            # Additional validation to prevent question repetition
-            if submitted_answer == question_text or submitted_answer.startswith(question_text):
-                submitted_answer = "Information not available"
+            # Prevent question repetition
+            if answer == question_text or answer.startswith(question_text):
+                answer = "Information not available"
             
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
+            answers_payload.append({"task_id": task_id, "submitted_answer": answer})
             results_log.append({
-                "Task ID": task_id, 
-                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text, 
-                "Submitted Answer": submitted_answer[:200] + "..." if len(submitted_answer) > 200 else submitted_answer
+                "Task ID": task_id,
+                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
+                "Submitted Answer": answer[:200] + "..." if len(answer) > 200 else answer
             })
         except Exception as e:
-            error_msg = f"AGENT ERROR: {e}"
-            print(f"Error running agent on task {task_id}: {e}")
+            error_msg = f"ERROR: {e}"
             answers_payload.append({"task_id": task_id, "submitted_answer": error_msg})
             results_log.append({
-                "Task ID": task_id, 
-                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text, 
+                "Task ID": task_id,
+                "Question": question_text[:100] + "..." if len(question_text) > 100 else question_text,
                 "Submitted Answer": error_msg
             })
 
     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)
+        return "No answers generated", pd.DataFrame(results_log)
 
-    # 4. Prepare Submission 
+    # 4. Submit Results
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Enhanced Agno Multi-LLM Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
-    print(status_update)
-
-    # 5. Submit
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
         result_data = response.json()
+        
         final_status = (
-            f"Submission Successful!\n"
+            f"✅ Submission Successful!\n"
             f"User: {result_data.get('username')}\n"
-            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            f"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.')}"
+            f"Message: {result_data.get('message', 'Success')}"
         )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
+        
+        return final_status, pd.DataFrame(results_log)
     except Exception as e:
-        status_message = f"Submission Failed: {e}"
-        print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return f"❌ Submission Failed: {e}", pd.DataFrame(results_log)
 
-# --- Build Gradio Interface ---
+# --- Gradio Interface ---
 with gr.Blocks() as demo:
-    gr.Markdown("# Enhanced Multi-LLM Agent with Agno + NVIDIA Integration")
+    gr.Markdown("# Working Multi-LLM Agent System")
     gr.Markdown(
         """
-        **Instructions:**
-        1. Log in to your Hugging Face account using the button below.
-        2. Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-        
-        **Enhanced Agent Features:**
-        - **NVIDIA NIM Models**: Enterprise-grade optimized models for maximum accuracy
-        - **Open-Source Models**: Groq, Ollama, Together AI, Anyscale, Hugging Face
-        - **Specialized Agents**: Enterprise research, advanced math, coding, fast response
-        - **Intelligent Routing**: Automatically selects best model/agent for each task
-        - **Advanced Tools**: DuckDuckGo search, Wikipedia, calculator, reasoning tools
-        - **Agno Framework**: Professional agent framework with memory and tool integration
+        **✅ This is a WORKING system that will actually answer questions!**
         
-        **Available Model Providers:**
-        - **NVIDIA NIM**: meta/llama3-70b-instruct, meta/codellama-70b-instruct, etc.
-        - **Groq (Free)**: llama3-70b-8192, llama3-8b-8192, mixtral-8x7b-32768
-        - **Ollama (Local)**: llama3, mistral, phi3, codellama, gemma, qwen
-        - **Together AI**: Meta-Llama models, Mistral, Qwen
-        - **Anyscale**: Enterprise hosting for open-source models
-        - **Hugging Face**: Direct model access
+        **Features:**
+        - **Groq Llama-3 70B**: High-quality responses
+        - **Smart Routing**: Math, search, wiki, and general queries
+        - **Web Search**: Tavily integration for current information
+        - **Wikipedia**: Encyclopedic knowledge access
+        - **Robust Error Handling**: Fallbacks and validation
         
-        **Routing Examples:**
-        - Enterprise: "Enterprise analysis of quantum computing" → NVIDIA NIM
-        - Math: "Calculate 25 × 17" → Advanced Math Agent
-        - Code: "Write Python factorial function" → Advanced Coding Agent
-        - Research: "Find Mercedes Sosa discography" → Enterprise Research Agent
-        - Quick: "Capital of France?" → Fast Response Agent
+        **Instructions:**
+        1. Log in with your Hugging Face account
+        2. Click 'Run Evaluation & Submit All Answers'
+        3. Wait for processing to complete
+        4. View your results and score
         
-        **Setup Requirements:**
-        - NVIDIA_API_KEY for enterprise models (optional)
-        - GROQ_API_KEY for free tier models
-        - Other API keys optional for additional providers
+        **Requirements:**
+        - GROQ_API_KEY in your environment variables
+        - TAVILY_API_KEY (optional, for web search)
         """
     )
 
     gr.LoginButton()
-
-    run_button = gr.Button("Run Evaluation & Submit All Answers", variant="primary")
-
-    status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
+    run_button = gr.Button("🚀 Run Evaluation & Submit All Answers", variant="primary")
+    status_output = gr.Textbox(label="Status", lines=5, interactive=False)
+    results_table = gr.DataFrame(label="Results", wrap=True)
 
     run_button.click(
         fn=run_and_submit_all,
@@ -242,20 +172,5 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " Enhanced Agno Multi-LLM Agent Starting " + "-"*30)
-    
-    # Display system status
-    if VERYFINAL_AVAILABLE:
-        try:
-            test_system = UnifiedAgnoEnhancedSystem()
-            info = test_system.get_system_info()
-            print(f"✅ System ready with {info.get('total_models', 0)} models")
-            print(f"📊 Model breakdown: {len(info.get('model_breakdown', {}).get('nvidia_models', []))} NVIDIA, "
-                  f"{len(info.get('model_breakdown', {}).get('groq_models', []))} Groq, "
-                  f"{len(info.get('model_breakdown', {}).get('ollama_models', []))} Ollama")
-        except Exception as e:
-            print(f"⚠️  System initialization warning: {e}")
-    else:
-        print("❌ veryfinal.py not properly imported")
-    
+    print("🚀 Starting Working Multi-LLM Agent System")
     demo.launch(debug=True, share=False)