Upload 2 files

agents.py

@@ -0,0 +1,224 @@
+import os
+from smolagents import CodeAgent, LiteLLMModel, load_tool, ToolCollection, HfApiModel, InferenceClientModel, TransformersModel, OpenAIServerModel
+from smolagents import ToolCallingAgent, PythonInterpreterTool, tool, WikipediaSearchTool
+from smolagents import DuckDuckGoSearchTool, FinalAnswerTool, VisitWebpageTool, SpeechToTextTool
+from mcp import StdioServerParameters
+from huggingface_hub import HfApi, login
+from dotenv import load_dotenv
+from typing import Optional
+from models.gemini_model import GeminiModel
+import requests
+import re
+import string
+import random
+import textwrap
+import nltk
+import spacy
+
+DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+
+
+@tool
+def download_file(task_id: str) -> str:
+    """
+    Returns the file path of the downloaded file.
+
+    Args:
+        task_id: the ID of the task to download the file for.
+    """
+    # Implement your file download logic here
+    data = requests.get(f"{DEFAULT_API_URL}/files/{task_id}")
+    if data.status_code == 200:
+        file_path = f"/tmp/{task_id}"
+        with open(file_path, "wb") as file:
+            file.write(data.content)
+        return file_path
+    else:
+        raise Exception(f"Failed to download file: {data.status_code}")
+
+@tool  
+def get_file_content_as_text(task_id: str) -> str:
+    """
+    Returns the content of the file as text.
+
+    Args:
+        task_id: the ID of the task to get the file content for.
+    """
+    # Implement your file content retrieval logic here
+    data = requests.get(f"{DEFAULT_API_URL}/files/{task_id}")
+    if data.status_code == 200:
+        return data.text
+    else:
+        raise Exception(f"Failed to get file content: {data.status_code}")
+
+
+
+def load_hf_model(modelName: str):
+    """
+    Lädt ein Hugging Face Modell und gibt den Agenten zurück.
+    :param modelName: Name des Modells
+    :return: model
+    """
+    load_dotenv()  # Lädt automatisch .env im Projektordner
+
+    hf_token = os.getenv("hugging_face")
+    login(token=hf_token)  # Authentifizierung bei Hugging Face
+    # Modell initialisieren
+    model = HfApiModel(model_id=modelName)
+    return model
+
+
+def load_ollama_model(modelName: str):
+    """
+    Lädt ein Ollama Modell und gibt den Agenten zurück.
+    :param modelName: Name des Modells
+    :return: model
+    """
+    # Modell initialisieren
+    model = OpenAIServerModel(model_id=modelName, api_base="http://localhost:11434/v1")
+    return model
+
+def load_lmStudio_model(modelName: str):
+    """
+    Lädt ein LM Studio Modell und gibt den Agenten zurück.
+    :param modelName: Name des Modells
+    :return: model 
+    """
+    # Modell initialisieren
+    #model = LiteLLMModel(model_id=modelName, api_base="http://localhost:1234")
+    model = OpenAIServerModel(model_id=modelName, api_base="http://localhost:1234/v1")
+    return model
+
+def load_gemini_model():
+    """
+    Lädt ein Gemini Modell und gibt den Agenten zurück.
+    :return: model
+    """
+    try:
+        print(f"Gemini API Key: {os.getenv('GEMINI_API_KEY')}")
+        model = LiteLLMModel(model_id="gemini/gemini-2.0-flash-exp",
+                         api_key=os.getenv("GEMINI_API_KEY"))
+        #model = GeminiModel(api_key=os.getenv("GEMINI_API_KEY"))
+        return model
+    except Exception as e:
+        print("Error loading Gemini model:", e)
+        return None
+
+
+
+def get_agent(model_name:str, model_type:str) -> Optional[CodeAgent]:
+    # Modell initialisieren
+    
+    match model_type:
+        case "hugging face":
+            model = load_hf_model(model_name)
+        case "Ollama":
+            model = load_ollama_model(model_name)
+        case "Gemini":
+            model = load_gemini_model()
+        case "LMStudio":
+            model = load_lmStudio_model(model_name)
+        case _:
+            print("Model type not supported.")
+            return None
+    
+    #model = load_lmStudio_model("gemma-3-4b-it")
+    #model = load_gemini_model()
+    #mopip del = HfApiModel()
+    #model=InferenceClientModel(model_id="meta-llama/Meta-Llama-3.1-8B-Instruct")
+    #model = TransformersModel(model_id="HuggingFaceTB/SmolLM-135M-Instruct")
+    # Tools laden
+    web_search_tool = DuckDuckGoSearchTool()
+    final_answer_tool = FinalAnswerTool()
+    visit_webpage_tool = VisitWebpageTool()
+    
+    #speech_to_text_tool = SpeechToTextTool()
+    #transcript_tool = load_tool("maguid28/TranscriptTool", trust_remote_code=True)
+
+    #mcp_tool_collection = ToolCollection.from_mcp(server_parameters, trust_remote_code=True)
+    #with ToolCollection.from_mcp(server_parameters, trust_remote_code=True) as tool_collection:
+    #    mcp_tool_agent = CodeAgent(tools=[*tool_collection.tools], add_base_tools=True)
+
+    #server_parameters = StdioServerParameters(
+    #    command="uv",
+    #    args=["--quiet", "pubmedmcp@0.1.3"],
+    #    env={"UV_PYTHON": "3.12", **os.environ},
+    #)
+    #
+    #with ToolCollection.from_mcp(server_parameters, trust_remote_code=True) as tool_collection:
+    #    mcp_agent = CodeAgent(tools=[*tool_collection.tools], model=model, add_base_tools=True)
+
+    variation_agent = CodeAgent(
+        model=model,
+        tools=[PythonInterpreterTool()],
+        name="variation_agent",
+        description="Get the user question and checks if the given question makes sense at all, if not, we try to modify the text like reverse. Provide the content / the questin as the 'task' argument." \
+        "The agent can write professional python code, focused on modifiying texts." \
+        "It has access to the following libraries: re, string, random, textwrap, nltk and spacy." \
+        "The goal is to find out, if a user question is a trick, and we might modify the content.",
+        additional_authorized_imports=[
+            "re",
+            "string",
+            "random",
+            "textwrap",
+            "nltk",
+            "spacy"
+        ]
+        )
+    variation_agent.system_prompt = "You are a text variation agent. You can write professional python code, focused on modifiying texts." \
+    "You can use the following libraries: re, string, random, textwrap, nltk and spacy." \
+    "Your goal is to find out, if a user question is a trick, and we might modify the content."
+
+    code_agent = CodeAgent(
+        name="code_agent",
+        description="Can generate code an run it. It provides the possibility to download additional files if needed.",
+        model=model,
+        tools=[download_file, PythonInterpreterTool(), get_file_content_as_text],
+        additional_authorized_imports=[
+            "geopandas",
+            "plotly",
+            "shapely",
+            "json",
+            "pandas",
+            "numpy",
+        ],
+        verbosity_level=2,
+        #final_answer_checks=[FinalAnswerTool()],
+        max_steps=5,
+    )
+
+    final_answer_tool = FinalAnswerTool()
+    final_answer_tool.description = "You are a general AI assistant. I will ask you a question. Report your thoughts, and finish your answer with the following template: FINAL ANSWER: [YOUR FINAL ANSWER]. YOUR FINAL ANSWER should be a number OR as few words as possible OR a comma separated list of numbers and/or strings. If you are asked for a number, don't use comma to write your number neither 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."
+
+    tool_agent = CodeAgent(
+        model=model,
+        tools=[web_search_tool, visit_webpage_tool, WikipediaSearchTool(), final_answer_tool],
+        verbosity_level=2,
+        max_steps=15,
+        managed_agents=[code_agent, variation_agent],
+        planning_interval=5,
+    )
+
+    return tool_agent
+#    return tool_agent
+
+    manager_agent = CodeAgent(
+        #model=HfApiModel("deepseek-ai/DeepSeek-R1", provider="together", max_tokens=8096),
+        model=model,
+        tools=[web_search_tool, visit_webpage_tool],
+#        managed_agents=[mcp_tool_agent],
+        additional_authorized_imports=[
+            "geopandas",
+            "plotly",
+            "shapely",
+            "json",
+            "pandas",
+            "numpy",
+        ],
+        planning_interval=5,
+        verbosity_level=2,
+        #final_answer_checks=[FinalAnswerTool()],
+        max_steps=15
+    )
+    
+    return manager_agent

