Update app.py

app.py

@@ -2,138 +2,152 @@ import os
 import gradio as gr
 import requests
 import pandas as pd
+from huggingface_hub import InferenceClient
 
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Intelligent Agent with Web Search ---
-class IntelligentAgent:
+# --- Powerful Agent with HuggingFace ---
+class PowerfulAgent:
     def __init__(self):
-        print("Initializing IntelligentAgent...")
-        self.search_tool = self._create_search_function()
+        print("Initializing PowerfulAgent with HuggingFace Inference...")
         
-    def _create_search_function(self):
-        """Create a simple DuckDuckGo search function"""
+        # Get HF token
+        hf_token = os. getenv("HF_TOKEN")
+        if not hf_token:
+            print("⚠️ Warning: No HF_TOKEN found, using public endpoint")
+        
+        # Initialize HF Inference Client
+        self.client = InferenceClient(token=hf_token)
+        
+        # Use a powerful free model
+        self.model = "Qwen/Qwen2.5-72B-Instruct"  # Very capable model
+        print(f"Using model: {self.model}")
+        
+        # Initialize search
         try:
             from duckduckgo_search import DDGS
-            return DDGS()
-        except: 
-            return None
+            self.search = DDGS()
+            print("✅ Search tool initialized")
+        except Exception as e:
+            self.search = None
+            print(f"⚠️ Search tool unavailable: {e}")
     
-    def search_web(self, query: str, max_results: int = 5) -> str:
-        """Search the web using DuckDuckGo"""
-        if self.search_tool is None:
-            return "Search unavailable"
+    def search_web(self, query: str) -> str:
+        """Search web for information"""
+        if not self.search:
+            return ""
         
-        try:
-            results = list(self.search_tool. text(query, max_results=max_results))
-            if not results:
-                return "No results found"
+        try: 
+            results = list(self. search. text(query, max_results=5))
+            if not results: 
+                return ""
             
-            # Format results
             formatted = []
-            for i, r in enumerate(results[: max_results], 1):
-                formatted.append(f"{i}. {r. get('title', 'N/A')}: {r.get('body', 'N/A')}")
+            for r in results[:5]:
+                title = r.get('title', '')
+                body = r.get('body', '')
+                if title and body:
+                    formatted.append(f"• {title}:  {body}")
             
-            return "\n\n".join(formatted)
+            return "\n". join(formatted)
         except Exception as e:
             print(f"Search error: {e}")
-            return "Search failed"
-
-    def __call__(self, question:  str) -> str:
-        print(f"Processing question: {question[:100]}...")
-        
-        # For questions that likely need web search
-        if any(keyword in question.lower() for keyword in ['current', 'latest', 'recent', 'today', 'now', '2024', '2025', '2026']):
-            print("Searching web for current information...")
-            search_results = self.search_web(question, max_results=3)
-            
-            # Try to extract relevant answer from search results
-            if search_results and search_results != "No results found":
-                # Return first meaningful snippet
-                lines = search_results.split('\n')
-                for line in lines:
-                    if len(line) > 20:
-                        return line[:500]
-        
-        # Basic knowledge-based responses
-        question_lower = question.lower()
+            return ""
+    
+    def __call__(self, question: str) -> str:
+        print(f"\n{'='*60}")
+        print(f"Question:  {question[: 200]}")
+        print(f"{'='*60}")
         
-        # Geography
-        if "capital" in question_lower: 
-            capitals = {
-                "france": "Paris", "germany": "Berlin", "italy": "Rome",
-                "spain": "Madrid", "japan": "Tokyo", "china": "Beijing",
-                "india": "New Delhi", "brazil": "Brasília", "canada": "Ottawa",
-                "australia": "Canberra", "russia": "Moscow", "uk": "London",
-                "united kingdom": "London", "usa": "Washington, D.C.",
-                "united states": "Washington, D.C.", "mexico": "Mexico City"
-            }
-            for country, capital in capitals.items():
-                if country in question_lower:
-                    return capital
+        # Search for context
+        search_context = ""
+        if self.search:
+            print("🔍 Searching web...")
+            search_context = self.search_web(question)
+            if search_context:
+                print(f"✅ Found search results ({len(search_context)} chars)")
         
