use google gemini

app.py

@@ -1,272 +1,82 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
-from core_agent import GAIAAgent
-
-# Debug function to show available environment variables
-def debug_environment():
-    """Print available environment variables related to API keys (with values hidden)"""
-    debug_vars = [
-        "HF_API_TOKEN", "HUGGINGFACEHUB_API_TOKEN", 
-        "OPENAI_API_KEY", "XAI_API_KEY",
-        "AGENT_MODEL_TYPE", "AGENT_MODEL_ID", 
-        "AGENT_TEMPERATURE", "AGENT_VERBOSE"
-    ]
-    
-    print("=== DEBUG: Environment Variables ===")
-    for var in debug_vars:
-        if os.environ.get(var):
-            # Hide actual values for security
-            print(f"{var}: [SET]")
-        else:
-            print(f"{var}: [NOT SET]")
-    print("===================================")
+from my_agent import GeminiAgentContainer
+from markdownify import markdownify as to_markdown
+import time
+import json
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
-# --- Basic Agent Definition ---
-# ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
-class BasicAgent:
-    def __init__(self):
-        print("BasicAgent initialized.")
-        
-        # Call debug function to show available environment variables
-        debug_environment()
-        
-        # Initialize the GAIAAgent with local execution
-        try:
-            # Load environment variables if dotenv is available
-            try:
-                import dotenv
-                dotenv.load_dotenv()
-                print("Loaded environment variables from .env file")
-            except ImportError:
-                print("python-dotenv not installed, continuing with environment as is")
-            
-            # Try to load API keys from environment
-            # Check both HF_API_TOKEN and HUGGINGFACEHUB_API_TOKEN (HF Spaces uses HF_API_TOKEN)
-            hf_token = os.environ.get("HF_API_TOKEN") or os.environ.get("HUGGINGFACEHUB_API_TOKEN")
-            openai_key = os.environ.get("OPENAI_API_KEY")
-            xai_key = os.environ.get("XAI_API_KEY")
-            
-            # If we have at least one API key, use a model-based approach
-            if hf_token or openai_key or xai_key:
-                # Default model parameters - read directly from environment
-                model_type = os.environ.get("AGENT_MODEL_TYPE", "OpenAIServerModel")
-                model_id = os.environ.get("AGENT_MODEL_ID", "gpt-4o")
-                temperature = float(os.environ.get("AGENT_TEMPERATURE", "0.2"))
-                verbose = os.environ.get("AGENT_VERBOSE", "false").lower() == "true"
-                
-                print(f"Agent config - Model Type: {model_type}, Model ID: {model_id}")
-                
-                try:
-                    if xai_key:
-                        # Use X.AI API with OpenAIServerModel
-                        api_base = os.environ.get("XAI_API_BASE", "https://api.x.ai/v1")
-                        self.gaia_agent = GAIAAgent(
-                            model_type="OpenAIServerModel",
-                            model_id="grok-3-latest",  # X.AI's model
-                            api_key=xai_key,
-                            api_base=api_base,
-                            temperature=temperature,
-                            executor_type="local",
-                            verbose=verbose
-                        )
-                        print(f"Using OpenAIServerModel with X.AI API at {api_base}")
-                    elif model_type == "HfApiModel" and hf_token:
-                        # Use Hugging Face API
-                        self.gaia_agent = GAIAAgent(
-                            model_type="HfApiModel",
-                            model_id=model_id,
-                            api_key=hf_token,
-                            temperature=temperature,
-                            executor_type="local",
-                            verbose=verbose
-                        )
-                        print(f"Using HfApiModel with model_id: {model_id}")
-                    elif openai_key:
-                        # Default to OpenAI API
-                        api_base = os.environ.get("AGENT_API_BASE")
-                        kwargs = {
-                            "model_type": "OpenAIServerModel",
-                            "model_id": model_id,
-                            "api_key": openai_key,
-                            "temperature": temperature,
-                            "executor_type": "local",
-                            "verbose": verbose
-                        }
-                        if api_base:
-                            kwargs["api_base"] = api_base
-                            print(f"Using custom API base: {api_base}")
-                        
-                        self.gaia_agent = GAIAAgent(**kwargs)
-                        print(f"Using OpenAIServerModel with model_id: {model_id}")
-                    else:
-                        # Fallback to using whatever token we have
-                        print("WARNING: Using fallback initialization with available token")
-                        if hf_token:
-                            self.gaia_agent = GAIAAgent(
-                                model_type="HfApiModel",
-                                model_id="mistralai/Mistral-7B-Instruct-v0.2",
-                                api_key=hf_token,
-                                temperature=temperature,
-                                executor_type="local",
-                                verbose=verbose
-                            )
-                        elif openai_key:
-                            self.gaia_agent = GAIAAgent(
-                                model_type="OpenAIServerModel",
-                                model_id="gpt-3.5-turbo",
-                                api_key=openai_key,
-                                temperature=temperature,
-                                executor_type="local",
-                                verbose=verbose
-                            )
-                        else:
-                            self.gaia_agent = GAIAAgent(
-                                model_type="OpenAIServerModel",
-                                model_id="grok-3-latest",
-                                api_key=xai_key,
-                                api_base=os.environ.get("XAI_API_BASE", "https://api.x.ai/v1"),
-                                temperature=temperature,
-                                executor_type="local",
-                                verbose=verbose
-                            )
-                except ImportError as ie:
-                    # Handle OpenAI module errors specifically
-                    if "openai" in str(ie).lower() and hf_token:
-                        print(f"OpenAI module error: {ie}. Falling back to HfApiModel.")
-                        self.gaia_agent = GAIAAgent(
-                            model_type="HfApiModel",
-                            model_id="mistralai/Mistral-7B-Instruct-v0.2",
-                            api_key=hf_token,
-                            temperature=temperature,
-                            executor_type="local",
-                            verbose=verbose
-                        )
-                        print(f"Using HfApiModel with model_id: mistralai/Mistral-7B-Instruct-v0.2 (fallback)")
-                    else:
-                        raise
-            else:
-                # No API keys available, log the error
-                print("ERROR: No API keys found. Please set at least one of these environment variables:")
-                print("- HUGGINGFACEHUB_API_TOKEN or HF_API_TOKEN")
-                print("- OPENAI_API_KEY")
-                print("- XAI_API_KEY")
-                self.gaia_agent = None
-                print("WARNING: No API keys found. Agent will not be able to answer questions.")
-                
-        except Exception as e:
-            print(f"Error initializing GAIAAgent: {e}")
-            self.gaia_agent = None
-            print("WARNING: Failed to initialize agent. Falling back to basic responses.")
-            
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        
-        # Check if we have a functioning GAIA agent
-        if self.gaia_agent:
-            try:
-                # Process the question using the GAIA agent
-                answer = self.gaia_agent.answer_question(question)
-                print(f"Agent generated answer: {answer[:50]}..." if len(answer) > 50 else f"Agent generated answer: {answer}")
-                return answer
-            except Exception as e:
-                print(f"Error processing question: {e}")
-                # Fall back to a simple response on error
-                return "An error occurred while processing your question. Please check the agent logs for details."
-        else:
-            # We don't have a valid agent, provide a basic response
-            return "The agent is not properly initialized. Please check your API keys and configuration."
-
-def run_and_submit_all( profile: gr.OAuthProfile | None):
-    """
-    Fetches all questions, runs the BasicAgent on them, submits all answers,
-    and displays the results.
-    """
-    # --- Determine HF Space Runtime URL and Repo URL ---
-    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
-    if profile:
-        username= f"{profile.username}"
-        print(f"User logged in: {username}")
-    else:
-        print("User not logged in.")
-        return "Please Login to Hugging Face with the button.", None
-
-    api_url = DEFAULT_API_URL
-    questions_url = f"{api_url}/questions"
-    submit_url = f"{api_url}/submit"
+# --- Global Variables ---
+questions = None
+results_log = []
+answers_by_task = {}
 
