Update app.py

app.py

@@ -18,15 +18,153 @@ cached_answers = {}
 cached_questions = []
 processing_status = {"is_processing": False, "progress": 0, "total": 0}
 
-# --- Basic Agent Definition ---
-class BasicAgent:
-    def __init__(self, debug: bool = False):
+# --- Intelligent Agent with Conditional Search ---
+class IntelligentAgent:
+    def __init__(self, debug: bool = False, model_name: str = "meta-llama/Llama-3.1-8B-Instruct"):
         self.search = DuckDuckGoSearchTool()
+        self.client = InferenceClient(model=model_name)
         self.debug = debug
         if self.debug:
-            print("BasicAgent initialized.")
+            print(f"IntelligentAgent initialized with model: {model_name}")
+
+    def _should_search(self, question: str) -> bool:
+        """
+        Use LLM to determine if search is needed for the question.
+        Returns True if search is recommended, False otherwise.
+        """
+        decision_prompt = f"""You are an AI assistant that decides whether a web search is needed to answer questions accurately.
+
+Analyze this question and decide if it requires real-time information, recent data, or specific facts that might not be in your training data.
+
+SEARCH IS NEEDED for:
+- Current events, news, recent developments
+- Real-time data (weather, stock prices, sports scores)
+- Specific factual information that changes frequently
+- Recent product releases, company information
+- Current status of people, organizations, or projects
+- Location-specific current information
+
+SEARCH IS NOT NEEDED for:
+- General knowledge questions
+- Mathematical calculations
+- Programming concepts and syntax
+- Historical facts (older than 1 year)
+- Definitions of well-established concepts
+- How-to instructions for common tasks
+- Creative writing or opinion-based responses
+
+Question: "{question}"
+
+Respond with only "SEARCH" or "NO_SEARCH" followed by a brief reason (max 20 words).
+
+Example responses:
+- "SEARCH - Current weather data needed"
+- "NO_SEARCH - Mathematical concept, general knowledge sufficient"
+"""
+
+        try:
+            response = self.client.text_generation(
+                decision_prompt,
+                max_new_tokens=50,
+                temperature=0.1,
+                do_sample=False
+            )
+            
+            decision = response.strip().upper()
+            should_search = decision.startswith("SEARCH")
+            
+            if self.debug:
+                print(f"Decision for '{question}': {decision}")
+                
+            return should_search
+            
+        except Exception as e:
+            if self.debug:
+                print(f"Error in search decision: {e}, defaulting to search")
+            # Default to search if decision fails
+            return True
+
+    def _answer_with_llm(self, question: str) -> str:
+        """
+        Generate answer using LLM without search.
+        """
+        answer_prompt = f"""You are a helpful AI assistant. Answer the following question based on your knowledge. Be accurate, concise, and helpful. If you're not certain about something, acknowledge the uncertainty.
+
+Question: {question}
+
+Answer:"""
+
+        try:
+            response = self.client.text_generation(
+                answer_prompt,
+                max_new_tokens=500,
+                temperature=0.3,
+                do_sample=True
+            )
+            return response.strip()
+            
+        except Exception as e:
+            return f"Sorry, I encountered an error generating the response: {e}"
+
+    def _answer_with_search(self, question: str) -> str:
+        """
+        Generate answer using search results and LLM.
+        """
+        try:
+            # Perform search
+            search_results = self.search(question)
+            
+            if not search_results:
+                return "No search results found. Let me try to answer based on my knowledge:\n\n" + self._answer_with_llm(question)
+
+            # Format search results
+            formatted_results = []
+            for i, result in enumerate(search_results[:3]):  # Use top 3 results
+                title = result.get("title", "No title")
+                snippet = result.get("snippet", "").strip()
+                link = result.get("link", "")
+                
+                formatted_results.append(f"Result {i+1}:\nTitle: {title}\nContent: {snippet}\nSource: {link}")
+
+            search_context = "\n\n".join(formatted_results)
+
+            # Generate answer using search context
+            answer_prompt = f"""You are a helpful AI assistant. Use the provided search results to answer the question accurately. Synthesize information from multiple sources when relevant, and cite sources when appropriate.
+
+Question: {question}
+
+Search Results:
+{search_context}
+
+Based on the search results above, provide a comprehensive answer to the question. If the search results don't fully answer the question, you can supplement with your general knowledge but clearly indicate what comes from the search results vs. your knowledge.
+
+Answer:"""
+
+            try:
+                response = self.client.text_generation(
+                    answer_prompt,
+                    max_new_tokens=600,
+                    temperature=0.3,
+                    do_sample=True
+                )
+                return response.strip()
+                
+            except Exception as e:
+                # Fallback to simple search result formatting
+                top_result = search_results[0]
+                title = top_result.get("title", "No title")
+                snippet = top_result.get("snippet", "").strip()
+                link = top_result.get("link", "")
+                
+                return f"**{title}**\n\n{snippet}\n\nSource: {link}"
+
+        except Exception as e:
+            return f"Search failed: {e}. Let me try to answer based on my knowledge:\n\n" + self._answer_with_llm(question)
 
     def __call__(self, question: str) -> str:
+        """
+        Main entry point - decide whether to search and generate appropriate response.
+        """
         if self.debug:
             print(f"Agent received question: {question}")
 
@@ -35,36 +173,21 @@ class BasicAgent:
             return "Please provide a valid question."
 
         try:
-            time.sleep(1)
-            results = self.search(question)
-            
-            # Use truthfulness check and early return
-            if not results:
-                return "No results found for that query."
-
-            # Direct access with get() method chaining
-            top = results[0]
-            title = top.get("title") or "No title"
-            snippet = top.get("snippet", "").strip()
-            link = top.get("link", "")
-
-            # Build answer more efficiently
-            parts = [f"**{title}**"]
-            if snippet:
-                parts.append(snippet)
-            if link:
-                parts.append(f"Source: {link}")
-            
-            answer = "\n".join(parts)
+            # Decide whether to search
+            if self._should_search(question):
+                if self.debug:
+                    print("Using search-based approach")
+                answer = self._answer_with_search(question)
+            else:
+                if self.debug:
+                    print("Using LLM-only approach")
+                answer = self._answer_with_llm(question)
 
-        except (IndexError, KeyError, AttributeError):
-            # More specific exception handling
-            answer = "Sorry, I couldn't process the search results properly."
         except Exception as e:
-            answer = f"Sorry, I couldn't fetch results due to: {e}"
+            answer = f"Sorry, I encountered an error: {e}"
 
         if self.debug:
-            print(f"Agent returning answer: {answer}")
+            print(f"Agent returning answer: {answer[:100]}...")
         
         return answer
 
@@ -106,9 +229,9 @@ def fetch_questions() -> Tuple[str, Optional[pd.DataFrame]]:
     except Exception as e:
         return f"An unexpected error occurred: {e}", None
 
-def generate_answers_async(progress_callback=None):
+def generate_answers_async(model_name: str = "meta-llama/Llama-3.1-8B-Instruct", progress_callback=None):
     """
-    Generate answers for all cached questions asynchronously.
+    Generate answers for all cached questions asynchronously using the intelligent agent.
     """
     global cached_answers, processing_status
     
@@ -120,7 +243,7 @@ def generate_answers_async(progress_callback=None):
     processing_status["total"] = len(cached_questions)
     
     try:
-        agent = BasicAgent()
+        agent = IntelligentAgent(debug=True, model_name=model_name)
         cached_answers = {}
         
         for i, item in enumerate(cached_questions):
@@ -154,7 +277,7 @@ def generate_answers_async(progress_callback=None):
     finally:
         processing_status["is_processing"] = False
 
-def start_answer_generation():
+def start_answer_generation(model_choice: str):
     """
     Start the answer generation process in a separate thread.
     """
@@ -164,211 +287,21 @@ def start_answer_generation():
     if not cached_questions:
         return "No questions available. Please fetch questions first.", None
     
-    # Start generation in background thread
-    thread = threading.Thread(target=generate_answers_async)
-    thread.daemon = True
-    thread.start()
-    
-    return "Answer generation started. Check progress below.", None
-
-def get_generation_progress():
-    """
-    Get the current progress of answer generation.
-    """
-    if not processing_status["is_processing"] and processing_status["progress"] == 0:
-        return "Not started", None
-    
-    if processing_status["is_processing"]:
-        progress = processing_status["progress"]
-        total = processing_status["total"]
-        status_msg = f"Generating answers... {progress}/{total} completed"
-        return status_msg, None
-    else:
-        # Generation completed
-        if cached_answers:
-            # Create DataFrame with results
-            display_data = []
-            for task_id, data in cached_answers.items():
-                display_data.append({
-                    "Task ID": task_id,
-                    "Question": data["question"][:100] + "..." if len(data["question"]) > 100 else data["question"],
-                    "Generated Answer": data["answer"][:200] + "..." if len(data["answer"]) > 200 else data["answer"]
-                })
-            
-            df = pd.DataFrame(display_data)
-            status_msg = f"Answer generation completed! {len(cached_answers)} answers ready for submission."
-            return status_msg, df
-        else:
-            return "Answer generation completed but no answers were generated.", None
-
-def submit_cached_answers(profile: gr.OAuthProfile | None):
-    """
-    Submit the cached answers to the evaluation API.
-    """
-    global cached_answers
-    
-    if not profile:
-        return "Please log in to Hugging Face first.", None
-    
-    if not cached_answers:
-        return "No cached answers available. Please generate answers first.", None
-    
-    username = profile.username
-    space_id = os.getenv("SPACE_ID")
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main" if space_id else "Unknown"
-    
-    # Prepare submission payload
-    answers_payload = []
-    for task_id, data in cached_answers.items():
-        answers_payload.append({
-            "task_id": task_id,
-            "submitted_answer": data["answer"]
-        })
-    
-    submission_data = {
-        "username": username.strip(),
-        "agent_code": agent_code,
-        "answers": answers_payload
+    # Map model choice to actual model name
+    model_map = {
+        "Llama 3.1 8B": "meta-llama/Llama-3.1-8B-Instruct",
+        "Llama 3.1 70B": "meta-llama/Llama-3.1-70B-Instruct",
+        "Mistral 7B": "mistralai/Mistral-7B-Instruct-v0.3",
+        "CodeLlama 7B": "codellama/CodeLlama-7b-Instruct-hf"
     }
     
-    # Submit to API
-    api_url = DEFAULT_API_URL
-    submit_url = f"{api_url}/submit"
+    selected_model = model_map.get(model_choice, "meta-llama/Llama-3.1-8B-Instruct")
     
-    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    # Start generation in background thread
+    thread = threading.Thread(target=generate_answers_async, args=(selected_model,))
+    thread.daemon = True
+    thread.start()
     
-    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"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.')}"
-        )
-        
-        # Create results DataFrame
-        results_log = []
-        for task_id, data in cached_answers.items():
-            results_log.append({
-                "Task ID": task_id,
-                "Question": data["question"],
-                "Submitted Answer": data["answer"]
-            })
-        
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
-        
-    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:
-            error_detail += f" Response: {e.response.text[:500]}"
-        return f"Submission Failed: {error_detail}", None
-        
-    except requests.exceptions.Timeout:
-        return "Submission Failed: The request timed out.", None
-        
-    except Exception as e:
-        return f"Submission Failed: {e}", None
+    return f"Answer generation started using {model_choice}. Check progress below.", None
 
