first try

.gitattributes

@@ -33,3 +33,8 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+.png filter=lfs diff=lfs merge=lfs -text
+.mp3 filter=lfs diff=lfs merge=lfs -text
+.xlsx filter=lfs diff=lfs merge=lfs -text
+*.mp3 filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

agent_OAI_03.py

@@ -0,0 +1,181 @@
+import base64
+from mimetypes import guess_type
+from dotenv import load_dotenv
+from typing import TypedDict, Annotated, List
+from langgraph.graph.message import add_messages
+from langchain_core.messages import AnyMessage
+from langchain_openai import ChatOpenAI
+from langgraph.prebuilt import ToolNode
+from langgraph.graph import START, StateGraph
+from langgraph.prebuilt import tools_condition
+from langchain_tavily import TavilySearch
+from langchain_community.tools import RequestsGetTool
+from langchain_community.utilities.requests import TextRequestsWrapper
+from openai import OpenAI, audio
+import pandas as pd
+from langchain_experimental.tools.python.tool import PythonREPLTool
+
+load_dotenv()
+
+# Initialize our LLM
+gpt1 = 'gpt-4o'
+gpt2 = 'gpt-4.1-2025-04-14'
+gpt3 = 'o3-mini'
+model = ChatOpenAI(model=gpt3)
+
+def integer_comparison(numb1: int, numb2: int) -> int:
+    """
+    Given input parameters
+     * numb1: an integer number,
+     * numb2: an integer number,
+    This function returns
+     * 0 if integer numb1 is equal to integer numb2
+     * 1 if integer numb1 is strictly bigger than integer numb2
+     * -1 if integer numb1 is strictly smaller than integer numb2
+    """
+    if numb1 == numb2:
+        return 0
+    elif numb1 > numb2:
+        return 1
+    else:
+        return -1
+
+def local_image_to_data_url(image_path: str) -> str:
+    # Guess MIME type
+    mime_type, _ = guess_type(image_path)
+    if mime_type is None:
+        mime_type = "application/octet-stream"
+    # Read file and base64-encode
+    with open(image_path, "rb") as f:
+        data = f.read()
+    b64 = base64.b64encode(data).decode("utf-8")
+    return f"data:{mime_type};base64,{b64}"
+
+def describe_a_photo(file: str) -> str:
+    """
+    Given input parameters
+     * file: file name of an image to be described in detail,
+    This function returns
+     * A string containing the description of the image
+    """
+    data_url = local_image_to_data_url(f"assets/{file}")
+    client = OpenAI()
+    messages = [
+                {
+                    "role": "user",
+                    "content": [
+                        "Describe what you see in this image:",
+                        {
+                            "type": "image_url",
+                            "image_url": {
+                                "url": data_url,
+                                "detail": "auto"  # optional: "low", "high", or "auto"
+                            }
+                        }
+                    ]
+                }
+    ]
+    resp = client.chat.completions.create(model="gpt-4o", messages=messages)
+    return resp.choices[0].message.content
+
+def transcript_an_audio(file: str) -> str:
+    """
+    Given input parameters
+     * file: file name of an audio to be transcripted
+    This function returns
+     * A string containing the transcription of the audio file
+    """
+    with open(f"assets/{file}", "rb") as audio_file:
+        # 3. Call the transcription endpoint
+        resp = audio.transcriptions.create(
+            model="whisper-1",
+            file=audio_file,
+            # optionally: prompt="...", response_format="verbose_json", temperature=0, language="en"
+        )
+    transcript = resp.text
+    return transcript
+
+def read_an_excel(file: str) -> str:
+    """
+    Given input parameters
+     * file: file name of an excel file to be attached
+    This function returns
+     * A string containing the excel rows as text using json format
+    """
+    df = pd.read_excel(f"assets/{file}")
+    records = df.to_dict(orient="records")
+    return str(records)
+
+def load_python_script(file: str) -> str:
+    """
+    Given input parameters
+     * file: file name of an python script file to be executed
+    This function returns
+     * A string containing the file content, the python script
+    """
+    with open(f"assets/{file}", "rb") as f:
+        data = f.read()
+    return str(data)
+
+# Simple instantiation with just the allow_dangerous_requests flag
+requests_wrapper = TextRequestsWrapper()  # or customize headers/proxy if needed
+
+# noinspection PyArgumentList
+visit_tool = RequestsGetTool(
+    requests_wrapper=requests_wrapper,
+    allow_dangerous_requests=True  # PyCharm may flag this, ignore inspection
+)
+
+# Add to your tools list:
+#visit_tool = RequestsGetTool(allow_dangerous_requests=True)
+tools = [TavilySearch(max_results=5),
+         visit_tool,
+         integer_comparison,
+         describe_a_photo,
+         transcript_an_audio,
+         read_an_excel,
+         load_python_script,
+         PythonREPLTool()]
+
+#llm_with_tools = model.bind_tools(tools, parallel_tool_calls=False)
+llm_with_tools = model.bind_tools(tools)
+
+
+# Generate the AgentState and Agent graph
+class AgentState(TypedDict):
+    messages: Annotated[List[AnyMessage], add_messages]
+
+def assistant(state: AgentState):
+    return {
+        "messages": [llm_with_tools.invoke(state["messages"])],
+    }
+
+def create_and_compile_oai_agent():
+    from openai import OpenAI
+    import os
+
+    client = OpenAI(api_key=os.environ["OPENAI_API_KEY"])
+    models = client.models.list()
+
+    #print("Available models:")
+    #for m in models.data:
+    #    print(m.id)
+
+    ## The graph
+    builder = StateGraph(AgentState)
+
+    # Define nodes: these do the work
+    builder.add_node("assistant", assistant)
+    builder.add_node("tools", ToolNode(tools))
+
+    # Define edges: these determine how the control flow moves
+    builder.add_edge(START, "assistant")
+    builder.add_conditional_edges(
+        "assistant",
+        # If the latest message requires a tool, route to tools
+        # Otherwise, provide a direct response
+        tools_condition,
+    )
+    builder.add_edge("tools", "assistant")
+    return builder.compile()
+