-    # 1. Instantiate Agent ( modify this part to create your agent)
-    try:
-        agent = BasicAgent()
-        
-        # Check if agent is properly initialized
-        if not agent.gaia_agent:
-            print("ERROR: Agent was not properly initialized")
-            return "ERROR: Agent was not properly initialized. Check the logs for details on missing API keys or configuration.", None
-        
-    except Exception as e:
-        print(f"Error instantiating agent: {e}")
-        return f"Error initializing agent: {e}", None
-    # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
-    agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
-    print(agent_code)
-
-    # 2. Fetch Questions
+def load_questions(questions_url):
     print(f"Fetching questions from: {questions_url}")
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
         questions_data = response.json()
         if not questions_data:
-             print("Fetched questions list is empty.")
-             return "Fetched questions list is empty or invalid format.", None
+             print("Fetched questions list is empty or invalid.")
+             return None
         print(f"Fetched {len(questions_data)} questions.")
     except requests.exceptions.RequestException as e:
         print(f"Error fetching questions: {e}")
-        return f"Error fetching questions: {e}", None
+        return None
     except requests.exceptions.JSONDecodeError as e:
          print(f"Error decoding JSON response from questions endpoint: {e}")
          print(f"Response text: {response.text[:500]}")
-         return f"Error decoding server response for questions: {e}", None
+         return None
     except Exception as e:
         print(f"An unexpected error occurred fetching questions: {e}")
