some changes to add llm and cleaning changes too

app.py

@@ -3,6 +3,9 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import time
+import json
+from typing import Dict, List, Union, Optional
 
 # (Keep Constants as is)
 # --- Constants ---
@@ -13,11 +16,122 @@ DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 class BasicAgent:
     def __init__(self):
         print("BasicAgent initialized.")
+        # Initialize the Hugging Face API client
+        self.hf_api_url = "https://api-inference.huggingface.co/models/meta-llama/Meta-Llama-3-8B-Instruct"
+        self.hf_api_token = os.getenv("HF_API_TOKEN")
+        if not self.hf_api_token:
+            print("WARNING: HF_API_TOKEN not found. Using default fallback methods.")
+        self.headers = {"Authorization": f"Bearer {self.hf_api_token}"} if self.hf_api_token else {}
+        self.max_retries = 3
+        self.retry_delay = 2  # seconds
+        
+    def query_llm(self, prompt):
+        """Send a prompt to the LLM API and return the response."""
+        if not self.hf_api_token:
+            # Fallback to a rule-based approach if no API token
+            return self.rule_based_answer(prompt)
+            
+        payload = {
+            "inputs": prompt,
+            "parameters": {
+                "max_new_tokens": 512,
+                "temperature": 0.7,
+                "top_p": 0.9,
+                "do_sample": True
+            }
+        }
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = requests.post(self.hf_api_url, headers=self.headers, json=payload, timeout=30)
+                response.raise_for_status()
+                result = response.json()
+                
+                # Extract the generated text from the response
+                if isinstance(result, list) and len(result) > 0:
+                    generated_text = result[0].get("generated_text", "")
+                    # Clean up the response to get just the answer
+                    return self.clean_response(generated_text, prompt)
+                return "I couldn't generate a proper response."
+                
+            except Exception as e:
+                print(f"Attempt {attempt+1}/{self.max_retries} failed: {str(e)}")
+                if attempt < self.max_retries - 1:
+                    time.sleep(self.retry_delay)
+                else:
+                    # Fall back to rule-based method on failure
+                    return self.rule_based_answer(prompt)
+    
+    def clean_response(self, response, prompt):
+        """Clean up the LLM response to extract the answer."""
+        # Remove the prompt from the beginning if it's included
+        if response.startswith(prompt):
+            response = response[len(prompt):]
+        
+        # Try to find where the model's actual answer begins
+        # This is model-specific and may need adjustments
+        markers = ["<answer>", "<response>", "Answer:", "Response:"]
+        for marker in markers:
+            if marker.lower() in response.lower():
+                parts = response.lower().split(marker.lower(), 1)
+                if len(parts) > 1:
+                    response = parts[1].strip()
+        
+        # Remove any closing tags if they exist
+        end_markers = ["</answer>", "</response>"]
+        for marker in end_markers:
+            if marker.lower() in response.lower():
+                response = response.lower().split(marker.lower())[0].strip()
+        
+        return response.strip()
+    
+    def rule_based_answer(self, question):
+        """Fallback method using rule-based answers for common question types."""
+        question_lower = question.lower()
+        
+        # Simple pattern matching for common question types
+        if "what is" in question_lower or "define" in question_lower:
+            if "agent" in question_lower:
+                return "An agent is an autonomous entity that observes and acts upon an environment using sensors and actuators, usually to achieve specific goals."
+            if "gaia" in question_lower:
+                return "GAIA (General AI Assistant) is a framework for creating and evaluating AI assistants that can perform a wide range of tasks."
+        
+        if "how to" in question_lower:
+            return "To accomplish this task, you should first understand the requirements, then implement a solution step by step, and finally test your implementation."
+        
+        if "example" in question_lower:
+            return "Here's an example implementation that demonstrates the concept in a practical manner."
+        
+        # Default response for unmatched questions
+        return "Based on my understanding, the answer involves analyzing the context carefully and applying the relevant principles to arrive at a solution."
+    
+    def format_prompt(self, question):
+        """Format the question into a proper prompt for the LLM."""
+        return f"""You are an intelligent AI assistant. Please answer the following question accurately and concisely:
+
+Question: {question}
+
+Answer:"""
+    
     def __call__(self, question: str) -> str:
         print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
+        
+        try:
+            # Format the question as a prompt
+            prompt = self.format_prompt(question)
+            
+            # Query the LLM
+            answer = self.query_llm(prompt)
+            
+            print(f"Agent returning answer (first 50 chars): {answer[:50]}...")
+            return answer
+            
+        except Exception as e:
+            print(f"Error in agent: {e}")
+            # Fallback to the rule-based method if anything goes wrong
+            fallback_answer = self.rule_based_answer(question)
+            print(f"Agent returning fallback answer: {fallback_answer[:50]}...")
+            return fallback_answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """

requirements.txt

@@ -1,2 +1,3 @@
 gradio
-requests
+requests
+pandas