app.py

@@ -3,11 +3,60 @@ import gradio as gr
 import requests
 import inspect
 import pandas as pd
+from agents import agents
+from PIL import Image
+from io import BytesIO
+import whisper
 
 # (Keep Constants as is)
 # --- Constants ---
 DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
 
+# --- Load Agent ---
+# 1. Instantiate Agent ( modify this part to create your agent)
+
+agent = None
+
+def select_agent(provider_name:str, model_name: str):
+    """
+    Selects the agent based on the provided name.
+    :param agent_name: Name of the agent to select.
+    :return: The selected agent instance.
+    """
+    global agent
+    try:
+        agent = agents.get_agent(model_name=model_name, model_type=provider_name)
+        if agent is None:
+            print(f"Agent not found for provider: {provider_name} and model: {model_name}")
+            agent = BasicAgent()
+    except Exception as e:
+        print(f"Error selecting agent: {e}")
+        agent = BasicAgent()
+    # Update ui to indicate the selected agent
+    print(f"Agent selected: {agent.model}")
+    agent_info_text.value = get_agent_info()
+    return agent
+
+
+def get_agent_info() -> str:
+    global agent
+    if (agent is None):
+        return "No agent selected."
+    try:
+        # Get the agent's class name
+        agent_class_name = agent.__class__.__name__
+        # Get the agent's model name
+        model_name = agent.model
+        # Get the agent's docstring
+        docstring = inspect.getdoc(agent)
+        # Format the information
+        info = f"Agent Class: {agent_class_name}\nModel Name: {model_name}\nDocstring: {docstring}"
+        return info
+    except Exception as e:
+        print(f"Error getting agent info: {e}")
+        return "Error getting agent info."
+
+
 # --- Basic Agent Definition ---
 # ----- THIS IS WERE YOU CAN BUILD WHAT YOU WANT ------
 class BasicAgent:
@@ -19,11 +68,135 @@ class BasicAgent:
         print(f"Agent returning fixed answer: {fixed_answer}")
         return fixed_answer
 
+
+def get_all_questions():
+    """
+    Fetches all available questions from the API.
+    """
+    yield from run_test_on_questions(False, False)
+
+def run_test_on_all_questions():
+    """
+    Runs tests on all available questions by forwarding yields from run_test_on_questions.
+    """
+    yield from run_test_on_questions(False, True)
+
+def run_test_on_random_question():
+    """
+    Runs a single test on a random available question by forwarding yields from run_test_on_questions.
+    """
+    yield from run_test_on_questions(True, True)
+
+
+def run_test_on_questions(use_random_question: bool, run_agent:bool):
+    """
+    Fetches all questions, runs the BasicAgent on them, submits all answers,
+    and displays the results.
+    """
+
+    global agent
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/random-question" if use_random_question else f"{api_url}/questions"
+
+
+    # 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)
+    info = "# started request"
+    yield info, None
+    # 2. Fetch Questions
+    print(f"Fetching questions from: {questions_url}")
+    try:
+        response = requests.get(questions_url, timeout=15)
+        response.raise_for_status()
+        questions_dataset_raw = response.json()
+        questions_dataset = [questions_dataset_raw] if use_random_question else questions_dataset_raw
+        yield info, None
+        if not questions_dataset:
+             print("Fetched questions list is empty.")
+             yield info +"\n\nFetched questions list is empty or invalid format.", None
+             return
+        print(f"Fetched {len(questions_dataset)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        yield f"Error fetching questions: {e}", None
+        return
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         yield f"Error decoding server response for questions: {e}", None
+         return
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        yield f"An unexpected error occurred fetching questions: {e}", None
+        return
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    # loop over all questions
+    for i, questions_data in enumerate(questions_dataset):
+
+        agent.memory.reset()
+        images = []
+        task_id = questions_data.get("task_id")
+        question_text = questions_data.get("question")
+        file_name = questions_data.get("file_name")
+        if (file_name != "" and file_name is not None):
+            question_text = question_text + f"\n\nYou can download the correspondig file using the download tool with the task id: {task_id}."
+            fileData = requests.get(f"{DEFAULT_API_URL}/files/{task_id}")
+            # check if file is an image
+            if fileData.headers['Content-Type'] in ['image/png', 'image/jpeg']:
+                image = Image.open(BytesIO(fileData.content)).convert("RGB")
+                images = [image]
+            if fileData.headers['Content-Type'] in ['audio/mpeg', 'audio/wav']:
+                # Load the audio file using Whisper
+                model = whisper.load_model("base")
+                # MP3-Datei von der API abrufen
+                with open("temp_audio.mp3", "wb") as f:
+                    f.write(fileData.content)
+
+                # Transkription durchführen
+                audioContent = model.transcribe("temp_audio.mp3")
+                question_text = question_text + f"\n\nTranscription: {audioContent['text']}"
+        info += f"\n\nRunning agent on question {i+1}/{len(questions_dataset)}:\n  - task_id: {task_id}\n  - question: {question_text}"
+        yield info, None
+        if not task_id or question_text is None:
+            yield info+ f"\nError in question data: {questions_data}", None
+            return
+        try:
+            submitted_answer = agent.run(question_text, images=images) if run_agent else "-- no agent interaction --"
+            info += f"\n  - got answer {submitted_answer}"
+            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, "FileInfo": file_name})
+        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}", "FileInfo": file_name})
+
+        if not answers_payload:
+            print("Agent did not produce any answers.")
+            yield info + "\nAgent did not produce any answers.", pd.DataFrame(results_log)
+            return
+
+        # 5. Submit
+        
+        try:
+            results_df = pd.DataFrame(results_log)
+            yield info + "\nGot an answer from agent", results_df
+        except Exception as e:
+            status_message = f"An unexpected error occurred during submission: {e}"
+            print(status_message)
+            results_df = pd.DataFrame(results_log)
+            yield status_message, results_df
+            return
+
+
+
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
     Fetches all questions, runs the BasicAgent on them, submits all answers,
     and displays the results.
     """
+
+    return "We are not there yet", None
     # --- Determine HF Space Runtime URL and Repo URL ---
     space_id = os.getenv("SPACE_ID") # Get the SPACE_ID for sending link to the code
 
@@ -140,37 +313,140 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
         return status_message, results_df
 
 
+def fetch_ollama_models() -> list:
+    """
+    Fetches available models from the Ollama server.
+    :return: List of available models.
+    """
+    try:
+        response = requests.get("http://localhost:11434/api/tags")
+        response.raise_for_status()
+        data = response.json()
+        return [model["name"] for model in data["models"]]
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching Ollama models: {e}")
+        return ["None"]
+def fetch_lmstudio_models() -> list:
+    """
+    Fetches available models from the LM Studio server.
+    :return: List of available models.
+    """
+    try:
+        response = requests.get("http://localhost:1234/v1/models")
+        response.raise_for_status()
+        data = response.json()
+        return [model["id"] for model in data["data"]]
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching LM Studio models: {e}")
+        return ["None"]
+
+
+available_models = ["None"]
+
+def update_available_models(provider:str):
+    """
+    Fetches available models based on the selected provider.
+    :param provider: The selected provider name.
+    :return: Update object for the model dropdown.
+    """
+    global available_models
+    print(f"Selected provider: {provider}")
+    
+    match provider:
+        case "hugging face":
+            available_models = ["None", "", "QWEN-2-instruct"]
+        case "Ollama":
+            available_models = fetch_ollama_models()
+        case "LMStudio":
+            available_models = fetch_lmstudio_models()
+        case "Gemini":
+            available_models = ["None", "Gemini-2.0-flash-exp", "Gemini-2.0-flash-lite"]
+        case "Anthropic":   
+            available_models = ["None", "Claude-3"]
+        case "OpenAI":
+            available_models = ["None", "GPT-4", "GPT-3.5-turbo"]
+        case "Basic Agent":
+            available_models = ["None"]
+        case _:
+            available_models = ["None"]
+    
+    print(f"Available models for {provider}: {available_models}")
+
+
+    return gr.Dropdown(choices=available_models)
+
+
+
 # --- Build Gradio Interface using Blocks ---
 with gr.Blocks() as demo:
     gr.Markdown("# Basic Agent Evaluation Runner")
+
+    agent_info_text = gr.Text(label="Agent Name", value=get_agent_info(), interactive=False, visible=True)
+
     gr.Markdown(
         """
         **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.