-        return f"An unexpected error occurred fetching questions: {e}", None
+        return None
+    return questions_data
 
-    # 3. Run your Agent
-    results_log = []
-    answers_payload = []
-    print(f"Running agent on {len(questions_data)} questions...")
-    for item in questions_data:
-        task_id = item.get("task_id")
-        question_text = item.get("question")
+def answer_one(agent, question_data):
+    """
+    Runs the agent on a single question and returns the result.
+    """
+    task_id = question_data.get("task_id")
+    question_text = question_data.get("question")
+    filename = question_data.get("file_name")
+    payload = None
+    submitted_answer = None
+    agent_error = None
+
+    try:
         if not task_id or question_text is None:
-            print(f"Skipping item with missing task_id or question: {item}")
-            continue
-        try:
-            submitted_answer = agent(question_text)
-            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer})
-            results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": submitted_answer})
-        except Exception as e:
-             print(f"Error running agent on task {task_id}: {e}")
-             results_log.append({"Task ID": task_id, "Question": question_text, "Submitted Answer": f"AGENT ERROR: {e}"})
-
-    if not answers_payload:
-        print("Agent did not produce any answers to submit.")
-        return "Agent did not produce any answers to submit.", pd.DataFrame(results_log)
-
-    # 4. Prepare Submission 
+            raise ValueError(f"Missing task_id or question in item: {question_data}")
+        if filename:
+            file_prompt = f"\nThere is an attached file with task id `{task_id}` available.\n"
+            question_text = file_prompt + question_text
+        submitted_answer = agent(question_text)
+        payload = {"task_id": task_id, "submitted_answer": submitted_answer}
+    except Exception as e:
+         print(agent)
+         print(f"Error running agent on task {task_id}: {e}")
+         agent_error = f"AGENT ERROR: {e}"
+    finally:
+        log_entry = {
+            "Task ID": task_id,
+            "Question": question_text,
+            "Submitted Answer": submitted_answer or agent_error,
+        }
+        return payload, log_entry    
+    
+def _submit_all(username, agent_code, answers_payload, submit_url):
+    # Prepare Submission 
     submission_data = {"username": username.strip(), "agent_code": agent_code, "answers": answers_payload}
-    status_update = f"Agent finished. Submitting {len(answers_payload)} answers for user '{username}'..."
+    status_update = f"Submitting {len(answers_payload)} answers for user '{username}'..."
     print(status_update)
 
-    # 5. Submit
+    # Submit Answers
     print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
     try:
         response = requests.post(submit_url, json=submission_data, timeout=60)
@@ -279,9 +89,8 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             f"({result_data.get('correct_count', '?')}/{result_data.get('total_attempted', '?')} correct)\n"
             f"Message: {result_data.get('message', 'No message received.')}"
         )
-        print("Submission successful.")
-        results_df = pd.DataFrame(results_log)
-        return final_status, results_df
+        print(final_status)
+        return final_status
     except requests.exceptions.HTTPError as e:
         error_detail = f"Server responded with status {e.response.status_code}."
         try:
@@ -291,23 +100,104 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             error_detail += f" Response: {e.response.text[:500]}"
         status_message = f"Submission Failed: {error_detail}"
         print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return status_message
     except requests.exceptions.Timeout:
         status_message = "Submission Failed: The request timed out."
         print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return status_message
     except requests.exceptions.RequestException as e:
         status_message = f"Submission Failed: Network error - {e}"
         print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return status_message
     except Exception as e:
         status_message = f"An unexpected error occurred during submission: {e}"
         print(status_message)