-        # Companies and CEOs
-        if "ceo" in question_lower or "chief executive" in question_lower:
-            ceos = {
-                "tesla": "Elon Musk", "spacex": "Elon Musk", "apple": "Tim Cook",
-                "microsoft": "Satya Nadella", "google": "Sundar Pichai",
-                "amazon": "Andy Jassy", "meta": "Mark Zuckerberg",
-                "facebook": "Mark Zuckerberg", "nvidia": "Jensen Huang"
-            }
-            for company, ceo in ceos.items():
-                if company in question_lower:
-                    return ceo
+        # Build comprehensive prompt
+        system_prompt = """You are an expert AI assistant that provides accurate, concise answers. 
+
+INSTRUCTIONS:
+1. Read the question carefully
+2. Use web search results if provided
+3. Think step-by-step for complex problems
+4. Give ONLY the final answer - be direct and concise
+5. For numbers:  provide just the number (e.g., "42" not "The answer is 42")
+6. For names: provide just the name (e.g., "Paris" not "The capital is Paris")
+7. For yes/no:  provide just "Yes" or "No"
+8. Show calculations if needed, but end with clear final answer
+
+Be precise, factual, and concise."""
+
+        user_prompt = f"Question: {question}"
         
-        # Historical dates
-        if "when" in question_lower or "what year" in question_lower:
-            events = {
-                "world war 2": "1939-1945", "world war ii": "1939-1945", "wwii": "1939-1945",
-                "world war 1": "1914-1918", "world war i": "1914-1918", "wwi": "1914-1918",
-                "moon landing": "1969", "first moon landing": "1969",
-                "declared independence": "1776", "independence america": "1776"
-            }
-            for event, date in events.items():
-                if event in question_lower: 
-                    return date
+        if search_context: 
+            user_prompt += f"\n\nWeb Search Results:\n{search_context[: 2500]}"
         
-        # Counting questions
-        if "how many" in question_lower: 
-            counts = {
-                "planets": "8", "continents": "7", "oceans": "5",
-                "days in a week": "7", "months": "12", "states in usa": "50",
-                "states in us": "50"
-            }
-            for thing, count in counts.items():
-                if thing in question_lower: 
-                    return count
+        user_prompt += "\n\nAnswer (be direct and concise):"
         
-        # Math questions
-        if any(op in question for op in ['+', '-', '*', '/', '×', '÷']):
+        # Call HF Inference
+        try: 
+            print("🤖 Calling HuggingFace Inference API...")
+            
+            messages = [
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": user_prompt}
+            ]
+            
+            # Use chat completion
+            response = self.client.chat_completion(
+                model=self. model,
+                messages=messages,
+                max_tokens=1000,
+                temperature=0.1  # Low for factual accuracy
+            )
+            
+            answer = response.choices[0].message.content.strip()
+            
+            # Clean up common verbose patterns
+            if answer.lower().startswith("according to"):
+                # Remove "According to the search results, " etc
+                parts = answer.split(",", 1)
+                if len(parts) > 1:
+                    answer = parts[1].strip()
+            
+            if answer.lower().startswith("the answer is"):
+                answer = answer[13:].strip()
+            
+            if answer.lower().startswith("answer:"):
+                answer = answer[7:].strip()
+            
+            print(f"✅ Answer:  {answer[: 200]}")
+            return answer
+            
+        except Exception as e:
+            print(f"❌ Error with HF Inference: {e}")
+            
+            # Fallback:  try text generation API
             try:
-                # Simple eval for basic math (be careful with this in production!)
-                result = eval(question. replace('×', '*').replace('÷', '/'))
-                return str(result)
-            except:
-                pass
-        
-        # Try web search as fallback
-        print("Using web search as fallback...")
-        search_results = self.search_web(question, max_results=3)
-        if search_results and "No results found" not in search_results:
-            # Extract first meaningful content
-            lines = search_results.split('\n')
-            for line in lines:
-                if len(line. strip()) > 30:
-                    # Return cleaned up snippet
-                    return line. strip()[:500]
-        
-        # Final fallback
-        return "I don't have enough information to answer this question accurately."
+                print("Trying text generation fallback...")
+                full_prompt = f"{system_prompt}\n\n{user_prompt}"
+                
+                response = self.client.text_generation(
+                    full_prompt,
+                    model=self.model,
+                    max_new_tokens=500,
+                    temperature=0.1
+                )
+                
+                return response.strip()
+            except Exception as e2:
+                print(f"❌ Fallback also failed: {e2}")
+                return "Unable to process this question at this time."
 
 def run_and_submit_all(profile: gr.OAuthProfile | None):
     """
-    Fetches all questions, runs the IntelligentAgent on them, submits all answers, and displays the results.
+    Fetches all questions, runs the PowerfulAgent on them, submits all answers, and displays the results. 
     """
     space_id = os.getenv("SPACE_ID")
     
