Create app.py

print("Application script started.") # Debugging print statement

import os
import gradio as gr
import requests
import inspect
import pandas as pd

# Import libraries for SerpAPI
from serpapi import GoogleSearch
# Removed google.generativeai import as LLM is not currently usable


# --- Get API Keys from Environment Variables ---
# SERPAPI_API_KEY and GOOGLE_API_KEY should be set as secrets in your Hugging Face Space
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

# Removed GOOGLE_API_KEY as it's not used in this version
# GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
# print(f"GOOGLE_API_KEY (first 5 chars): {GOOGLE_API_KEY[:5] if GOOGLE_API_KEY else 'None'}...") # Debugging API key

# --- Define the default API URL ---
DEFAULT_API_URL = "https://agent-challenge.hf.space/agent_challenge" # Or the correct API URL if different


# --- Google Generative AI LLM Initialization (Removed) ---
# print("Attempting to initialize Google Generative AI model...") # Debugging print before loading
# gemini_model = None # Initialize to None
# if not GOOGLE_API_KEY:
# print("Warning: GOOGLE_API_KEY environment variable not set. LLM will not be available.")
# else:
# try:
# # Configure the generative AI library
# genai.configure(api_key=GOOGLE_API_KEY)
# print("Google Generative AI configured.")
# gemini_model = genai.GenerativeModel('gemini-1.5-flash')
# print("Gemini model initialized successfully.") # Debugging print after successful init
# except Exception as e:
# print(f"An error occurred during Google Generative AI initialization: {e}")
# gemini_model = None # Ensure model is None if initialization fails


# --- Web Search Function (using SerpAPI) ---
def web_search(query: str) -> list[dict]:
# Removed global gemini_model declaration as it's not used here
"""
Performs a web search using SerpAPI and returns relevant information.

Args:
query: The search query string.

Returns:
A list of dictionaries, where each dictionary represents a search result
with keys 'title', 'snippet', and 'url'. Returns an empty list if no
results are found or an error occurs.
"""
print(f"web_search called with query: {query[:50]}...") # Debugging web_search call
if not SERPAPI_API_KEY:
print("SerpAPI key not found in environment variables.")
return []

params = {
"q": query,
"api_key": SERPAPI_API_KEY,
"engine": "google", # Use Google search engine
"num": 5 # Number of results to fetch
}
results = []

try:
search = GoogleSearch(params)
search_results_dict = search.get_dict() # Get results as a dictionary
print(f"SerpAPI raw response keys: {search_results_dict.keys() if isinstance(search_results_dict, dict) else 'Response is not a dictionary'}") # Debugging response keys

# Extract organic results
# Add check that search_results_dict and organic_results are valid
if isinstance(search_results_dict, dict) and "organic_results" in search_results_dict and isinstance(search_results_dict["organic_results"], list):
print(f"Found {len(search_results_dict['organic_results'])} organic results.") # Debugging result count
for result in search_results_dict["organic_results"]:
# Add check for None or non-dict result item
if result is None or not isinstance(result, dict):
print(f"Skipping invalid search result item: {result}")
continue
item = {
'title': result.get('title'),
'url': result.get('link'),
'snippet': result.get('snippet', 'No snippet available')
}
results.append(item)
else:
print(f"No 'organic_results' key found or invalid format in SerpAPI response. Response type: {type(search_results_dict)}")
# Print the whole response if no organic_results are found for debugging
# print(f"SerpAPI response (no organic results): {search_results_dict}")


except Exception as e:
print(f"An error occurred during SerpAPI web search: {e}")
# Ensure an empty list is returned on error
return []

print(f"web_search returning {len(results)} results.") # Debugging return count
return results # Always return a list (empty or with results)


# --- Basic Agent Definition (Modified to remove LLM dependency for now) ---
class BasicAgent:

def __init__(self):
print("BasicAgent initialized.") # Debugging print before init
# Removed LLM check as it's not used here
# global gemini_model # Access global variable
# if gemini_model is None:
# print("Warning: Google Generative AI model not successfully loaded before agent initialization.")
# else:
# print("Google Generative AI model found and ready.") # Debugging print after successful init


def __call__(self, question: str) -> str:
# Removed global gemini_model declaration as it's not used here
print(f"Agent received question (first 50 chars): {question[:50]}...")

# Simple logic to determine if a web search is needed
question_lower = question.lower()
search_keywords = ["what is", "how to", "where is", "who is", "when did", "define", "explain", "tell me about"]
needs_search = any(keyword in question_lower for keyword in search_keywords) or "?" in question
print(f"Needs search: {needs_search}") # Debugging search decision

# --- Analyze question and refine search query ---
# Simplified search query generation - removed LLM query generation
search_query = question # Default search query is the original question
if needs_search:
print("Analyzing question for keywords and refining search query...")
# Basic keyword extraction: split by common question words and take the rest
parts = question_lower.split("what is", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
parts = question_lower.split("how to", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
parts = question_lower.split("where is", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
parts = question_lower.split("who is", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
parts = question_lower.split("when did", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
parts = question_lower.split("define", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
parts = question_lower.split("explain", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
parts = question_lower.split("tell me about", 1)
if len(parts) > 1:
search_query = parts[1].strip()
else:
# If no specific question keyword found, use the whole question
search_query = question_lower.strip()


# Optional: Add quotation marks for multi-word phrases if identified
# This simple approach just uses the extracted part as is.
# A more complex approach would identify multi-word entities (e.g., "New York City")
# and wrap them in quotes.

# Optional: Add contextual terms
# Example: If "musician" or "band" is in the question, add "discography"
if any(word in question_lower for word in ["musician", "band", "artist", "singer"]):
search_query += " discography"
elif any(word in question_lower for word in ["movie", "film", "actor", "actress"]):
search_query += " plot summary"
elif any(word in question_lower for word in ["book", "author", "novel"]):
search_query += " plot summary"


print(f"Final search query used: {search_query}") # Debugging final query

search_results = [] # Initialize search_results to an empty list before the try block
if needs_search:
print(f"Question likely requires search. Searching for: {search_query}")
try:
search_results = web_search(search_query) # Call the web_search function with the generated query
print(f"Received {len(search_results)} search results from web_search.") # Debugging results received
print(f"Type of search_results: {type(search_results)}") # Debugging type of search_results
except Exception as e:
print(f"An error occurred during web search: {e}")
return f"An error occurred during web search: {e}"

# --- Use LLM to process search results if available (Removed LLM Synthesis) ---
# Check that search_results is a list and is not empty
if isinstance(search_results, list) and search_results:
print("Returning basic answer based on search results (LLM not available).")
answer_parts = []

app.py

@@ -1,17 +1,14 @@
+print("Application script started.") # Debugging print statement
+
 import os
 import gradio as gr
 import requests
 import inspect
 import pandas as pd
 
-# Import libraries for SerpAPI and Google Generative AI
+# Import libraries for SerpAPI
 from serpapi import GoogleSearch
-import google.generativeai as genai
-
-# --- Constants ---
-DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space" # Corrected API URL
-
-print("Application script started.") # Debugging print statement
+# Removed google.generativeai import as LLM is not currently usable
 
 
 # --- Get API Keys from Environment Variables ---
@@ -19,37 +16,34 @@ print("Application script started.") # Debugging print statement
 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
 
-GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
-print(f"GOOGLE_API_KEY (first 5 chars): {GOOGLE_API_KEY[:5] if GOOGLE_API_KEY else 'None'}...") # Debugging API key
-
+# Removed GOOGLE_API_KEY as it's not used in this version
+# GOOGLE_API_KEY = os.getenv('GOOGLE_API_KEY')
+# print(f"GOOGLE_API_KEY (first 5 chars): {GOOGLE_API_KEY[:5] if GOOGLE_API_KEY else 'None'}...") # Debugging API key
 
-# --- Google Generative AI LLM Initialization ---
-print("Attempting to initialize Google Generative AI model...") # Debugging print before loading
+# --- Define the default API URL ---
+DEFAULT_API_URL = "https://agent-challenge.hf.space/agent_challenge" # Or the correct API URL if different
 
-gemini_model = None # Initialize to None
 
-if not GOOGLE_API_KEY:
-    print("Warning: GOOGLE_API_KEY environment variable not set. LLM will not be available.")
-else:
-    try:
-        # Configure the generative AI library
-        genai.configure(api_key=GOOGLE_API_KEY)
-        print("Google Generative AI configured.")
-
-        # Initialize the Generative Model
-        # Using a fast and efficient model like gemini-1.5-flash
-        # You can explore other models like 'gemini-1.5-pro' for potentially better results
-        gemini_model = genai.GenerativeModel('gemini-1.5-flash')
-        print("Gemini model initialized successfully.") # Debugging print after successful init
-
-    except Exception as e:
-        print(f"An error occurred during Google Generative AI initialization: {e}")
-        gemini_model = None # Ensure model is None if initialization fails
+# --- Google Generative AI LLM Initialization (Removed) ---
+# print("Attempting to initialize Google Generative AI model...") # Debugging print before loading
+# gemini_model = None # Initialize to None
+# if not GOOGLE_API_KEY:
+#     print("Warning: GOOGLE_API_KEY environment variable not set. LLM will not be available.")
+# else:
+#     try:
+#         # Configure the generative AI library
+#         genai.configure(api_key=GOOGLE_API_KEY)
+#         print("Google Generative AI configured.")
+#         gemini_model = genai.GenerativeModel('gemini-1.5-flash')
+#         print("Gemini model initialized successfully.") # Debugging print after successful init
+#     except Exception as e:
+#         print(f"An error occurred during Google Generative AI initialization: {e}")
+#         gemini_model = None # Ensure model is None if initialization fails
 
 
 # --- Web Search Function (using SerpAPI) ---
 def web_search(query: str) -> list[dict]:
-    global gemini_model # Ensure global declaration is first
+    # Removed global gemini_model declaration as it's not used here
     """
     Performs a web search using SerpAPI and returns relevant information.
 
@@ -109,22 +103,21 @@ def web_search(query: str) -> list[dict]:
     return results # Always return a list (empty or with results)
 
 
-# --- Basic Agent Definition (Updated to use Google LLM) ---
+# --- Basic Agent Definition (Modified to remove LLM dependency for now) ---
 class BasicAgent:
 
     def __init__(self):
         print("BasicAgent initialized.") # Debugging print before init
-        # Check if LLM is loaded (optional but good practice)
-        global gemini_model # Access global variable
-        if gemini_model is None:
-             print("Warning: Google Generative AI model not successfully loaded before agent initialization.")
-             # The agent can still perform search but won't use the LLM for synthesis
-        else:
-            print("Google Generative AI model found and ready.") # Debugging print after successful init
+        # Removed LLM check as it's not used here
+        # global gemini_model # Access global variable
+        # if gemini_model is None:
+        #      print("Warning: Google Generative AI model not successfully loaded before agent initialization.")
+        # else:
+        #     print("Google Generative AI model found and ready.") # Debugging print after successful init
 
 
     def __call__(self, question: str) -> str:
-        global gemini_model # Ensure global declaration is first
+        # Removed global gemini_model declaration as it's not used here
         print(f"Agent received question (first 50 chars): {question[:50]}...")
 
         # Simple logic to determine if a web search is needed
@@ -134,138 +127,45 @@ class BasicAgent:
         print(f"Needs search: {needs_search}") # Debugging search decision
 
         # --- Analyze question and refine search query ---
+        # Simplified search query generation - removed LLM query generation
         search_query = question # Default search query is the original question
         if needs_search:
             print("Analyzing question for keywords and refining search query...")
-            # A more refined approach: identify potential entities or key phrases
-            # This is a simplified example; advanced agents might use NLP libraries (spaCy, NLTK)
-            # or even the LLM itself to extract optimal search terms.
-
-            # Simple approach: Use LLM to generate search query
-            if gemini_model is not None:
-                print("Using LLM to generate search query.")
-                query_prompt = f"""Given the following question, generate the most effective web search query to find information to answer it.
-Focus on extracting key entities and concepts. Do not include question words like "what is" or "how to".
-
-Question: {question}
-
-Search Query:"""
-                try:
-                    response = gemini_model.generate_content(query_prompt)
-                    generated_query = response.text.strip()
-                    if generated_query and len(generated_query.split()) > 1: # Ensure it's not empty or just one word
-                         search_query = generated_query
-                         print(f"LLM generated search query: {search_query}")
-                    else:
-                        print(f"LLM generated empty or single-word query: '{generated_query}'. Falling back to basic extraction.")
-                        # Fallback to basic extraction if LLM fails
-                        parts = question_lower.split("what is", 1)
-                        if len(parts) > 1:
-                            search_query = parts[1].strip()
-                        else:
-                            parts = question_lower.split("how to", 1)
-                            if len(parts) > 1:
-                                search_query = parts[1].strip()
-                            else:
-                                 parts = question_lower.split("where is", 1)
-                                 if len(parts) > 1:
-                                     search_query = parts[1].strip()
-                                 else:
-                                     parts = question_lower.split("who is", 1)
-                                     if len(parts) > 1:
-                                         search_query = parts[1].strip()
-                                     else:
-                                          parts = question_lower.split("when did", 1)
-                                          if len(parts) > 1:
-                                              search_query = parts[1].strip()
-                                          else:
-                                               parts = question_lower.split("define", 1)
-                                               if len(parts) > 1:
-                                                   search_query = parts[1].strip()
-                                               else:
-                                                    parts = question_lower.split("explain", 1)
-                                                    if len(parts) > 1:
-                                                        search_query = parts[1].strip()
-                                                    else:
-                                                         parts = question_lower.split("tell me about", 1)
-                                                         if len(parts) > 1:
-                                                             search_query = parts[1].strip()
-                                                         else:
-                                                             search_query = question_lower.strip() # Fallback to whole question
-
-
-                except Exception as llm_e:
-                    print(f"An error occurred during LLM search query generation: {llm_e}. Falling back to basic extraction.")
-                    # Fallback to basic extraction if LLM call fails
-                    parts = question_lower.split("what is", 1)
-                    if len(parts) > 1:
-                        search_query = parts[1].strip()
-                    else:
-                        parts = question_lower.split("how to", 1)
-                        if len(parts) > 1:
-                            search_query = parts[1].strip()
-                        else:
-                             parts = question_lower.split("where is", 1)
-                             if len(parts) > 1:
-                                 search_query = parts[1].strip()
-                             else:
-                                 parts = question_lower.split("who is", 1)
-                                 if len(parts) > 1:
-                                     search_query = parts[1].strip()
-                                 else:
-                                      parts = question_lower.split("when did", 1)
-                                      if len(parts) > 1:
-                                          search_query = parts[1].strip()
-                                      else:
-                                           parts = question_lower.split("define", 1)
-                                           if len(parts) > 1:
-                                               search_query = parts[1].strip()
-                                           else:
-                                                parts = question_lower.split("explain", 1)
-                                                if len(parts) > 1:
-                                                    search_query = parts[1].strip()
-                                                else:
-                                                     parts = question_lower.split("tell me about", 1)
-                                                     if len(parts) > 1:
-                                                         search_query = parts[1].strip()
-                                                     else:
-                                                         search_query = question_lower.strip() # Fallback to whole question
-            else: # LLM not available
-                 print("LLM not available. Using basic search query extraction.")
-                 # Fallback to basic extraction if LLM is not initialized
-                 parts = question_lower.split("what is", 1)
-                 if len(parts) > 1:
-                     search_query = parts[1].strip()
-                 else:
-                     parts = question_lower.split("how to", 1)
+            # Basic keyword extraction: split by common question words and take the rest
+            parts = question_lower.split("what is", 1)
+            if len(parts) > 1:
+                search_query = parts[1].strip()
+            else:
+                parts = question_lower.split("how to", 1)
+                if len(parts) > 1:
+                    search_query = parts[1].strip()
+                else:
+                     parts = question_lower.split("where is", 1)
                      if len(parts) > 1:
                          search_query = parts[1].strip()
                      else:
-                          parts = question_lower.split("where is", 1)
-                          if len(parts) > 1:
-                              search_query = parts[1].strip()
-                          else:
-                              parts = question_lower.split("who is", 1)
+                         parts = question_lower.split("who is", 1)
+                         if len(parts) > 1:
+                             search_query = parts[1].strip()
+                         else:
+                              parts = question_lower.split("when did", 1)
                               if len(parts) > 1:
                                   search_query = parts[1].strip()
                               else:
-                                   parts = question_lower.split("when did", 1)
+                                   parts = question_lower.split("define", 1)
                                    if len(parts) > 1:
                                        search_query = parts[1].strip()
                                    else:
-                                        parts = question_lower.split("define", 1)
+                                        parts = question_lower.split("explain", 1)
                                         if len(parts) > 1:
                                             search_query = parts[1].strip()
                                         else:
-                                             parts = question_lower.split("explain", 1)
+                                             parts = question_lower.split("tell me about", 1)
                                              if len(parts) > 1:
                                                  search_query = parts[1].strip()
                                              else:
-                                                  parts = question_lower.split("tell me about", 1)
-                                                  if len(parts) > 1:
-                                                      search_query = parts[1].strip()
-                                                  else:
-                                                      search_query = question_lower.strip() # Fallback to whole question
+                                                 # If no specific question keyword found, use the whole question
+                                                 search_query = question_lower.strip()
 
 
             # Optional: Add quotation marks for multi-word phrases if identified
@@ -285,106 +185,52 @@ Search Query:"""
 
             print(f"Final search query used: {search_query}") # Debugging final query
 
-
+            search_results = [] # Initialize search_results to an empty list before the try block
             if needs_search:
                 print(f"Question likely requires search. Searching for: {search_query}")
-                search_results = web_search(search_query) # Call the web_search function with the generated query
-                print(f"Received {len(search_results)} search results from web_search.") # Debugging results received
-                print(f"Type of search_results: {type(search_results)}") # Debugging type of search_results
-
-
-                # --- Use LLM to process search results if available ---
-                # Add check that search_results is a list before proceeding
-                if isinstance(search_results, list) and search_results and gemini_model is not None:
-                    print("Using Google LLM to process search results.") # Debugging print before LLM call
-
-                    # Format search results for the LLM
-                    context = ""
-                    for i, result in enumerate(search_results[:5]): # Use top 5 results for context
-                        # Add check for None or non-dict result item before accessing keys
-                        if result is None or not isinstance(result, dict):
-                            print(f"Skipping invalid result at index {i} in LLM context formatting: {result}")
-                            continue
-                        context += f"Source {i+1}:\n"
-                        if result.get('title'):
-                             context += f"Title: {result['title']}\n"
-                        if result.get('snippet'):
-                             context += f"Snippet: {result['snippet']}\n"
-                        if result.get('url'):
-                             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}
-
-Search Results:
-{context}
-
-Answer:"""
-
-                    print(f"LLM Prompt (first 500 chars):\n{prompt[:500]}...") # Debugging prompt
-
-                    try:
-                        # Generate content using the Gemini model
-                        response = gemini_model.generate_content(prompt)
-                        generated_text = response.text # Get the generated text
-
-                        # 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:
-                            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:
-                             return llm_answer
-                        else:
-                             # 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}"
-
-                # Fallback if search results are empty OR LLM is None (due to initialization error)
-                elif isinstance(search_results, list) and search_results: # Search results exist and is a list, but LLM is not available
-                     print("Google Generative AI model not loaded. Cannot use LLM.")
-                     # Return the old style answer if LLM is not available, but only if search results exist
-                     print("Returning basic answer based on search results (LLM not available).")
-                     answer_parts = []
-                     for i, result in enumerate(search_results[:3]):
-                        # Add check for None or non-dict result item before accessing keys
-                        if result is None or not isinstance(result, dict):
-                            print(f"Skipping invalid result at index {i} in basic answer formatting: {result}")
-                            continue
-                        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:
+                try:
+                    search_results = web_search(search_query) # Call the web_search function with the generated query
+                    print(f"Received {len(search_results)} search results from web_search.") # Debugging results received
+                    print(f"Type of search_results: {type(search_results)}") # Debugging type of search_results
+                except Exception as e:
+                    print(f"An error occurred during web search: {e}")
+                    return f"An error occurred during web search: {e}"
+
+                # --- Use LLM to process search results if available (Removed LLM Synthesis) ---
+                # Check that search_results is a list and is not empty
+                if isinstance(search_results, list) and search_results:
+                    print("Returning basic answer based on search results (LLM not available).")
+                    answer_parts = []
+                    for i, result in enumerate(search_results[:3]):
+                       # Add check for None or non-dict result item before accessing keys
+                       if result is None or not isinstance(result, dict):
+                           print(f"Skipping invalid result at index {i} in basic answer formatting: {result}")
+                           continue
+                       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:
+                         # Fallback if no useful snippets/titles found in search results
+                         print("No useful snippets/titles found in search results.")
                          return "I couldn't find useful information in the search results (LLM not available)."
                 else: # search_results is None or not a list, or empty
                     print(f"Web search returned no results or results in invalid format. Type: {type(search_results)}")
                     return "I couldn't find any relevant information on the web for your question."
 
-            else:
-                # If no search is needed, return a default or simple response
-                print("Question does not appear to require search. Returning fixed answer.")
-                fixed_answer = "How can I help you?"
-                return fixed_answer
+            else: # needs_search is True but no search results were returned
+                 # This else block should ideally not be reached if needs_search is True and web_search is called
+                 print("Question required search, but no search was performed or it failed.")
+                 return "I couldn't perform a web search for your question."
+
+
+        else:
+            # If no search is needed, return a default or simple response
+            print("Question does not appear to require search. Returning fixed answer.")
+            fixed_answer = "How can I help you?"
+            return fixed_answer
 
 
 def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modified to accept 2 arguments
@@ -410,7 +256,6 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
     # 1. Instantiate Agent ( modify this part to create your agent)
     print("Attempting to instantiate BasicAgent...") # Debugging print before instantiation
     try:
-        # The error occurs when trying to *call* this instantiated object
         agent = BasicAgent()
         print("BasicAgent instantiated successfully.") # Debugging print after instantiation
     except Exception as e:
@@ -462,7 +307,6 @@ def run_and_submit_all( profile: gr.OAuthProfile | None, other_arg=None): # Modi
             continue
         print(f"Processing Task ID: {task_id}") # Debugging task ID
         try:
-            # Error occurs here: 'BasicAgent' object is not callable
             submitted_answer = agent(question_text)
             print(f"Agent returned answer for {task_id}: {submitted_answer[:50]}...") # Debugging returned answer
             answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
@@ -563,4 +407,5 @@ with gr.Blocks(theme=gr.themes.Soft(), title="Basic Agent Evaluation Runner") as
     )
 
 # Ensure the app launches when the script is run
-demo.launch(server_name="0.0.0.0") # Ensure binding to all interfaces
+if __name__ == "__main__":
+    demo.launch(server_name="0.0.0.0") # Ensure binding to all interfaces