-        results_df = pd.DataFrame(results_log)
-        return status_message, results_df
+        return status_message
+
+    
+def prepare_agent(api_key=None):  
+    # 1. Instantiate Agent ( modify this part to create your agent)
+    try:
+        agent = GeminiAgentContainer(api_key=api_key)
+        print(agent.system_prompt)
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return None
+    
+    return agent
+
+def save_answers_to_file():
+    """
+    Submits the answers to a local file named with the current epoch time.
+    """
+    if not answers_by_task:
+        return ("Nothing to save, no answers found.")
+    answers_payload = list(answers_by_task.values())
+
+    file_path = f"answers-{int(time.time())}.json"
+    print(f"Saving answers to file: {file_path}")
+    try:
+        with open(file_path, "w") as file:
+            json.dump(answers_payload, file, indent=4)
+        submit_status = (f"Answers successfully written to {file_path}")
+    except Exception as e:
+        submit_status = (f"Error writing answers to file: {e}")
+    print(submit_status)
+    return submit_status
+
+
+def run_all(api_key: str | None = None):
+    """
+    Fetches all questions, runs the BasicAgent on them,
+    """
+    
+    questions_url = f"{DEFAULT_API_URL}/questions"
+
+    agent = prepare_agent(api_key)
+
+    questions_data = load_questions(questions_url)
+    # 3. Run your Agent
+    
+    print(f"Running agent on {len(questions_data)} questions...")
+    for item in questions_data:
+        payload_data, log_entry = answer_one(agent, item)
+        if payload_data:
+            task_id = payload_data.get("task_id")
+            answers_by_task[task_id] = payload_data
+        results_log.append(log_entry)
+        time.sleep(1)
+    if not answers_by_task:
+        final_status = "Agent did not produce any answers to submit."
+    else:
+        final_status = f"Agent finished, {len(answers_by_task)} answers produced."
+    print(final_status)
+    return final_status, pd.DataFrame(results_log)
+
+def submit_all( profile: gr.OAuthProfile | None):
+    """
+    Submits all answers and displays the results.
+    """
+    submit_url = f"{DEFAULT_API_URL}/submit"
+
+    if profile:
+        username= f"{profile.username}"
+        print(f"User logged in: {username}")
+    else:
+        print("User not logged in.")
+        return "Please Login to Hugging Face with the button."
+    # --- Determine HF Space Runtime URL and Repo URL ---
+    space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
+
+    if not answers_by_task:
+        submit_status = "No answers to submit."
+    else:
+        # 4. Submit all answers
+        # In the case of an app running as a hugging Face space, this link points toward your codebase ( usefull for others so please keep it public)
+        agent_code = f"https://huggingface.co/spaces/{space_id}/tree/main"
+
+        submit_status = _submit_all(username, agent_code, list(answers_by_task.values()), submit_url)
+
+    return submit_status
 
 
 # --- Build Gradio Interface using Blocks ---