@@ -141,50 +155,54 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
         print("User not logged in.")
         return "❌ Please login to Hugging Face using the button above.", None
     
-    username = profile.username
+    username = profile. username
+    print(f"\n{'#'*60}")
     print(f"User logged in:  {username}")
+    print(f"{'#'*60}\n")
 
     api_url = DEFAULT_API_URL
     questions_url = f"{api_url}/questions"
     submit_url = f"{api_url}/submit"
 
     # 1. Instantiate Agent
-    print("Creating agent instance...")
+    print("🚀 Creating agent instance...")
     try:
-        agent = IntelligentAgent()
+        agent = PowerfulAgent()
     except Exception as e:
-        print(f"Error instantiating agent: {e}")
-        return f"Error initializing agent: {e}", None
+        print(f"❌ Error instantiating agent:  {e}")
+        return f"Error initializing agent:  {e}", None
 
     agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(f"Agent code: {agent_code}")
+    print(f"📝 Agent code:  {agent_code}\n")
 
     # 2. Fetch Questions
-    print(f"Fetching questions from:  {questions_url}")
+    print(f"📥 Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=30)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
             return "Fetched questions list is empty.", None
-        print(f"✅ Fetched {len(questions_data)} questions.")
+        print(f"✅ Fetched {len(questions_data)} questions.\n")
     except Exception as e:
-        print(f"Error fetching questions: {e}")
+        print(f"❌ Error fetching questions: {e}")
         return f"Error fetching questions: {e}", None
 
     # 3. Run Agent
     results_log = []
     answers_payload = []
-    print(f"\n🤖 Running agent on {len(questions_data)} questions...")
+    print(f"🤖 Running agent on {len(questions_data)} questions...")
+    print(f"⏳ This will take 3-5 minutes...\n")
     
     for idx, item in enumerate(questions_data, 1):
         task_id = item.get("task_id")
-        question_text = item.get("question")
+        question_text = item. get("question")
         
         if not task_id or question_text is None:
             continue
 
-        print(f"\n[{idx}/{len(questions_data)}] Task: {task_id}")
+        print(f"\n{'─'*60}")
+        print(f"[{idx}/{len(questions_data)}] Task: {task_id}")
         
         try:
             answer = agent(question_text)
@@ -192,80 +210,117 @@ def run_and_submit_all(profile: gr.OAuthProfile | None):
                 "task_id": task_id,
                 "submitted_answer": answer
             })
-            results_log.append((task_id, question_text[:50], answer[:100]))
-            print(f"✅ Answer:  {answer[:100]}")
-        except Exception as e: 
-            print(f"❌ Error:  {e}")
+            results_log.append((task_id, question_text[:50], answer[: 100]))
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            error_msg = "Unable to process this question."
             answers_payload.append({
                 "task_id": task_id,
-                "submitted_answer": "Error processing question"
+                "submitted_answer": error_msg
             })
+            results_log.append((task_id, question_text[:50], f"Error: {e}"))
+
+    print(f"\n{'='*60}")
+    print(f"✅ Completed processing all {len(answers_payload)} questions!")
+    print(f"{'='*60}\n")
 
     # 4. Submit answers
-    print(f"\n📤 Submitting {len(answers_payload)} answers...")
+    print(f"📤 Submitting answers to scoring server...")
     try:
         payload = {
             "username": username,
             "answers": answers_payload,
-            "agent_code":  agent_code
+            "agent_code": agent_code
         }
         
-        submit_response = requests. post(submit_url, json=payload, timeout=60)
+        submit_response = requests.post(submit_url, json=payload, timeout=60)
         submit_response.raise_for_status()
         submission_result = submit_response.json()
-        print(f"✅ Submission successful:  {submission_result}")
+        print(f"✅ Submission successful!")
+        print(f"📊 Result: {submission_result}\n")
     except Exception as e:
-        print(f"❌ Error submitting:  {e}")
+        print(f"❌ Error submitting: {e}")
         return f"Error submitting answers: {e}", None
 
     # Display results
     results_df = pd.DataFrame(results_log, columns=["task_id", "question", "answer"])
     score = submission_result.get('score', 'N/A')
     
