Create app.py

app.py

@@ -5,16 +5,25 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+import subprocess
+import sys
 
 # Import SerpAPI
 from serpapi import GoogleSearch
 
+# Import Hugging Face libraries
+import torch
+from transformers import AutoModelForCausalLM, AutoTokenizer
+
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 # Get SerpAPI key from environment variables
 SERPAPI_API_KEY = os.getenv('SERPAPI_API_KEY')
 print(f"SERPAPI_API_KEY (first 5 chars): {SERPAPI_API_KEY[:5] if SERPAPI_API_KEY else 'None'}...") # Debugging API key
 
+# Access the loaded Hugging Face model and tokenizer (loaded in a previous cell)
+# Ensure these global variables are defined by running the model loading cell first.
+global hf_model, hf_tokenizer
 
 # --- Web Search Function (using SerpAPI) ---
 def web_search(query: str) -> list[dict]:
@@ -60,7 +69,7 @@ def web_search(query: str) -> list[dict]:
         else:
             print("No 'organic_results' key found in SerpAPI response.")
             # Print the whole response if no organic_results are found for debugging
-            print(f"SerpAPI response (no organic results): {search_results_dict}")
+            # print(f"SerpAPI response (no organic results): {search_results_dict}")
 
 
     except Exception as e:
@@ -70,16 +79,17 @@ def web_search(query: str) -> list[dict]:
     return results
 
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-
+# --- Basic Agent Definition (Updated to use LLM) ---
 class BasicAgent:
 
     def __init__(self):
         print("BasicAgent initialized.")
-        # Access the globally loaded model and tokenizer
-        self.tokenizer = hf_tokenizer
-        self.model = hf_model
+        # Check if LLM and tokenizer are loaded (optional but good practice)
+        if 'hf_model' not in globals() or 'hf_tokenizer' not in globals():
+             print("Warning: Hugging Face model or tokenizer not loaded before agent initialization.")
+             # You might want to raise an error or handle this case more robustly
+        else:
+            print("Hugging Face model and tokenizer found.")
 
 
     def __call__(self, question: str) -> str:
@@ -96,65 +106,88 @@ class BasicAgent:
             search_results = web_search(question) # Call the web_search function
             print(f"Received {len(search_results)} search results from web_search.") # Debugging results received
 
-            if search_results:
-                # Format search results into a context string for the LLM
+            if search_results and hf_model and hf_tokenizer:
+                # --- Use LLM to process search results ---
+                print("Using LLM to process search results.")
+
+                # Format search results for the LLM
                 context = ""
-                for i, result in enumerate(search_results[:3]): # Use top 3 results
-                    context += f"Result {i+1}:\n"
+                for i, result in enumerate(search_results[:5]): # Use top 5 results for context
+                    context += f"Source {i+1}:\n"
                     if result.get('title'):
-                        context += f"Title: {result['title']}\n"
+                         context += f"Title: {result['title']}\n"
                     if result.get('snippet'):
-                        context += f"Snippet: {result['snippet']}\n"
+                         context += f"Snippet: {result['snippet']}\n"
                     if result.get('url'):
-                        context += f"URL: {result['url']}\n"
-                    context += "---\n"
+                         context += f"URL: {result['url']}\n"
+                    context += "---\n" # Separator
+
+                # Create a prompt for the LLM
+                prompt = f"""Using the following search results, answer the question accurately.
+If the search results do not contain enough information to answer the question,
+respond with "I couldn't find enough information in the search results."
+
+Question: {question}
 
-                # Construct the prompt for the LLM
-                prompt = f"Question: {question}\n\nSearch Results:\n{context}\nBased on the search results provided, please answer the question."
-                print(f"LLM Prompt (first 200 chars): {prompt[:200]}...") # Debugging prompt
+Search Results:
+{context}
+
+Answer:"""
+
+                print(f"LLM Prompt (first 500 chars):\n{prompt[:500]}...") # Debugging prompt
 
                 try:
-                    # Encode the prompt
-                    inputs = self.tokenizer(prompt, return_tensors="pt")
-
-                    # Generate response using the LLM
-                    # Adjust generation parameters as needed
-                    output_sequences = self.model.generate(
-                        **inputs,
-                        max_length=512,  # Maximum length of the generated text
-                        num_return_sequences=1, # Number of sequences to generate
-                        no_repeat_ngram_size=2, # Avoid repeating n-grams
-                        do_sample=True, # Enable sampling
-                        top_k=50, # Sample from top_k tokens
-                        top_p=0.95, # Sample from top_p probability mass
-                        temperature=0.7, # Control randomness
-                        attention_mask=inputs['attention_mask'] # Pass attention mask
-                    )
-
-                    # Decode the generated output
-                    generated_text = self.tokenizer.decode(output_sequences[0], skip_special_tokens=True)
-                    print(f"LLM Generated Text (first 200 chars): {generated_text[:200]}...") # Debugging generated text
-
-                    # Extract the answer from the generated text
-                    # For CausalLMs like gpt2, the prompt is included in the output,
-                    # so we need to remove it.
-                    if generated_text.startswith(prompt):
-                        llm_answer = generated_text[len(prompt):].strip()
+                    # Tokenize the prompt
+                    inputs = hf_tokenizer(prompt, return_tensors="pt")
+
+                    # Generate a response from the LLM
+                    # Note: Generation parameters like max_length, temperature, do_sample
+                    # can significantly affect the output.
+                    # This is a basic example. You might need to experiment here.
+                    # For gpt2, max_length might need adjustment if prompt+context is too long.
+                    # Also, be aware of model context window limitations.
+                    # If using a chat model, a chat template might be needed.
+                    # For demonstration, using a simple generation approach.
+                    generate_ids = hf_model.generate(inputs.input_ids, max_length=512, num_return_sequences=1, temperature=0.7, do_sample=True) # Adjust max_length as needed
+                    generated_text = hf_tokenizer.batch_decode(generate_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True)[0]
+
+                    # Extract only the answer part from the generated text if necessary
+                    # Depending on the prompt and model, the model might repeat the prompt.
+                    # A simple way is to look for the "Answer:" tag.
+                    answer_tag = "Answer:"
+                    if answer_tag in generated_text:
+                        llm_answer = generated_text.split(answer_tag, 1)[1].strip()
                     else:
-                        # Fallback if the output format is unexpected
-                        llm_answer = generated_text.strip()
+                        llm_answer = generated_text.strip() # Fallback if tag not found
+
+                    print(f"LLM generated text (first 100 chars): {generated_text[:100]}...") # Debugging raw output
+                    print(f"Agent returning LLM-based answer (first 100 chars): {llm_answer[:100]}...") # Debugging final answer
 
                     if llm_answer:
-                         print(f"Agent returning LLM-based answer: {llm_answer[:100]}...")
                          return llm_answer
                     else:
-                         print("LLM generated empty or whitespace answer.")
-                         return "I couldn't generate a specific answer based on the search results."
-
-
-                except Exception as e:
-                    print(f"Error during LLM generation: {e}")
-                    return f"An error occurred while generating the answer using the LLM: {e}"
+                         # Fallback if LLM generates empty response
+                         print("LLM generated an empty response.")
+                         return "I couldn't generate an answer based on the search results."
+
+                except Exception as llm_e:
+                     print(f"An error occurred during LLM generation: {llm_e}")
+                     return f"An error occurred while processing search results with the LLM: {llm_e}"
+
+            elif search_results:
+                 # Fallback if model/tokenizer not loaded but search results exist
+                 print("Hugging Face model or tokenizer not loaded. Cannot use LLM.")
+                 # Return the old style answer if LLM is not available
+                 answer_parts = []
+                 for i, result in enumerate(search_results[:3]):
+                    if result.get('snippet'):
+                        answer_parts.append(f"Snippet {i+1}: {result['snippet']}")
+                    elif result.get('title'):
+                         answer_parts.append(f"Result {i+1} Title: {result['title']}")
+                 if answer_parts:
+                     return "Based on web search (LLM not available):\n" + "\n".join(answer_parts)
+                 else:
+                     return "I couldn't find useful information in the search results (LLM not available)."
 
 
             else:
@@ -300,10 +333,9 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Basic Agent Evaluation Runner") as
         **Instructions:**
         1. Ensure your agent logic is defined in the `BasicAgent` class above.
         2. **Get a SerpAPI key and add it as an environment variable in your runtime environment (e.g., as a secret in your Hugging Face Space settings).**
-        3. **Ensure your Hugging Face model and tokenizer are loaded (usually in a preceding cell).**
-        4. Log in to Hugging Face using the button below.
-        5. Click the "Run Evaluation & Submit All Answers" button.
-        6. The application will fetch questions, run your agent, submit answers, and display the results below.
+        3. Log in to Hugging Face using the button below.
+        4. Click the "Run Evaluation & Submit All Answers" button.
+        5. The application will fetch questions, run your agent, submit answers, and display the results below.
         """
     )
     login_btn = gr.LoginButton()