@@ -317,30 +207,45 @@ with gr.Blocks() as demo:
         """
         **Instructions:**
 
-        1.  Please clone this space, then modify the code to define your agent's logic, the tools, the necessary packages, etc ...
-        2.  Log in to your Hugging Face account using the button below. This uses your HF username for submission.
-        3.  Click 'Run Evaluation & Submit All Answers' to fetch questions, run your agent, submit answers, and see the score.
-
-        ---
-        **Disclaimers:**
-        Once clicking on the "submit button, it can take quite some time ( this is the time for the agent to go through all the questions).
-        This space provides a basic setup and is intentionally sub-optimal to encourage you to develop your own, more robust solution. For instance for the delay process of the submit button, a solution could be to cache the answers and submit in a seperate action or even to answer the questions in async.
-        """
+        1.  Please use your own Gemini API key to run the agent. You can find your API key in your [Gemini account settings](https://gemini.com/account/settings).
+        2.  Click 'Run Evaluation' to fetch questions, run the agent, and see the answers.
+        3.  Click 'Submit All Answers' to submit the answers to the server.
+       """
     )
 
     gr.LoginButton()
 
-    run_button = gr.Button("Run Evaluation & Submit All Answers")
+    api_key_input = gr.Textbox(
+        label="Gemini API Key",
+        placeholder="Enter your Gemini API key here",
+        type="password",
+        lines=1,
+        visible=True
+    )
+
+    run_button = gr.Button("Run Evaluation")
+    save_button = gr.Button("Save Answers to File")
+    submit_button = gr.Button("Submit All Answers")
 
     status_output = gr.Textbox(label="Run Status / Submission Result", lines=5, interactive=False)
-    # Removed max_rows=10 from DataFrame constructor
     results_table = gr.DataFrame(label="Questions and Agent Answers", wrap=True)
 
     run_button.click(
-        fn=run_and_submit_all,
+        fn=run_all,
+        inputs=[api_key_input],
         outputs=[status_output, results_table]
     )
 
+    save_button.click(
+        fn=save_answers_to_file,
+        outputs=[status_output]
+    )
+
+    submit_button.click(
+        fn=submit_all,
+        outputs=[status_output]
+    )
+
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
     # Check for SPACE_HOST and SPACE_ID at startup for information
@@ -359,6 +264,7 @@ if __name__ == "__main__":
         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(f"API KEY: {os.getenv('GOOGLE_API_KEY')}")
 
     print("-"*(60 + len(" App Starting ")) + "\n")
 

my_agent.py

@@ -0,0 +1,242 @@
+import os
+import requests
+from smolagents import LiteLLMModel, ToolCallingAgent, Tool
+from typing import Optional
+from google import genai
+from google.genai import types
+import wikipedia as wiki
+from markdownify import markdownify as to_markdown
+
+# --- Tools ---
+
+class VideoWatchingTool(Tool):
+    name = "watch_video"
+    description ="""
+    A tool for watching videos and answering questions about them.
+    """
+    inputs = {
+        "video_url": {
+            "type": "string",
+            "description": "The URL of the video to watch."
+        },
+        "user_query": {
+            "type": "string",
+            "description": "The question to answer about the video."
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, model_name, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.model_name = model_name
+
+    def forward(self, video_url: str, user_query: str) -> str:
+        request_json = {
+        'model': f'models/{self.model_name}',
+        'contents': [{
+            "parts": [
+                {
+                    'fileData': {
+                        'fileUri': video_url
+                    }
+                },
+                {
+                    'text': f"Please watch the video and answer the following question: {user_query}"
+                }
+            ]
+        }]
+    }
+        api_url = f'https://generativelanguage.googleapis.com/v1beta/models/{self.model_name}:generateContent?key={os.getenv("GOOGLE_API_KEY")}'
+        response = requests.post(
+            api_url, 
+            json=request_json,
+            headers={
+                'Content-Type': 'application/json',
+            }
+        )
+        if response.status_code != 200:
+            return f"Error: {response.status_code} - {response.text}"
+        response_json = response.json()
+        result_parts = response_json['candidates'][0]['content']['parts']
+        result = "".join([_.get('text', '') for _ in result_parts])
+        return result
+    
+class GoogleSearchTool(Tool):
+    name = "google_search"
+    description = """
+    Performs a Google search and returns the results.
+    """
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The search query."
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, client, model_name, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.client = client
+        self.model_name = model_name
+
+    def forward(self, query: str) -> str:
+        google_search_tool = types.Tool(
+            google_search=types.GoogleSearch()
+        )
+        response = self.client.models.generate_content(
+        model=self.model_name,
+        contents=f"Please search the internet for: {query}",
+        config=types.GenerateContentConfig(
+            tools=[google_search_tool],
+            response_modalities=['TEXT'],
+            )
+        )
+        return response.text
+    
+class WikipediaTitleSearchTool(Tool):
+    name = "check_wikipedia_page_titles"
+    description = """
+    Searches for Wikipedia pages related to the query and returns the canonical titles of the related pages.
+    """
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The search query."
+        }
+    }
+    output_type = "string"
+
+    def forward(self, query: str) -> str:
+        response = wiki.search(query)
+        if len(response) > 0:
+            result = ", ".join(response)
+        else:
+            result = "No results found."
+        return result
+
+class WikipediaPageTool(Tool):
+    name = "get_wikipedia_page"
+    description = """
+    Gets the content of a Wikipedia page.
+    """
+    inputs = {
+        "page_title": {
+            "type": "string",
+            "description": "The canonical title of the Wikipedia page."
+        }
+    }
+    output_type = "string"
+    
+    def forward(self, page_title: str) -> str:
+        # TODO: may need to do caching of the HTML ourselves?
+        try:
+            page = wiki.page(page_title)
+        except wiki.exceptions.PageError:
+            return f"Page '{page_title}' not found."
+        md_content = to_markdown(page.html())
+        return md_content
+   
+class FileAttachmentQueryTool(Tool):
+    name = "run_query_with_file"
+    description = """
+    Downloads a file mentioned in a user prompt, adds it to the context, and runs a query on it.
+    This assumes the file is 20MB or less.
+    """
+    inputs = {
+        "task_id": {
+            "type": "string",
+            "description": "A unique identifier for the task related to this file, used to download it."
+        },
+        "mime_type": {
+            "type": "string",
+            "nullable": True,
+            "description": "The MIME type of the file, or the best guess if unknown."
+        },
+        "user_query": {
+            "type": "string",
+            "description": "The question to answer about the file."
+        }
+    }
+    output_type = "string"
+    def __init__(self, client, model_name, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+        self.client = client
+        self.model_name = model_name
+    
+    def forward(self, task_id: str, mime_type: str | None, user_query: str) -> str:
+        # Download the file
+        file_url = f"https://agents-course-unit4-scoring.hf.space/files/{task_id}"
+        file_response = requests.get(file_url)
+        if file_response.status_code != 200:
+            raise Exception(f"Failed to download file: {file_response.status_code} - {file_response.text}")
+        file_data = file_response.content
+        mime_type = mime_type or file_response.headers.get('Content-Type', 'application/octet-stream')
+        response = self.client.models.generate_content(
+            model=self.model_name,
+            contents=[
+                types.Part.from_bytes(
+                    data=file_data,
+                    mime_type=mime_type,
+                ),
+                user_query,
+            ]
+        )
+
+        return response.text
+    
+# --- Agent Management ---
+
+class GeminiAgentContainer:
+    """
+    A container for the Gemini agent.
+    """
+    # TODO: make it easier to chnge the model
+    MODEL_NAME = "gemini-2.0-flash"
+
+    def __init__(self, api_key: Optional[str] = None):
+        api_key = api_key or os.getenv("GOOGLE_API_KEY")
+        self.model = LiteLLMModel(model_id=f"gemini/{self.MODEL_NAME}", api_key=api_key)
+        self.client = genai.Client(api_key=os.getenv("GOOGLE_API_KEY"))
+        system_prompt = """
+            You are a general AI assistant. I will ask you a question. 
+            YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. 
+            If your answer is a number and you are not explicitly asked for a string, write it in numerals instead of words, and don't use comma to write your number nor use units such as $ or percent sign unless specified otherwise. 
+            If you are asked for a string, don't use articles, neither abbreviations (e.g. for cities), and write the digits in plain text unless specified otherwise. 
+            If you are asked for a comma separated list, apply the above rules depending of whether the element to be put in the list is a number or a string.
+
+            Answer questions as literally as you can, making as few assumptions as possible. Restrict the answer to the narrowest definition that still satifies the question.
+            If you are provied with a video, please watch and summarize the entire video before answering the question. The correct answer may be present only in a few frames of the video.
+            If you have difficulty finding an answer on Wikipedia, you may search the internet using Google Search.
+            If you are asked to prove something, first state your assumptions and think step by step before giving your final answer.
+
+        """
+
+        self.agent = ToolCallingAgent(
+            model=self.model, 
+            tools = [
+                VideoWatchingTool(model_name=self.MODEL_NAME),
+                GoogleSearchTool(client=self.client, model_name=self.MODEL_NAME),
+                WikipediaTitleSearchTool(),
+                WikipediaPageTool(),
+                FileAttachmentQueryTool(client=self.client, model_name=self.MODEL_NAME),
+                ], 
+            max_steps=14,
+            planning_interval=2,
+        )
+        self.system_prompt = system_prompt
+
+
+    def __call__(self, question: str) -> str:
+        response = self.agent.run(f"{self.system_prompt}\n{question}")
+        return response
+    
+if __name__ == "__main__":
+    agent_container = GeminiAgentContainer()
+    agent = agent_container.agent
+    #my_query = "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia."
+    #my_query = "In the video https://www.youtube.com/watch?v=L1vXCYZAYYM, what is the highest number of bird species to be on camera simultaneously?"
+    my_query= "Examine the video at https://www.youtube.com/watch?v=1htKBjuUWec.\n\nWhat does Teal'c say in response to the question \"Isn't that hot?\""
+    response = agent.run(agent_container.system_prompt+my_query, max_steps=5)
+    print(response)
+    #print(my_query)
+

requirements.txt

@@ -1,8 +1,9 @@
 gradio
 requests
-smolagents[openai]
-python-dotenv
-pandas
-numpy
-openai
+smolagents[litellm]
+gradio[oauth]
+google-api-python-client
+google-genai
+wikipedia
+markdownify