+    # Determine pass/fail
+    passed = isinstance(score, (int, float)) and score >= 30
+    
     result_message = f"""
-## 🎉 Submission Successful!
+## {'🎉 CONGRATULATIONS!  YOU PASSED!' if passed else '📊 Submission Complete'}
+
+### 🏆 Your Score: **{score}%**
+
+{'### ✅ YOU PASSED UNIT 4!' if passed else '### ⚠️ Score below 30% threshold'}
 
-### 📊 Your Results: 
-- **Score:** {score}
-- **Username:** {username}
-- **Questions Answered:** {len(answers_payload)}
+**Submission Details:**
+- 👤 Username: `{username}`
+- 📝 Questions Answered: {len(answers_payload)}
+- 🎯 Pass Threshold: 30%
+- 📊 Your Score: {score}%
 
-### 🏆 Score Breakdown:
-- ✅ **Pass Threshold:** 30%
-- 📈 **Your Score:** {score}
+{f"### 🎓 Congratulations! You have successfully completed Unit 4 of the Hugging Face Agents Course!" if passed else "### 💡 Tips to improve:  The agent uses Qwen 2.5 72B and web search.  Try running again as results may vary. "}
 
-{f"🎓 **Congratulations!  You passed Unit 4! **" if isinstance(score, (int, float)) and score >= 30 else "📚 Keep improving to reach 30%! "}
+### 🔗 Resources:
+- [View Your Agent Code]({agent_code})
+- [Unit 4 Course Material](https://huggingface.co/learn/agents-course/en/unit4/hands-on)
 
-### 🔗 Links:
-- [View Your Code]({agent_code})
-- [Course Unit 4](https://huggingface.co/learn/agents-course/en/unit4/hands-on)
+---
+*Agent:  Qwen 2.5 72B-Instruct + DuckDuckGo Search*
     """
     
     return result_message, results_df
 
 # --- Gradio UI ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr. Markdown("""
-    # 🤖 Intelligent Agent - Unit 4 Final Assignment
+    gr.Markdown("""
+    # 🤖 AI Agent - Unit 4 Final Assignment
     
-    This agent uses: 
-    - 🔍 **DuckDuckGo Search** for web information
-    - 🧠 **Knowledge Base** for common questions
-    - 🎯 **Smart fallbacks** for better coverage
+    ## 🚀 Agent Capabilities:
+    - 🧠 **Qwen 2.5 72B-Instruct** - One of the most capable open models
+    - 🔍 **DuckDuckGo Web Search** - Real-time information retrieval
+    - 🎯 **Advanced Reasoning** - Step-by-step problem solving
+    - 📊 **Optimized Prompts** - Engineered for GAIA benchmark
     
-    ## 📋 Instructions:
-    1. ✅ Sign in with Hugging Face
-    2. 🚀 Click "Run Evaluation & Submit"
-    3. ⏳ Wait for your score
+    ## 📋 How to Use:
+    1. ✅ Click "Sign in with Hugging Face" below (must be logged in)
+    2. 🚀 Click "Run Evaluation & Submit All Answers"
+    3. ⏳ Wait 3-5 minutes for all questions to be processed
+    4. 🎉 See your score! 
     
-    **Target:** 30% or higher to pass! 
+    ## 🎯 Goal:
+    **Get 30% or higher to pass Unit 4! **
+    
+    The agent will process each question using web search and advanced reasoning. 
     """)
     
-    gr.LoginButton()
-    submit_button = gr.Button("🚀 Run Evaluation & Submit All Answers", variant="primary", size="lg")
-    output_text = gr.Markdown()
-    output_table = gr. Dataframe(label="📝 Results", wrap=True)
+    with gr.Row():
+        gr.LoginButton()
+    
+    with gr.Row():
+        submit_button = gr.Button(
+            "🚀 Run Evaluation & Submit All Answers", 
+            variant="primary", 
+            size="lg"
+        )
+    
+    with gr.Row():
+        output_text = gr.Markdown()
+    
+    with gr.Row():
+        output_table = gr. Dataframe(
+            label="📝 Detailed Results", 
+            wrap=True,
+            interactive=False
+        )
 
-    submit_button.click(run_and_submit_all, inputs=None, outputs=[output_text, output_table])
+    submit_button.click(
+        run_and_submit_all, 
+        inputs=None, 
+        outputs=[output_text, output_table]
+    )
 
 demo.launch()