-def clear_cache():
-    """
-    Clear all cached data.
-    """
-    global cached_answers, cached_questions, processing_status
-    cached_answers = {}
-    cached_questions = []
-    processing_status = {"is_processing": False, "progress": 0, "total": 0}
-    return "Cache cleared successfully.", None
-
-# --- Enhanced Gradio Interface ---
-with gr.Blocks(title="Enhanced Agent Evaluation Runner") as demo:
-    gr.Markdown("# Enhanced Agent Evaluation Runner with Answer Caching")
-
-    with gr.Row():
-        gr.LoginButton()
-        clear_btn = gr.Button("Clear Cache", variant="secondary")
-
-    with gr.Tab("Step 1: Fetch Questions"):
-        gr.Markdown("### Fetch Questions from API")
-        fetch_btn = gr.Button("Fetch Questions", variant="primary")
-        fetch_status = gr.Textbox(label="Fetch Status", lines=2, interactive=False)
-        questions_table = gr.DataFrame(label="Available Questions", wrap=True)
-        
-        fetch_btn.click(
-            fn=fetch_questions,
-            outputs=[fetch_status, questions_table]
-        )
-
-    with gr.Tab("Step 2: Generate Answers"):
-        gr.Markdown("### Generate Answers (Background Processing)")
-        
-        with gr.Row():
-            generate_btn = gr.Button("Start Answer Generation", variant="primary")
-            refresh_btn = gr.Button("Refresh Progress", variant="secondary")
-        
-        generation_status = gr.Textbox(label="Generation Status", lines=2, interactive=False)
-        answers_preview = gr.DataFrame(label="Generated Answers Preview", wrap=True)
-        
-        generate_btn.click(
-            fn=start_answer_generation,
-            outputs=[generation_status, answers_preview]
-        )
-        
-        refresh_btn.click(
-            fn=get_generation_progress,
-            outputs=[generation_status, answers_preview]
-        )
-
-    with gr.Tab("Step 3: Submit Results"):
-        gr.Markdown("### Submit Generated Answers")
-        submit_btn = gr.Button("Submit Cached Answers", variant="primary")
-        submission_status = gr.Textbox(label="Submission Status", lines=5, interactive=False)
-        final_results = gr.DataFrame(label="Final Submission Results", wrap=True)
-        
-        submit_btn.click(
-            fn=submit_cached_answers,
-            outputs=[submission_status, final_results]
-        )
-
-    # Clear cache functionality
-    clear_btn.click(
-        fn=clear_cache,
-        outputs=[fetch_status, questions_table]
-    )
-
-    # Auto-refresh progress every 5 seconds when generation is active
-    demo.load(
-        fn=get_generation_progress,
-        outputs=[generation_status, answers_preview]
-    )
-
-if __name__ == "__main__":
-    print("\n" + "-"*30 + " Enhanced App Starting " + "-"*30)
-    
-    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 should be: 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?). Repo URL cannot be determined.")
-
-    print("-"*(60 + len(" Enhanced App Starting ")) + "\n")
-
-    print("Launching Enhanced Gradio Interface...")
-    demo.launch(debug=True, share=False)
+def get_generation_progre