app.py

@@ -1,23 +1,14 @@
 import os
 import gradio as gr
 import requests
-import inspect
 import pandas as pd
+from langchain_core.messages import HumanMessage, SystemMessage
+from agent_OAI_03 import create_and_compile_oai_agent
 
 # (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.")
-    def __call__(self, question: str) -> str:
-        print(f"Agent received question (first 50 chars): {question[:50]}...")
-        fixed_answer = "This is a default answer."
-        print(f"Agent returning fixed answer: {fixed_answer}")
-        return fixed_answer
 
 def run_and_submit_all( profile: gr.OAuthProfile | None):
     """
@@ -40,7 +31,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 1. Instantiate Agent ( modify this part to create your agent)
     try:
-        agent = BasicAgent()
+        agent = create_and_compile_oai_agent()
     except Exception as e:
         print(f"Error instantiating agent: {e}")
         return f"Error initializing agent: {e}", None
@@ -50,6 +41,7 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
 
     # 2. Fetch Questions
     print(f"Fetching questions from: {questions_url}")
+    response = None
     try:
         response = requests.get(questions_url, timeout=15)
         response.raise_for_status()
@@ -72,6 +64,36 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
     # 3. Run your Agent
     results_log = []
     answers_payload = []
+
+    prompt = f"""
+    As Alfred the butler:
+        1.- analyze the human user question
+        2.- design a plan for getting the solution, including the use of the provided tools (described below)
+        3.- and, based on your reasoning and the information gathered using the available tools, 
+          provide exactly the answer in the explained format
+          (there be always a specific format for a direct response: a number, a word, etc.)
+
+    You are sported with great tools:
+     - Based on the words of the human you can look for related pages in Internet with TavilySearch: it will 
+       give you a list of URL as well the pages sneak peak of its content. Since the sneak peaks rarely contain the
+       final answer, in any case it will help you to choose what URL to visit next using the next tool:
+     - RequestsGetTool, for capturing the text, along the page DOM, so you can complete your knowledge and make a new decision
+     - Describe a Photo, for depicting the content of a picture for further questions. The tool just needs the file name, 
+       it will take care of loading it from file system and send it to the VLM.
+     - Transcript an Audio, for transcripting the content of an audio file for further questions. The tool just needs 
+       the file name, it will take care of loading it from file system and send it to the transcriptor.
+     - Read an excel file, for attaching the content in a text string to the messages. The tool just needs name, it will 
+       take care of loading it from file system and send it to the agent.
+
+    Very important, just answer with the specific information in the specified format.
+    It will be parsed with a deterministic program and it will evaluate your skills.
+    For example
+    - User: "How many items .....?"
+    - Your answer: "5"
+    - User: "comma separated list of ....."
+    - Your answer: "item1, item2, item3" (use a blank space on the right of the comma)
+    """
+
     print(f"Running agent on {len(questions_data)} questions...")
     for item in questions_data:
         task_id = item.get("task_id")
@@ -80,7 +102,18 @@ def run_and_submit_all( profile: gr.OAuthProfile | None):
             print(f"Skipping item with missing task_id or question: {item}")
             continue
         try:
-            submitted_answer = agent(question_text)
+            question_content = question_text
+            if item.get('file_name'):
+                if (item.get('file_name').endswith('.png') or
+                        item.get('file_name').endswith('.mp3') or
+                        item.get('file_name').endswith('.xlsx') or
+                        item.get('file_name').endswith('.py')):
+                    question_content = [
+                        {"type": "text", "text": question_text},
+                        {"type": "text", "text": f"the file name is: {item.get('file_name')}"}
+                    ]
+            messages = [SystemMessage(content=prompt), HumanMessage(content=question_content)]
+            submitted_answer = agent.invoke({"messages": messages})
             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:

assets/1f975693-876d-457b-a649-393859e79bf3.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:200f767e732b49efef5c05d128903ee4d2c34e66fdce7f5593ac123b2e637673
+size 280868

assets/99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3.mp3

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b218c951c1f888f0bbe6f46c080f57afc7c9348fffc7ba4da35749ff1e2ac40f
+size 179304

assets/f918266a-b3e0-4914-865d-4faa564f1aef.py

@@ -0,0 +1,35 @@
+from random import randint
+import time
+
+class UhOh(Exception):
+    pass
+
+class Hmm:
+    def __init__(self):
+        self.value = randint(-100, 100)
+
+    def Yeah(self):
+        if self.value == 0:
+            return True
+        else:
+            raise UhOh()
+
+def Okay():
+    while True:
+        yield Hmm()
+
+def keep_trying(go, first_try=True):
+    maybe = next(go)
+    try:
+        if maybe.Yeah():
+            return maybe.value
+    except UhOh:
+        if first_try:
+            print("Working...")
+            print("Please wait patiently...")
+        time.sleep(0.1)
+        return keep_trying(go, first_try=False)
+
+if __name__ == "__main__":
+    go = Okay()
+    print(f"{keep_trying(go)}")

requirements.txt

@@ -1,2 +1,10 @@
 gradio
-requests
+requests
+langchain
+langchain-community
+langchain-core
+langchain-experimental
+langchain-openai
+langchain-tavily
+langgraph
+pandas

runner_endpoints.py

@@ -0,0 +1,146 @@
+import requests
+import sys
+from pathlib import Path
+from langchain_core.messages import HumanMessage, SystemMessage
+from langchain_core.runnables import RunnableConfig
+from langfuse.callback import CallbackHandler
+
+
+def run(provider, questions_data: list, question_number: int):
+    # 1. Instantiate Agent ( modify this part to create your agent)
+    try:
+        if provider == "openai":
+            # from agent_OAI_01 import create_and_compile_oai_agent
+            from agent_OAI_03 import create_and_compile_oai_agent
+            agent = create_and_compile_oai_agent()
+        elif provider == "deepseek":
+            from agent_DS_01 import create_and_compile_ds_agent
+            agent = create_and_compile_ds_agent()
+        # elif provider == "claude":
+        print('agent compiled')
+    except Exception as e:
+        print(f"Error instantiating agent: {e}")
+        return f"Error initializing agent: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+
+    prompt = f"""
+    As Alfred the butler:
+        1.- analyze the human user question
+        2.- design a plan for getting the solution, including the use of the provided tools (described below)
+        3.- and, based on your reasoning and the information gathered using the available tools, 
+          provide exactly the answer in the explained format
+          (there be always a specific format for a direct response: a number, a word, etc.)
+
+    You are sported with great tools:
+     - Based on the words of the human you can look for related pages in Internet with TavilySearch: it will 
+       give you a list of URL as well the pages sneak peak of its content. Since the sneak peaks rarely contain the
+       final answer, in any case it will help you to choose what URL to visit next using the next tool:
+     - RequestsGetTool, for capturing the text, along the page DOM, so you can complete your knowledge and make a new decision
+     - Describe a Photo, for depicting the content of a picture for further questions. The tool just needs the file name, 
+       it will take care of loading it from file system and send it to the VLM.
+     - Transcript an Audio, for transcripting the content of an audio file for further questions. The tool just needs 
+       the file name, it will take care of loading it from file system and send it to the transcriptor.
+     - Read an excel file, for attaching the content in a text string to the messages. The tool just needs name, it will 
+       take care of loading it from file system and send it to the agent.
+
+    **Very important**, just answer with the specific information in the specified format.
+    It will be parsed with a deterministic program and it will evaluate your skills.
+    For example
+    - User: "How many items .....?"
+    - Your answer: "5"
+    - User: "comma separated list of ....."
+    - Your answer: "item1, item2, item3" (use a blank space on the right of the comma)
+    Another format rule for your answer: The first letter of the final answer should be upper case unless the word is in the question.
+    """
+
+    match = 0
+
+    for i, item in enumerate(questions_data[:question_number]):
+        print(item)
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        if not task_id or question_text is None:
+            print(f"Skipping item with missing task_id or question: {item}")
+            continue
+        try:
+            question_content = question_text
+            if item.get('file_name'):
+                if (item.get('file_name').endswith('.png') or
+                        item.get('file_name').endswith('.mp3') or
+                        item.get('file_name').endswith('.xlsx') or
+                        item.get('file_name').endswith('.py')):
+                    question_content = [
+                        {"type": "text", "text": question_text},
+                        {"type": "text", "text": f"the file name is: {item.get('file_name')}"}
+                    ]
+            messages = [SystemMessage(content=prompt), HumanMessage(content=question_content)]
+            print('invocando')
+
+            # WORKS!!!
+            # TEMPORARY DISABLED WHILE TESTING THE COURSE TOPIC
+            # Langfuse: https://cloud.langfuse.com/
+            # Initialize Langfuse CallbackHandler for LangGraph/Langchain (tracing)
+            langfuse_handler = CallbackHandler()
+
+            # Process legitimate email
+            submitted_answer = agent.invoke(
+                # input={"messages": messages, "llm": get_model(item.get('file_name'))},
+                input={"messages": messages},
+                config=RunnableConfig(callbacks=[langfuse_handler])
+            )
+
+            # submitted_answer = agent.invoke({"messages": messages})
+            print('response')
+            print(submitted_answer['messages'][-1].content)
+            #print("Expected: ", item.get("Final answer"))
+            #if submitted_answer['messages'][-1].content == item.get("Final answer"):
+            #    print("***** MATCH !!! *****")
+            #    match += 1
+            answers_payload.append({"task_id": task_id, "submitted_answer": submitted_answer['messages'][-1].content})
+            results_log.append({"Task ID": task_id, "Question": question_text,
+                                "Submitted Answer": submitted_answer['messages'][-1].content})
+        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}"})
+
+    print('**** OUTPUT ***')
+    print(answers_payload)
+    print('\n\n  ===== ---- TOTAL MATCHES:', match)
+    return None
+
+
+if __name__ == "__main__":
+
+    DEFAULT_API_URL = "https://agents-course-unit4-scoring.hf.space"
+    api_url = DEFAULT_API_URL
+    questions_url = f"{api_url}/questions"
+    submit_url = f"{api_url}/submit"
+
+    # 2. Fetch Questions
+    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.")
+             sys.exit("Fetched questions list is empty or invalid format.")
+        print(f"Fetched {len(questions_data)} questions.")
+    except requests.exceptions.RequestException as e:
+        print(f"Error fetching questions: {e}")
+        sys.exit(f"Error fetching questions: {e}")
+    except requests.exceptions.JSONDecodeError as e:
+         print(f"Error decoding JSON response from questions endpoint: {e}")
+         print(f"Response text: {response.text[:500]}")
+         sys.exit(f"Error decoding server response for questions: {e}")
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        sys.exit(f"An unexpected error occurred fetching questions: {e}")
+
+
+    run("openai", questions_data, question_number=20)
+    # run(provider, [q1, q2, q3, q4, q5, q6, q7, q8, q9, q10, q11, q12], question_number=args.max_questions)
+