Update app.py

app.py

@@ -1,4 +1,4 @@
-""" Enhanced Multi-LLM Agent Evaluation Runner - CORRECTED VERSION"""
+""" Enhanced LangGraph Agent Evaluation Runner - Final Version"""
 import os
 import gradio as gr
 import requests
@@ -10,76 +10,54 @@ from veryfinal import build_graph
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
 # --- Enhanced Agent Definition ---
-class EnhancedMultiLLMAgent:
-    """A multi-provider LangGraph agent with proper response handling."""
+class EnhancedLangGraphAgent:
+    """Enhanced LangGraph agent with proper response handling."""
     def __init__(self):
-        print("Enhanced Multi-LLM Agent initialized.")
+        print("Enhanced LangGraph Agent initialized.")
         try:
             self.graph = build_graph(provider="groq")
-            print("Multi-LLM Graph built successfully.")
+            print("LangGraph built successfully.")
         except Exception as e:
             print(f"Error building graph: {e}")
             self.graph = None
 
     def __call__(self, question: str) -> str:
-        print(f"Agent received question: {question[:100]}...")
+        print(f"Processing: {question[:100]}...")
         
         if self.graph is None:
             return "Error: Agent not properly initialized"
         
-        # Create complete state structure
-        state = {
-            "messages": [HumanMessage(content=question)],
-            "query": question,  # Critical: this must match the question
-            "agent_type": "",
-            "final_answer": "",
-            "perf": {},
-            "agno_resp": ""
-        }
-        # Always provide the required config with thread_id
-        config = {"configurable": {"thread_id": f"eval_{hash(question)}"}}
-        
         try:
-            result = self.graph.invoke(state, config)
+            # Create messages and config
+            messages = [HumanMessage(content=question)]
+            config = {"configurable": {"thread_id": f"eval_{hash(question)}"}}
+            
+            # Invoke the graph
+            result = self.graph.invoke({"messages": messages}, config)
             
-            # CORRECTED: Proper response extraction
-            if isinstance(result, dict):
-                # First try to get final_answer from the state
-                if 'final_answer' in result and result['final_answer']:
-                    answer = result['final_answer']
-                # Fallback to messages if final_answer is empty
-                elif 'messages' in result and result['messages']:
-                    last_message = result['messages'][-1]
-                    if hasattr(last_message, 'content'):
-                        answer = last_message.content
-                    else:
-                        answer = str(last_message)
+            # Extract the final answer
+            if result and "messages" in result and result["messages"]:
+                final_message = result["messages"][-1]
+                if hasattr(final_message, 'content'):
+                    answer = final_message.content
                 else:
-                    answer = str(result)
+                    answer = str(final_message)
+                
+                # Clean up the answer
+                if "FINAL ANSWER:" in answer:
+                    answer = answer.split("FINAL ANSWER:")[-1].strip()
+                
+                # Validate the answer
+                if not answer or answer == question or len(answer.strip()) == 0:
+                    return "Information not available"
+                
+                return answer.strip()
             else:
-                answer = str(result)
-            
-            # Clean the answer
-            answer = answer.strip()
-            
-            # CRITICAL FIX: Ensure we don't return the question as answer
-            if answer == question or answer.startswith(question):
                 return "Information not available"
-            
-            # Extract final answer if present
-            if "FINAL ANSWER:" in answer:
-                answer = answer.split("FINAL ANSWER:")[-1].strip()
-            
-            # Additional validation
-            if not answer or len(answer.strip()) == 0:
-                return "No answer generated"
-                
-            return answer
                 
         except Exception as e:
-            error_msg = f"Error: {str(e)}"
-            print(error_msg)
-            return error_msg
+            print(f"Error processing question: {e}")
+            return f"Error: {str(e)}"
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """Fetch questions, run agent, and submit answers."""
@@ -98,7 +76,7 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent
     try:
-        agent = EnhancedMultiLLMAgent()
+        agent = EnhancedLangGraphAgent()
         if agent.graph is None:
             return "Error: Failed to initialize agent properly", None
     except Exception as e:
@@ -106,7 +84,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         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}")
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
@@ -115,35 +92,27 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         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.")
     except Exception as e:
-        print(f"Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
 
-    # 3. Run your Agent
+    # 3. Run Agent
     results_log = []
     answers_payload = []
-    print(f"Running Enhanced Multi-LLM agent on {len(questions_data)} questions...")
+    print(f"Running Enhanced LangGraph 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}")
         
         try:
             submitted_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"
-            
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
             results_log.append({
                 "Task ID": task_id, 
@@ -152,7 +121,6 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             })
         except Exception as e:
             error_msg = f"AGENT ERROR: {e}"
-            print(f"Error running agent on task {task_id}: {e}")
             answers_payload.append({"task_id": task_id, "submitted_answer": error_msg})
             results_log.append({
                 "Task ID": task_id, 
@@ -161,16 +129,12 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             })
 
     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. Prepare Submission 
+    # 4. Submit
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Enhanced 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}")
+    print(f"Submitting {len(answers_payload)} answers...")
+    
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
         response.raise_for_status()
@@ -182,30 +146,30 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        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 - CORRECTED VERSION")
+    gr.Markdown("# Enhanced LangGraph Agent - Final Version")
     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.
+        **Features:**
+        - ✅ Proper LangGraph structure with tool integration
+        - ✅ Multi-LLM support (Groq, Google, HuggingFace)
+        - ✅ Enhanced search capabilities (Wikipedia, Tavily, ArXiv)
+        - ✅ Mathematical tools for calculations
+        - ✅ Vector store integration for similar questions
+        - ✅ Proper response formatting and validation
+        - ✅ Error handling and fallback mechanisms
         
-        **FIXES APPLIED:**
-        - ✅ Proper response extraction from graph state
-        - ✅ Prevention of question repetition as answer
-        - ✅ Enhanced prompt engineering for better responses
-        - ✅ Improved error handling and validation
-        - ✅ Search-enhanced processing for information retrieval
+        **Tools Available:**
+        - Mathematical operations (add, subtract, multiply, divide, modulus)
+        - Wikipedia search for encyclopedic information
+        - Web search via Tavily for current information
+        - ArXiv search for academic papers
+        - Vector similarity search for related questions
         """
     )
 
@@ -220,5 +184,5 @@ with gr.Blocks() as demo:
     )
 
 if __name__ == "__main__":
-    print("\n" + "-"*30 + " Enhanced Multi-LLM Agent CORRECTED Starting " + "-"*30)
+    print("\n" + "-"*30 + " Enhanced LangGraph Agent Starting " + "-"*30)
     demo.launch(debug=True, share=False)