+        Select a provider and then model to generate the agent.
         """
     )
 
-    gr.LoginButton()
+    provider_select = gr.Dropdown(
+        label="Select Provider",
+        choices=["Basic Agent", "LMStudio", "Ollama", "hugging face", "Gemini", "Anthropic", "OpenAI"],
+        interactive=True,
+        visible=True,
+        multiselect=False)
+
+    model_select = gr.Dropdown(
+        label="Select Model",
+        choices=available_models,
+        interactive=True,
+        visible=True,
+        multiselect=False) 
+
+    # changing the provider will change the available models
+    provider_select.input(fn=update_available_models, inputs=provider_select, outputs=[model_select])
+    
+    # changing a model will update the agent (see select_agent)
+    model_select.change(fn=select_agent, inputs=[provider_select, model_select])
+
+    # in case of running on HF space, we support the login button
+    # we somehow need to find out, if this is running on HF space or not
+    #gr.LoginButton()
 
     run_button = gr.Button("Run Evaluation & Submit All Answers")
 
+    run_test_button = gr.Button("Run Test on Random Question")
+
+    run_multiple_tests_button = gr.Button("Run tests on all questions")
+
+    run_get_questions_button = gr.Button("Get Questions")  
+
     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_test_button.click(
+        fn=run_test_on_random_question,
+        outputs=[status_output, results_table]
+    )
+
+    run_multiple_tests_button.click(
+        fn=run_test_on_all_questions,
+        outputs=[status_output, results_table]
+    )
+
     run_button.click(
         fn=run_and_submit_all,
         outputs=[status_output, results_table]
     )
 
+    run_get_questions_button.click(
+        fn=get_all_questions,
+        outputs=[status_output, results_table]
+    )
+
 if __name__ == "__main__":
     print("\n" + "-"*30 + " App Starting " + "-"*30)
     # Check for SPACE_HOST and SPACE_ID at startup for information