Clean state

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz 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

.gitignore

@@ -0,0 +1,37 @@
+
+__pycache__
+venv
+env
+.env
+.venv
+.pytest_cache
+.coverage
+.idea
+.vscode
+lightning_logs
+.ipynb_checkpoints
+.ckpt
+example.ckpt
+.neptune
+logs_for_plots
+logs_for_heuristics
+logs_for_graphs
+logs_for_freedom_maps
+logs_for_experiments
+heuristic_tables
+stats
+videos
+algs_RL/stasts
+.DS_Store
+saved_replays
+my_folder
+results
+test-trainer
+.gradio
+alfred_chroma_db
+lib
+flow.html
+mlruns
+models_for_proj
+files
+pics

1_get_files.ipynb

@@ -0,0 +1,162 @@
+{
+ "cells": [
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-08T16:23:31.534793Z",
+     "start_time": "2025-06-08T16:23:31.531154Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "from globals import *\n",
+    "DEFAULT_API_URL = \"https://agents-course-unit4-scoring.hf.space\"\n",
+    "api_url = DEFAULT_API_URL\n",
+    "questions_url = f\"{api_url}/questions\"\n",
+    "submit_url = f\"{api_url}/submit\"\n",
+    "file_url = f\"{api_url}/files\""
+   ],
+   "id": "f59c08d782ebc6bd",
+   "outputs": [],
+   "execution_count": 4
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-08T15:07:07.789828Z",
+     "start_time": "2025-06-08T15:07:07.098834Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "response = requests.get(questions_url, timeout=15)\n",
+    "response.raise_for_status()\n",
+    "questions_data = response.json()"
+   ],
+   "id": "81985fdf7fcffcc9",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-08T16:30:24.102354Z",
+     "start_time": "2025-06-08T16:30:24.099451Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "for item_num, item in enumerate(questions_data):\n",
+    "    # dict_keys(['task_id', 'question', 'Level', 'file_name'])\n",
+    "    # print(item['question'])\n",
+    "    if item['file_name'] != '':\n",
+    "        print(f\"Task {item_num} has file: {item['file_name']}\")\n",
+    "    # print(f\"The question: \\n {item['question']} \\n\")"
+   ],
+   "id": "28fe3ba72aa61a85",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Task 3 has file: cca530fc-4052-43b2-b130-b30968d8aa44.png\n",
+      "Task 9 has file: 99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3.mp3\n",
+      "Task 11 has file: f918266a-b3e0-4914-865d-4faa564f1aef.py\n",
+      "Task 13 has file: 1f975693-876d-457b-a649-393859e79bf3.mp3\n",
+      "Task 18 has file: 7bd855d8-463d-4ed5-93ca-5fe35145f733.xlsx\n"
+     ]
+    }
+   ],
+   "execution_count": 10
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-08T16:38:46.821091Z",
+     "start_time": "2025-06-08T16:38:46.143120Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# dict_keys(['task_id', 'question', 'Level', 'file_name'])\n",
+    "item_num = 18\n",
+    "item = questions_data[item_num]\n",
+    "print('---')\n",
+    "print(f\"{item['task_id']}\")\n",
+    "print(f\"Task {item_num} has file: {item['file_name']}\")\n",
+    "\n",
+    "response = requests.get(f\"{file_url}/{item['task_id']}\", timeout=15)\n",
+    "response.raise_for_status()\n",
+    "file_data = response.url\n",
+    "print(file_data)\n",
+    "print('---')"
+   ],
+   "id": "829cb65e4c515908",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "---\n",
+      "7bd855d8-463d-4ed5-93ca-5fe35145f733\n",
+      "Task 18 has file: 7bd855d8-463d-4ed5-93ca-5fe35145f733.xlsx\n",
+      "https://agents-course-unit4-scoring.hf.space/files/7bd855d8-463d-4ed5-93ca-5fe35145f733\n",
+      "---\n"
+     ]
+    }
+   ],
+   "execution_count": 14
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-08T16:29:01.814363Z",
+     "start_time": "2025-06-08T16:29:01.811569Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "\n",
+   "id": "6108349553a14924",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "https://agents-course-unit4-scoring.hf.space/files/cca530fc-4052-43b2-b130-b30968d8aa44\n",
+      "---\n"
+     ]
+    }
+   ],
+   "execution_count": 9
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "",
+   "id": "f3cca13bc30bca7b"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

2_simplest_approach.ipynb

@@ -0,0 +1,365 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Preparations",
+   "id": "85e57249794e16a7"
+  },
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2025-06-08T16:21:51.896485Z",
+     "start_time": "2025-06-08T16:21:51.893462Z"
+    }
+   },
+   "source": [
+    "from globals import *\n",
+    "DEFAULT_API_URL = \"https://agents-course-unit4-scoring.hf.space\"\n",
+    "api_url = DEFAULT_API_URL\n",
+    "questions_url = f\"{api_url}/questions\"\n",
+    "submit_url = f\"{api_url}/submit\"\n",
+    "file_url = f\"{api_url}/files\""
+   ],
+   "outputs": [],
+   "execution_count": 32
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-07T14:46:28.498789Z",
+     "start_time": "2025-06-07T14:46:27.794622Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# get questions\n",
+    "response = requests.get(questions_url, timeout=15)\n",
+    "response.raise_for_status()\n",
+    "questions_data = response.json()"
+   ],
+   "id": "2fc7ef4f0959246b",
+   "outputs": [],
+   "execution_count": 28
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-08T16:49:29.230136Z",
+     "start_time": "2025-06-08T16:49:29.227812Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "for item_num, item in enumerate(questions_data):\n",
+    "    # dict_keys(['task_id', 'question', 'Level', 'file_name'])\n",
+    "    # print(item['question'])\n",
+    "    # print('---')\n",
+    "    # print(f\"{item['task_id']}\")\n",
+    "    print(f\"Task {item_num} has file: {item['file_name']}\")\n",
+    "    # print(f\"The question: \\n {item['question']} \\n\")"
+   ],
+   "id": "8a00fe57d4ec29bb",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Task 0 has file: \n",
+      "Task 1 has file: \n",
+      "Task 2 has file: \n",
+      "Task 3 has file: cca530fc-4052-43b2-b130-b30968d8aa44.png\n",
+      "Task 4 has file: \n",
+      "Task 5 has file: \n",
+      "Task 6 has file: \n",
+      "Task 7 has file: \n",
+      "Task 8 has file: \n",
+      "Task 9 has file: 99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3.mp3\n",
+      "Task 10 has file: \n",
+      "Task 11 has file: f918266a-b3e0-4914-865d-4faa564f1aef.py\n",
+      "Task 12 has file: \n",
+      "Task 13 has file: 1f975693-876d-457b-a649-393859e79bf3.mp3\n",
+      "Task 14 has file: \n",
+      "Task 15 has file: \n",
+      "Task 16 has file: \n",
+      "Task 17 has file: \n",
+      "Task 18 has file: 7bd855d8-463d-4ed5-93ca-5fe35145f733.xlsx\n",
+      "Task 19 has file: \n"
+     ]
+    }
+   ],
+   "execution_count": 38
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-04T18:23:01.054690Z",
+     "start_time": "2025-06-04T18:22:59.280217Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "train_dataset = load_dataset(\"gaia-benchmark/GAIA\", '2023_level1', split=\"validation\")\n",
+    "len(train_dataset)"
+   ],
+   "id": "d6216c8b17766ad8",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "53"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 22
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-04T18:24:32.847570Z",
+     "start_time": "2025-06-04T18:24:32.844925Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "print(train_dataset[0].keys())\n",
+    "item_0 = train_dataset[0]\n",
+    "# for item in train_dataset:\n",
+    "#     print(item)"
+   ],
+   "id": "ace71ed85c088f6e",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "dict_keys(['task_id', 'Question', 'Level', 'Final answer', 'file_name', 'file_path', 'Annotator Metadata'])\n"
+     ]
+    }
+   ],
+   "execution_count": 25
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Simplest approach - just ask LLM",
+   "id": "81dbae05a73009a4"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-06T17:02:03.029164Z",
+     "start_time": "2025-06-06T17:02:02.986724Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "from globals import *\n",
+    "from tools import *\n",
+    "\n",
+    "# ------------------------------------------------------ #\n",
+    "# MODELS & TOOLS\n",
+    "# ------------------------------------------------------ #\n",
+    "chat_llm = ChatTogether(model=\"meta-llama/Llama-3.3-70B-Instruct-Turbo-Free\", api_key=os.getenv(\"TOGETHER_API_KEY\"))\n",
+    "\n",
+    "# ------------------------------------------------------ #\n",
+    "# STATE\n",
+    "# ------------------------------------------------------ #\n",
+    "class AgentState(TypedDict):\n",
+    "    # messages: list[AnyMessage, add_messages]\n",
+    "    messages: list[AnyMessage]\n",
+    "    # final_output_is_good: bool\n",
+    "\n",
+    "# ------------------------------------------------------ #\n",
+    "# HELP FUNCTIONS\n",
+    "# ------------------------------------------------------ #\n",
+    "def step_print(state: AgentState, step_label: str):\n",
+    "    print(f'<<--- [{len(state[\"messages\"])}] Starting {step_label}... --->>')\n",
+    "\n",
+    "def messages_print(messages_to_print: List[AnyMessage]):\n",
+    "    print('--- Message/s ---')\n",
+    "    for m in messages_to_print:\n",
+    "        print(f'{m.type} ({m.name}): \\n{m.content}')\n",
+    "    print(f'<<--- *** --->>')\n",
+    "\n",
+    "# ------------------------------------------------------ #\n",
+    "# NODES\n",
+    "# ------------------------------------------------------ #\n",
+    "def preprocessing(state: AgentState):\n",
+    "    step_print(state, 'Preprocessing')\n",
+    "    messages_print(state['messages'][-1:])\n",
+    "    return {\n",
+    "        \"messages\": [SystemMessage(content=DEFAULT_SYSTEM_PROMPT)] + state[\"messages\"]\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def assistant(state: AgentState):\n",
+    "    # state[\"messages\"] = [SystemMessage(content=DEFAULT_SYSTEM_PROMPT)] + state[\"messages\"]\n",
+    "    step_print(state, 'assistant')\n",
+    "    ai_message = chat_llm.invoke(state[\"messages\"])\n",
+    "    messages_print([ai_message])\n",
+    "    return {\n",
+    "        'messages': state[\"messages\"] + [ai_message]\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "base_tool_node = ToolNode(tools)\n",
+    "def wrapped_tool_node(state: AgentState):\n",
+    "    step_print(state, 'Tools')\n",
+    "    # Call the original ToolNode\n",
+    "    result = base_tool_node.invoke(state)\n",
+    "    messages_print(result[\"messages\"])\n",
+    "    # Append to the messages list instead of replacing it\n",
+    "    state[\"messages\"] += result[\"messages\"]\n",
+    "    return {\"messages\": state[\"messages\"]}\n",
+    "\n",
+    "\n",
+    "# ------------------------------------------------------ #\n",
+    "# CONDITIONAL FUNCTIONS\n",
+    "# ------------------------------------------------------ #\n",
+    "def condition_tools_or_continue(\n",
+    "    state: Union[list[AnyMessage], dict[str, Any], BaseModel],\n",
+    "    messages_key: str = \"messages\",\n",
+    ") -> Literal[\"tools\", \"__end__\"]:\n",
+    "\n",
+    "    if isinstance(state, list):\n",
+    "        ai_message = state[-1]\n",
+    "    elif isinstance(state, dict) and (messages := state.get(messages_key, [])):\n",
+    "        ai_message = messages[-1]\n",
+    "    elif messages := getattr(state, messages_key, []):\n",
+    "        ai_message = messages[-1]\n",
+    "    else:\n",
+    "        raise ValueError(f\"No messages found in input state to tool_edge: {state}\")\n",
+    "    if hasattr(ai_message, \"tool_calls\") and len(ai_message.tool_calls) > 0:\n",
+    "        return \"tools\"\n",
+    "    # return \"checker_final_answer\"\n",
+    "    return \"__end__\"\n",
+    "\n",
+    "\n",
+    "# ------------------------------------------------------ #\n",
+    "# BUILDERS\n",
+    "# ------------------------------------------------------ #\n",
+    "def workflow_simple() -> Tuple[StateGraph, str]:\n",
+    "    i_builder = StateGraph(AgentState)\n",
+    "    # Nodes\n",
+    "    i_builder.add_node('preprocessing', preprocessing)\n",
+    "    i_builder.add_node('assistant', assistant)\n",
+    "\n",
+    "    # Edges\n",
+    "    i_builder.add_edge(START, 'preprocessing')\n",
+    "    i_builder.add_edge('preprocessing', 'assistant')\n",
+    "    return i_builder, 'workflow_simple'\n",
+    "\n",
+    "\n",
+    "# ------------------------------------------------------ #\n",
+    "# COMPILATION\n",
+    "# ------------------------------------------------------ #\n",
+    "builder, builder_name = workflow_simple()\n",
+    "alfred = builder.compile()"
+   ],
+   "id": "9dda3c180ddb1cf6",
+   "outputs": [],
+   "execution_count": 9
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-06T17:02:14.364108Z",
+     "start_time": "2025-06-06T17:02:04.962236Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "response = alfred.invoke({'messages': [HumanMessage(content=\"If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.\")]})",
+   "id": "817c59e55d4ccd37",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<<--- [1] Starting Preprocessing... --->>\n",
+      "--- Message/s ---\n",
+      "human (None): \n",
+      "If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.\n",
+      "<<--- *** --->>\n",
+      "<<--- [2] Starting assistant... --->>\n",
+      "--- Message/s ---\n",
+      "ai (None): \n",
+      "To calculate the time it would take Eliud Kipchoge to run from the Earth to the Moon at its closest approach, we first need to find out the distance between the Earth and the Moon at its closest approach and Eliud Kipchoge's speed.\n",
+      "\n",
+      "The minimum perigee value for the Moon, according to Wikipedia, is approximately 356400 kilometers.\n",
+      "\n",
+      "Eliud Kipchoge's record-making marathon pace is 2:01:39 hours for 42.195 kilometers. To find his speed in kilometers per hour, we divide the distance by the time. \n",
+      "\n",
+      "First, convert 2:01:39 hours to just hours: 2 + (1/60) + (39/3600) = 2 + 0.0167 + 0.0108 = 2.0275 hours.\n",
+      "\n",
+      "Now, calculate his speed: 42.195 km / 2.0275 hours = 20.818 km/h.\n",
+      "\n",
+      "Now, calculate the time it would take to run 356400 km at this speed: 356400 km / 20.818 km/h = 17127 hours.\n",
+      "\n",
+      "To convert this to thousand hours, divide by 1000: 17127 / 1000 = 17.127.\n",
+      "\n",
+      "Rounded to the nearest 1000 hours, this is 17 thousand hours, but since the answer should not use comma separators or units, and should be rounded to the nearest 1000, we get 17000.\n",
+      "\n",
+      "FINAL ANSWER: 17000\n",
+      "<<--- *** --->>\n"
+     ]
+    }
+   ],
+   "execution_count": 10
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-06T16:58:44.774532Z",
+     "start_time": "2025-06-06T16:58:42.601012Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "response1 = chat_llm.invoke([SystemMessage(content=DEFAULT_SYSTEM_PROMPT), HumanMessage(content=\"If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.\")])",
+   "id": "ef5b5fafeaff660b",
+   "outputs": [],
+   "execution_count": 6
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-06T16:59:57.792887Z",
+     "start_time": "2025-06-06T16:59:55.855377Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "response2 = chat_llm.invoke([SystemMessage(content=DEFAULT_SYSTEM_PROMPT), HumanMessage(content=\"If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.\"), response1])",
+   "id": "7462e130d047c1be",
+   "outputs": [],
+   "execution_count": 8
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

3_tools_approach.ipynb

@@ -0,0 +1,640 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Preps",
+   "id": "39fa029d099d9f52"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.142189Z",
+     "start_time": "2025-06-10T20:50:31.139103Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "from tools import describe_audio_tool",
+   "id": "a8592566121f9a22",
+   "outputs": [],
+   "execution_count": 87
+  },
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.155454Z",
+     "start_time": "2025-06-10T20:50:31.152566Z"
+    }
+   },
+   "source": [
+    "from globals import *\n",
+    "from global_functions import *\n",
+    "from tools import *\n",
+    "from IPython.display import Image, display\n",
+    "import datasets\n",
+    "import base64\n",
+    "from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, SystemMessage, ToolMessage\n",
+    "# describe_image_tool\n",
+    "import subprocess\n",
+    "from langchain_community.document_loaders import UnstructuredExcelLoader\n",
+    "import yt_dlp\n",
+    "from langchain_community.tools import WikipediaQueryRun\n",
+    "from langchain_community.utilities import WikipediaAPIWrapper"
+   ],
+   "outputs": [],
+   "execution_count": 88
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.198378Z",
+     "start_time": "2025-06-10T20:50:31.165368Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# MODELS\n",
+    "# ------------------------------------------------------ #\n",
+    "# init_chat_llm = ChatOllama(model=model_name)\n",
+    "init_chat_llm = ChatTogether(model=\"meta-llama/Llama-3.3-70B-Instruct-Turbo-Free\", api_key=os.getenv(\"TOGETHER_API_KEY\"))\n"
+   ],
+   "id": "de15a3991553b118",
+   "outputs": [],
+   "execution_count": 89
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.208604Z",
+     "start_time": "2025-06-10T20:50:31.206116Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# FUNCTIONS FOR TOOLS\n",
+    "# ------------------------------------------------------ #\n",
+    "def read_mp3(f, normalized=False):\n",
+    "    \"\"\"Read MP3 file to numpy array.\"\"\"\n",
+    "    a = pydub.AudioSegment.from_mp3(f)\n",
+    "    y = np.array(a.get_array_of_samples())\n",
+    "    if a.channels == 2:\n",
+    "        y = y.reshape((-1, 2))\n",
+    "        # y = y.mean(axis=1)\n",
+    "        y = y[:,1]\n",
+    "    if normalized:\n",
+    "        return a.frame_rate, np.float32(y) / 2**15\n",
+    "    else:\n",
+    "        return a.frame_rate, y"
+   ],
+   "id": "6db4dcdc5746ff14",
+   "outputs": [],
+   "execution_count": 90
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.222129Z",
+     "start_time": "2025-06-10T20:50:31.217718Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# TOOLS\n",
+    "# ------------------------------------------------------ #\n",
+    "# mp3\n",
+    "def describe_audio_tool(file_name: str) -> str:\n",
+    "    \"\"\"\n",
+    "    This tool receives a file name of an audio, uploads the audio and returns a detailed description of the audio.\n",
+    "    Inputs: file_name as str\n",
+    "    Outputs: audio detailed description as str\n",
+    "    \"\"\"\n",
+    "    # --------------------------------------------------------------------------- #\n",
+    "    file_dir = f'files/{file_name}'\n",
+    "    print(f\"{file_dir=}\")\n",
+    "    audio_input_sr, audio_input_np = read_mp3(file_dir)\n",
+    "    audio_input_t = torch.tensor(audio_input_np, dtype=torch.float32)\n",
+    "    target_sr = 16000\n",
+    "    resampler = T.Resample(audio_input_sr, target_sr, dtype=audio_input_t.dtype)\n",
+    "    resampled_audio_input_t: torch.Tensor = resampler(audio_input_t)\n",
+    "    resampled_audio_input_np = resampled_audio_input_t.numpy()\n",
+    "    # --------------------------------------------------------------------------- #\n",
+    "    inputs = processor(resampled_audio_input_np, sampling_rate=16000, return_tensors=\"pt\", padding=True)\n",
+    "    # Inference\n",
+    "    with torch.no_grad():\n",
+    "        logits = model(**inputs).logits\n",
+    "    # Decode\n",
+    "    predicted_ids = torch.argmax(logits, dim=-1)\n",
+    "    transcription = processor.decode(predicted_ids[0])\n",
+    "    return transcription\n",
+    "\n",
+    "# py\n",
+    "def python_repl_tool(file_name: str) -> str:\n",
+    "    \"\"\"\n",
+    "    This tool receives a file name of a python code and executes it. Then, it returns a an output of the code.\n",
+    "    Inputs: file_name as str\n",
+    "    Outputs: code's output as str\n",
+    "    \"\"\"\n",
+    "    file_dir = f'files/{file_name}'\n",
+    "    print(f\"{file_dir=}\")\n",
+    "    result = subprocess.run([\"python\", file_dir], capture_output=True, text=True)\n",
+    "    return result.stdout\n",
+    "\n",
+    "# xlsx\n",
+    "def excel_repl_tool(file_name: str) -> str:\n",
+    "    \"\"\"\n",
+    "    This tool receives a file name of an Excel file and reads it. Then, it returns a string of the content of the file.\n",
+    "    Inputs: file_name as str\n",
+    "    Outputs: file's content as str\n",
+    "    \"\"\"\n",
+    "    file_dir = f'files/{file_name}'\n",
+    "    print(f\"{file_dir=}\")\n",
+    "    loader = UnstructuredExcelLoader(file_dir, mode=\"elements\")\n",
+    "    docs = loader.load()\n",
+    "    return docs[0].metadata['text_as_html']\n",
+    "\n",
+    "\n",
+    "# youtube\n",
+    "def youtube_extractor_tool(url: str) -> str:\n",
+    "    \"\"\"\n",
+    "    This tool receives a url of the youtube video and reads it. Then, it returns a string of the content of the video.\n",
+    "    Inputs: url as str\n",
+    "    Outputs: video's content as str\n",
+    "    \"\"\"\n",
+    "    file_name = 'my_audio_file'\n",
+    "    ydl_opts = {\n",
+    "        'format': 'bestaudio/best',\n",
+    "        'outtmpl': f'files/{file_name}.%(ext)s',  # <-- set your custom filename here\n",
+    "        'postprocessors': [{\n",
+    "            'key': 'FFmpegExtractAudio',\n",
+    "            'preferredcodec': 'mp3',\n",
+    "            'preferredquality': '192',\n",
+    "        }],\n",
+    "    }\n",
+    "\n",
+    "    with yt_dlp.YoutubeDL(ydl_opts) as ydl:\n",
+    "        ydl.download([url])\n",
+    "    return describe_audio_tool(file_name=f'{file_name}.mp3')\n",
+    "\n",
+    "\n",
+    "# wiki\n",
+    "def wikipedia_tool(query: str) -> str:\n",
+    "    \"\"\"\n",
+    "    This tool receives a query to search inside the Wikipedia website, reads the page and returns the relevant information as a string.\n",
+    "    Inputs: query as str\n",
+    "    Outputs: Wikipedia's relevant content as str\n",
+    "    \"\"\"\n",
+    "    print(f\"[wiki tool] {query=}\")\n",
+    "    wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())\n",
+    "    respond = wikipedia.run(query)\n",
+    "    return respond"
+   ],
+   "id": "259492d051c8ae57",
+   "outputs": [],
+   "execution_count": 91
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.239565Z",
+     "start_time": "2025-06-10T20:50:31.230235Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# BENDING TO TOOLS\n",
+    "# ------------------------------------------------------ #\n",
+    "tools = [search_tool, describe_image_tool, describe_audio_tool, python_repl_tool, excel_repl_tool, youtube_extractor_tool, wikipedia_tool]\n",
+    "chat_llm = init_chat_llm.bind_tools(tools)"
+   ],
+   "id": "13d9344ff87bc5e6",
+   "outputs": [],
+   "execution_count": 92
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.247558Z",
+     "start_time": "2025-06-10T20:50:31.246108Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# STATE\n",
+    "# ------------------------------------------------------ #\n",
+    "class AgentState(TypedDict):\n",
+    "    # messages: list[AnyMessage, add_messages]\n",
+    "    messages: list[AnyMessage]\n",
+    "    file_name: str\n",
+    "    final_output_is_good: bool"
+   ],
+   "id": "6a38f29e827cab31",
+   "outputs": [],
+   "execution_count": 93
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.257049Z",
+     "start_time": "2025-06-10T20:50:31.254965Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# HELP FUNCTIONS\n",
+    "# ------------------------------------------------------ #\n",
+    "def step_print(state: AgentState | None, step_label: str):\n",
+    "    if state:\n",
+    "        print(f'<<--- [{len(state[\"messages\"])}] Entering ``{step_label}`` Node... --->>')\n",
+    "    else:\n",
+    "        print(f'<<--- [] Entering ``{step_label}`` Node... --->>')\n",
+    "\n",
+    "\n",
+    "def messages_print(messages_to_print: List[AnyMessage]):\n",
+    "    print('--- Message/s ---')\n",
+    "    for m in messages_to_print:\n",
+    "        print(f'{m.type} ({m.name}): \\n{m.content}')\n",
+    "    print(f'<<--- *** --->>')"
+   ],
+   "id": "583f00a3c2e18e36",
+   "outputs": [],
+   "execution_count": 94
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.271958Z",
+     "start_time": "2025-06-10T20:50:31.264390Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# NODES\n",
+    "# ------------------------------------------------------ #\n",
+    "def preprocessing(state: AgentState):\n",
+    "    # state['messages'] = [state['messages'][0]]\n",
+    "    step_print(None, 'Preprocessing')\n",
+    "    if state['file_name'] != '':\n",
+    "        # state['messages'] += f\"\\nfile_name: {state['file_name']}\"\n",
+    "        state['messages'][0].content += f\"\\nfile_name: {state['file_name']}\"\n",
+    "    messages_print(state['messages'])\n",
+    "    return {\n",
+    "        \"messages\": [SystemMessage(content=DEFAULT_SYSTEM_PROMPT)] + state[\"messages\"]\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "def assistant(state: AgentState):\n",
+    "    # state[\"messages\"] = [SystemMessage(content=DEFAULT_SYSTEM_PROMPT)] + state[\"messages\"]\n",
+    "    step_print(state, 'assistant')\n",
+    "    ai_message = chat_llm.invoke(state[\"messages\"])\n",
+    "    messages_print([ai_message])\n",
+    "    return {\n",
+    "        'messages': state[\"messages\"] + [ai_message]\n",
+    "    }\n",
+    "\n",
+    "\n",
+    "base_tool_node = ToolNode(tools)\n",
+    "def wrapped_tool_node(state: AgentState):\n",
+    "    step_print(state, 'Tools')\n",
+    "    # Call the original ToolNode\n",
+    "    result = base_tool_node.invoke(state)\n",
+    "    messages_print(result[\"messages\"])\n",
+    "    # Append to the messages list instead of replacing it\n",
+    "    state[\"messages\"] += result[\"messages\"]\n",
+    "    return {\"messages\": state[\"messages\"]}\n",
+    "\n",
+    "\n",
+    "def checker_final_answer(state: AgentState):\n",
+    "    step_print(state, 'Final Check')\n",
+    "    s = state['messages'][-1].content\n",
+    "    if \"FINAL ANSWER: \" not in s:\n",
+    "        return {\n",
+    "        'messages': state[\"messages\"],\n",
+    "        'final_output_is_good': False\n",
+    "    }\n",
+    "    return {\n",
+    "        'final_output_is_good': True\n",
+    "    }\n"
+   ],
+   "id": "45ef5e1d3df698de",
+   "outputs": [],
+   "execution_count": 95
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.281228Z",
+     "start_time": "2025-06-10T20:50:31.278542Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# CONDITIONAL FUNCTIONS\n",
+    "# ------------------------------------------------------ #\n",
+    "def condition_output(state: AgentState) -> Literal[\"assistant\", \"__end__\"]:\n",
+    "    if state['final_output_is_good']:\n",
+    "        return END\n",
+    "    return \"assistant\"\n",
+    "\n",
+    "\n",
+    "def condition_tools_or_continue(\n",
+    "    state: Union[list[AnyMessage], dict[str, Any], BaseModel],\n",
+    "    messages_key: str = \"messages\",\n",
+    ") -> Literal[\"tools\", \"checker_final_answer\"]:\n",
+    "\n",
+    "    if isinstance(state, list):\n",
+    "        ai_message = state[-1]\n",
+    "    elif isinstance(state, dict) and (messages := state.get(messages_key, [])):\n",
+    "        ai_message = messages[-1]\n",
+    "    elif messages := getattr(state, messages_key, []):\n",
+    "        ai_message = messages[-1]\n",
+    "    else:\n",
+    "        # pass\n",
+    "        raise ValueError(f\"No messages found in input state to tool_edge: {state}\")\n",
+    "    if hasattr(ai_message, \"tool_calls\") and len(ai_message.tool_calls) > 0:\n",
+    "        return \"tools\"\n",
+    "    return \"checker_final_answer\"\n",
+    "    # return \"__end__\"\n"
+   ],
+   "id": "8fd537b4436a3d4b",
+   "outputs": [],
+   "execution_count": 96
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.291047Z",
+     "start_time": "2025-06-10T20:50:31.289017Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# BUILDERS\n",
+    "# ------------------------------------------------------ #\n",
+    "def workflow_tools() -> Tuple[StateGraph, str]:\n",
+    "    i_builder = StateGraph(AgentState)\n",
+    "\n",
+    "    # Nodes\n",
+    "    i_builder.add_node('preprocessing', preprocessing)\n",
+    "    i_builder.add_node('assistant', assistant)\n",
+    "    i_builder.add_node('tools', wrapped_tool_node)\n",
+    "    i_builder.add_node('checker_final_answer', checker_final_answer)\n",
+    "\n",
+    "    # Edges\n",
+    "    i_builder.add_edge(START, 'preprocessing')\n",
+    "    i_builder.add_edge('preprocessing', 'assistant')\n",
+    "    i_builder.add_conditional_edges('assistant', condition_tools_or_continue)\n",
+    "    i_builder.add_edge('tools', 'assistant')\n",
+    "    i_builder.add_conditional_edges('checker_final_answer', condition_output)\n",
+    "    return i_builder, 'workflow_tools'"
+   ],
+   "id": "ec58d7a039c99ca2",
+   "outputs": [],
+   "execution_count": 97
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Graph",
+   "id": "fda1229d71a9bba9"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.299610Z",
+     "start_time": "2025-06-10T20:50:31.298066Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "# print(alfred.get_graph().draw_mermaid())",
+   "id": "66d69686b3d6c030",
+   "outputs": [],
+   "execution_count": 98
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.311304Z",
+     "start_time": "2025-06-10T20:50:31.306768Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# ------------------------------------------------------ #\n",
+    "# COMPILATION\n",
+    "# ------------------------------------------------------ #\n",
+    "# builder, builder_name = workflow_simple()\n",
+    "builder, builder_name = workflow_tools()\n",
+    "alfred = builder.compile()"
+   ],
+   "id": "42cebd005b0a53f4",
+   "outputs": [],
+   "execution_count": 99
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:31.319171Z",
+     "start_time": "2025-06-10T20:50:31.317804Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "# display(Image(alfred.get_graph().draw_mermaid_png()))",
+   "id": "b611c5a2248d19af",
+   "outputs": [],
+   "execution_count": 100
+  },
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Check",
+   "id": "6247ddc363658c5e"
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:32.029730Z",
+     "start_time": "2025-06-10T20:50:31.326735Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "response = requests.get(questions_url, timeout=15)\n",
+    "response.raise_for_status()\n",
+    "questions_data = response.json()"
+   ],
+   "id": "713d8c986733ac2f",
+   "outputs": [],
+   "execution_count": 101
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:32.046633Z",
+     "start_time": "2025-06-10T20:50:32.043386Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "for item_num, item in enumerate(questions_data):\n",
+    "    # dict_keys(['task_id', 'question', 'Level', 'file_name'])\n",
+    "    if item['file_name'] != '':\n",
+    "        print(f\"Task {item_num} has file: {item['file_name']}\")\n",
+    "    if 'wiki' in item['question']:\n",
+    "        print(f\"Task {item_num} question: {item['question']}\")\n",
+    "\n",
+    "item_num = 0\n",
+    "item = questions_data[item_num]\n",
+    "# dict_keys(['task_id', 'question', 'Level', 'file_name'])\n",
+    "print('---')\n",
+    "print(f\"NUM: {item_num}\")\n",
+    "print(f\"ID: {item['task_id']}\")\n",
+    "print(f\"FILE NAME: {item['file_name']}\")\n",
+    "print(f\"QUESTION: \\n{item['question']}\")\n",
+    "print('---')"
+   ],
+   "id": "52247811540e5c73",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Task 0 question: How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia.\n",
+      "Task 3 has file: cca530fc-4052-43b2-b130-b30968d8aa44.png\n",
+      "Task 9 has file: 99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3.mp3\n",
+      "Task 11 has file: f918266a-b3e0-4914-865d-4faa564f1aef.py\n",
+      "Task 13 has file: 1f975693-876d-457b-a649-393859e79bf3.mp3\n",
+      "Task 18 has file: 7bd855d8-463d-4ed5-93ca-5fe35145f733.xlsx\n",
+      "---\n",
+      "NUM: 0\n",
+      "ID: 8e867cd7-cff9-4e6c-867a-ff5ddc2550be\n",
+      "FILE NAME: \n",
+      "QUESTION: \n",
+      "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia.\n",
+      "---\n"
+     ]
+    }
+   ],
+   "execution_count": 102
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:50:46.752288Z",
+     "start_time": "2025-06-10T20:50:36.572639Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "response = alfred.invoke({\n",
+    "    'messages': [HumanMessage(content=item['question'])],\n",
+    "    'file_name': item['file_name'],\n",
+    "    'final_output_is_good': False,\n",
+    "})"
+   ],
+   "id": "d1469f387207c914",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<<--- [] Entering ``Preprocessing`` Node... --->>\n",
+      "--- Message/s ---\n",
+      "human (None): \n",
+      "How many studio albums were published by Mercedes Sosa between 2000 and 2009 (included)? You can use the latest 2022 version of english wikipedia.\n",
+      "<<--- *** --->>\n",
+      "<<--- [2] Entering ``assistant`` Node... --->>\n",
+      "--- Message/s ---\n",
+      "ai (None): \n",
+      "\n",
+      "<<--- *** --->>\n",
+      "<<--- [3] Entering ``Tools`` Node... --->>\n",
+      "[wiki tool] query='Mercedes Sosa discography'\n",
+      "--- Message/s ---\n",
+      "tool (wikipedia_tool): \n",
+      "Page: Mercedes Sosa\n",
+      "Summary: Haydée Mercedes \"La Negra\" Sosa (Latin American Spanish: [meɾˈseðes ˈsosa]; 9 July 1935 – 4 October 2009) was an Argentine singer who was popular throughout Latin America and many countries outside the region. With her roots in Argentine folk music, Sosa became one of the preeminent exponents of El nuevo cancionero. She gave voice to songs written by many Latin American songwriters. Her music made people hail her as the \"voice of the voiceless ones\". She was often called \"the conscience of Latin America\".\n",
+      "Sosa performed in venues such as the Lincoln Center in New York City, the Théâtre Mogador in Paris, the Sistine Chapel in Vatican City, as well as sold-out shows in New York's Carnegie Hall and the Roman Colosseum during her final decade of life. Her career spanned four decades and she was the recipient of six Latin Grammy awards (2000, 2003, 2004, 2006, 2009, 2011), including a Latin Grammy Lifetime Achievement Award in 2004 and two posthumous Latin Grammy Award for Best Folk Album in 2009 and 2011. She won the Premio Gardel in 2000, the main musical award in Argentina. She served as an ambassador for UNICEF.\n",
+      "\n",
+      "Page: Cantora, un Viaje Íntimo\n",
+      "Summary: Cantora, un Viaje Íntimo  (English: Cantora, An Intimate Journey) is a double album by Argentine singer Mercedes Sosa, released on 2009 through Sony Music Argentina. The album features Cantora 1 and Cantora 2, the project is Sosa's final album before her death on October 4, 2009.\n",
+      "At the 10th Annual Latin Grammy Awards, Cantora 1 was nominated for Album of the Year and won Best Folk Album and Best Recording Package, the latter award went to Alejandro Ros, the art director of the album. Additionally, Sosa won two out of five nominations for the albums at the Gardel Awards 2010, the double album was nominated for Album of the Year and Production of the Year and won Best DVD while both Cantora 1 and Cantora 2 were nominated for Best Female Folk Album, with the former winning the category.\n",
+      "The double album was a commercial success, being certified platinum by the CAPIF selling more than 200,000 copies in Argentina, Cantora 1 was also certified platinum selling 40,000 copies while Cantora 2 was certified gold selling 20,000 copies. The album also peaked at numbers 22 and 8 at the Top Latin Albums and Latin Pop Albums charts in United States, respectively, being Sosa's only appearances on both charts.\n",
+      "At documentary film titled Mercedes Sosa, Cantora un viaje íntimo was released on 2009, it was directed by Rodrigo Vila and features the recording process of the album as well as testimonies from the different guest artists that appeared on the project.\n",
+      "\n",
+      "Page: Joan Baez discography\n",
+      "Summary: This is a discography for American folk singer and songwriter Joan Baez.\n",
+      "<<--- *** --->>\n",
+      "<<--- [4] Entering ``assistant`` Node... --->>\n",
+      "--- Message/s ---\n",
+      "ai (None): \n",
+      "According to the Wikipedia page, between 2000 and 2009, Mercedes Sosa published the following studio albums: Acústico (2002), Corazón Libre (2005), and Cantora 1 and Cantora 2 (2009). \n",
+      "\n",
+      "FINAL ANSWER: 4\n",
+      "<<--- *** --->>\n",
+      "<<--- [5] Entering ``Final Check`` Node... --->>\n"
+     ]
+    }
+   ],
+   "execution_count": 103
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-09T19:43:11.250731Z",
+     "start_time": "2025-06-09T19:43:11.249022Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# pic_loc_str = 'files/cca530fc-4052-43b2-b130-b30968d8aa44.png'\n",
+    "# # doc = [UnstructuredImageLoader(pic_loc_str).load()]\n",
+    "# dataset = datasets.Dataset.from_dict({\"image\": [pic_loc_str]}).cast_column(\"image\", datasets.Image())\n",
+    "# dataset[0][\"image\"]"
+   ],
+   "id": "c9ee8e0b9fbc5df7",
+   "outputs": [],
+   "execution_count": 93
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "\n",
+   "id": "ab912d811bf50006"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

README.md

@@ -0,0 +1,26 @@
+---
+title: Template Final Assignment
+emoji: 🕵🏻‍♂️
+colorFrom: indigo
+colorTo: indigo
+sdk: gradio
+sdk_version: 5.25.2
+app_file: app.py
+pinned: false
+hf_oauth: true
+# optional, default duration is 8 hours/480 minutes. Max duration is 30 days/43200 minutes.
+hf_oauth_expiration_minutes: 480
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+
+
+## Credits
+
+- [Original Template](https://huggingface.co/spaces/ArseniyPerchik/Final_Assignment_Template)
+- [Agent Evaluation API](https://agents-course-unit4-scoring.hf.space/docs)
+- [GAIA Leaderboard](http://huggingface.co/spaces/gaia-benchmark/leaderboard)
+- [GAIA Dataset](https://huggingface.co/datasets/gaia-benchmark/GAIA)
+- [LangChain | Local LLMs](https://python.langchain.com/docs/how_to/local_llms/)
+- [Laminar | Dashboard for tracing](https://www.lmnr.ai/projects)
+- [Together.AI Docs](https://docs.together.ai/docs/introduction)

app.py

@@ -0,0 +1,249 @@
+import gradio
+
+from globals import *
+from gradio_functions import *
+
+# Initialize Laminar - this single step enables automatic tracing
+# Laminar.initialize(project_api_key=LAMINAR_API_KEY)
+
+# (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, q_num: int, file_name: str) -> str:
+        print(f"# {'':=^30} #")
+        print(f"# {q_num:=^30} #")
+        print(f"# {'':=^30} #")
+        print(f"Agent received question (first 50 chars): {question[:50]}...")
+        # output_answer = "This is a default answer."
+        # output_answer_object = alfred.invoke({'messages': [HumanMessage(content=question)]})
+        _, output_answer  = ask_alfred(question, file_name)
+        print(f"Agent returning fixed answer: {output_answer}")
+        return output_answer
+
+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"
+
+    # 1. Instantiate Agent ( modify this part to create your agent)
+    try:
+        agent = BasicAgent()
+    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
+    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(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
+    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
+    except Exception as e:
+        print(f"An unexpected error occurred fetching questions: {e}")
+        return f"An unexpected error occurred fetching questions: {e}", None
+
+    # 3. Run your Agent
+    results_log = []
+    answers_payload = []
+    print(f"Running agent on {len(questions_data)} questions...")
+    file_names = ''
+    for q_num, item in enumerate(questions_data):
+        task_id = item.get("task_id")
+        question_text = item.get("question")
+        file_name = item.get("file_name")
+        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, q_num, file_name)
+            file_names += f'{q_num}: {file_name}\n'
+            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}"})
+    print(file_names)
+    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 
+    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}'..."
+    print(status_update)
+
+    # 5. Submit
+    print(f"Submitting {len(answers_payload)} answers to: {submit_url}")
+    try:
+        response = requests.post(submit_url, json=submission_data, timeout=60)
+        response.raise_for_status()
+        result_data = response.json()
+        final_status = (
+            f"Submission Successful!\n"
+            f"User: {result_data.get('username')}\n"
+            f"Overall Score: {result_data.get('score', 'N/A')}% "
+            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
+    except requests.exceptions.HTTPError as e:
+        error_detail = f"Server responded with status {e.response.status_code}."
+        try:
+            error_json = e.response.json()
+            error_detail += f" Detail: {error_json.get('detail', e.response.text)}"
+        except requests.exceptions.JSONDecodeError:
+            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
+    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
+    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
+    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
+
+
+# --- Build Gradio Interface using Blocks ---
+with gr.Blocks() as demo:
+    # --- #
+    gr.Markdown("# Train Dataset")
+    with gr.Row():
+        with gradio.Column():
+            tr_slider = gr.Slider(minimum=0, maximum=len(train_dataset)-1, step=1, label="Number of a question from the train dataset.")
+            tr_checkbox_meta = gradio.Checkbox(value=True, label='Hide metadata')
+            tr_checkbox_file = gradio.Checkbox(value=True, label='Hide file data')
+            gr.Markdown("## Agent's Analysis")
+            tr_graph = gradio.Image(label='LangGraph Structure')
+        with gradio.Column():
+            tr_question = gr.Textbox(label="Question content", lines=1, max_lines=20)
+            tr_answer = gr.Textbox(label="Real answer:", lines=1, max_lines=20)
+            tr_tools = gr.Textbox(label='Recommended tools:', lines=1, max_lines=20)
+            tr_file = gr.Textbox(label="File name", visible=False)
+            tr_meta = gr.Textbox(label="Metadata", lines=1, max_lines=40, visible=False)
+            gr.Markdown("## Agent's Output")
+            tr_refresh = gradio.Button('Respond!', variant='huggingface')
+            tr_agent_answer = gr.Textbox(label="Agent answer:", lines=1, max_lines=20)
+            tr_agent_answer_full = gr.Textbox(label="Agent full answer:", lines=1, max_lines=20)
+
+
+    # --- #
+    # --- #
+    # --- #
+    # --- #
+    # --- #
+
+
+    gr.Markdown("---")
+    gr.Markdown("# Basic Agent Evaluation Runner")
+    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.
+        """
+    )
+
+    gr.LoginButton()
+
+    run_button = gr.Button("Run Evaluation & 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)
+
+    # --- #
+    # --- #
+    # --- #
+    # --- #
+    # --- #
+
+    # EVENTS
+    run_button.click(
+        fn=run_and_submit_all,
+        outputs=[status_output, results_table]
+    )
+    tr_slider.change(fn=slider_release_func, inputs=[tr_slider], outputs=[tr_question, tr_answer, tr_file, tr_meta, tr_tools])
+    # tr_slider.change(fn=get_agent_answer, inputs=[tr_slider], outputs=[tr_agent_answer_full, tr_agent_answer])
+    tr_refresh.click(fn=get_agent_answer_train, inputs=[tr_slider], outputs=[tr_agent_answer_full, tr_agent_answer])
+    tr_refresh.click(fn=show_langgraph_structure, outputs=[tr_graph])
+    tr_checkbox_meta.change(fn=toggle_textbox, inputs=[tr_checkbox_meta], outputs=[tr_meta])
+    tr_checkbox_file.change(fn=toggle_textbox, inputs=[tr_checkbox_file], outputs=[tr_file])
+
+if __name__ == "__main__":
+    print("\n" + "-"*30 + " App Starting " + "-"*30)
+    # Check for SPACE_HOST and SPACE_ID at startup for information
+    space_host_startup = os.getenv("SPACE_HOST")
+    space_id_startup = os.getenv("SPACE_ID") # Get SPACE_ID at startup
+
+    if space_host_startup:
+        print(f"✅ SPACE_HOST found: {space_host_startup}")
+        print(f"   Runtime URL should be: https://{space_host_startup}.hf.space")
+    else:
+        print("ℹ️  SPACE_HOST environment variable not found (running locally?).")
+
+    if space_id_startup: # Print repo URLs if SPACE_ID is found
+        print(f"✅ SPACE_ID found: {space_id_startup}")
+        print(f"   Repo URL: https://huggingface.co/spaces/{space_id_startup}")
+        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("-"*(60 + len(" App Starting ")) + "\n")
+
+    print("Launching Gradio Interface for Basic Agent Evaluation...")
+    demo.launch(debug=True, share=False)

draft_1.py

@@ -0,0 +1,3 @@
+# from datasets import load_dataset
+# issues_dataset = load_dataset("gaia-benchmark/GAIA", '2023_level1', split="train")
+

global_functions.py

@@ -0,0 +1,8 @@
+from globals import *
+
+# ------------------------------------------------------ #
+# GENERAL FUNCTIONS
+# ------------------------------------------------------ #
+def encode_image(image_path):
+    with open(image_path, "rb") as image_file:
+        return base64.b64encode(image_file.read()).decode('utf-8')

globals.py

@@ -0,0 +1,71 @@
+from typing import TypedDict, Annotated, Literal, Union, Any, List, Tuple
+"""
+Typing:
+Union = either type A or type B
+Optional = either type A or None
+Literal = only specific values (constants), not any value of a type
+"""
+from pydantic import BaseModel
+import os
+import re
+import random
+import requests
+import inspect
+import subprocess
+
+import gradio as gr
+import pandas as pd
+from lmnr import Laminar
+from dotenv import load_dotenv
+load_dotenv()
+from together import Together
+import base64
+import yt_dlp
+
+import datasets
+from datasets import load_dataset
+from huggingface_hub import list_models
+from langchain.docstore.document import Document
+from langchain_community.retrievers import BM25Retriever
+from langchain_community.tools import DuckDuckGoSearchRun
+from langchain_community.document_loaders import UnstructuredExcelLoader
+from langchain_community.tools import WikipediaQueryRun
+from langchain_community.utilities import WikipediaAPIWrapper
+from langchain.tools import Tool
+from langchain_ollama import ChatOllama
+from langchain_together import ChatTogether
+from langchain_huggingface import HuggingFaceEndpoint,ChatHuggingFace
+from langchain_core.messages import AnyMessage, HumanMessage, AIMessage, SystemMessage, ToolMessage
+from langgraph.graph import StateGraph, START, END
+from langgraph.graph.message import add_messages
+from langgraph.prebuilt import tools_condition, ToolNode
+from langsmith import traceable
+
+
+
+# GLOBALS
+HF_TOKEN = os.getenv('HF_TOKEN')
+LAMINAR_API_KEY = os.getenv('LAMINAR_API_KEY')
+# from the task
+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"
+file_url = f"{api_url}/files"
+
+# DEFAULT_SYSTEM_PROMPT = """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."""
+DEFAULT_SYSTEM_PROMPT = """
+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.
+"""
+# Think step by step. On every step use a tool if it is needed. Make multiple tool calls if required.
+DEFAULT_SYSTEM_PROMPT = DEFAULT_SYSTEM_PROMPT.replace("\n", "")
+
+
+# model_name = 'qwen3:8b'
+model_name = 'llama3.2:latest'

gradio_functions.py

@@ -0,0 +1,62 @@
+from globals import *
+from langgraph_agent import *
+from PIL import Image
+import io
+
+train_dataset = load_dataset("gaia-benchmark/GAIA", '2023_level1', split="validation")
+builder, builder_name = workflow_tools()
+alfred = builder.compile()
+
+def toggle_textbox(show):
+    return gr.update(visible=not show)
+
+
+def slider_release_func(q_num: int):
+    item = train_dataset[q_num]
+    tr_metadata = ''
+    for k, v in item['Annotator Metadata'].items():
+        tr_metadata += f'{k}: \n{v} \n---\n'
+
+    return item['Question'], item['Final answer'], item['file_name'], tr_metadata.strip(), item['Annotator Metadata']['Tools']
+
+
+def process_output(response):
+    s = response['messages'][-1].content
+    pattern = "FINAL ANSWER: "
+    index = s.find(pattern)
+    if index != -1:
+        result = s[index + len(pattern):].lstrip()
+        return s, result
+    return s, f'WITH ERROR: {s}'
+
+
+
+def get_agent_answer_train(q_num: int):
+    item = train_dataset[q_num]
+    return ask_alfred(question=item['Question'], file_name=item['file_name'])
+    # # q_content = item['Question']
+    # response = alfred.invoke({
+    #     'messages': [HumanMessage(content=item['Question'])],
+    #     'file_name': item['file_name'],
+    #     'final_output_is_good': False,
+    # })
+    # # response = alfred.invoke({'messages': [HumanMessage(content=q_content)]})
+    # return process_output(response)
+
+
+
+def ask_alfred(question: str, file_name: str):
+    response = alfred.invoke({
+        'messages': [HumanMessage(content=question)],
+        'file_name': file_name,
+        'final_output_is_good': False,
+    })
+    # response = alfred.invoke({'messages': [HumanMessage(content=q_content)]})
+    return process_output(response)
+
+
+def show_langgraph_structure():
+    png_bytes = alfred.get_graph().draw_mermaid_png()
+    image = Image.open(io.BytesIO(png_bytes))
+    return image
+

langgraph_agent.py

@@ -0,0 +1,194 @@
+from globals import *
+from tools import *
+
+# ------------------------------------------------------ #
+# MODELS
+# ------------------------------------------------------ #
+# init_chat_llm = ChatOllama(model=model_name)
+init_chat_llm = ChatTogether(model="meta-llama/Llama-3.3-70B-Instruct-Turbo-Free", api_key=os.getenv("TOGETHER_API_KEY"))
+
+# ------------------------------------------------------ #
+# BENDING TO TOOLS
+# ------------------------------------------------------ #
+# tools = [guest_info_tool, search_tool, weather_info_tool, hub_stats_tool]
+# tools = [search_tool]
+tools = [
+    search_tool,
+    describe_image_tool,
+    describe_audio_tool,
+    python_repl_tool,
+    excel_repl_tool,
+    youtube_extractor_tool,
+    wikipedia_tool
+]
+chat_llm = init_chat_llm.bind_tools(tools)
+
+# ------------------------------------------------------ #
+# STATE
+# ------------------------------------------------------ #
+class AgentState(TypedDict):
+    # messages: list[AnyMessage, add_messages]
+    messages: list[AnyMessage]
+    file_name: str
+    final_output_is_good: bool
+
+# ------------------------------------------------------ #
+# HELP FUNCTIONS
+# ------------------------------------------------------ #
+def step_print(state: AgentState | None, step_label: str):
+    if state:
+        print(f'<<--- [{len(state["messages"])}] Entering ``{step_label}`` Node... --->>')
+    else:
+        print(f'<<--- [] Entering ``{step_label}`` Node... --->>')
+
+
+def messages_print(messages_to_print: List[AnyMessage]):
+    print('--- Message/s ---')
+    for m in messages_to_print:
+        print(f'{m.type} ({m.name}): \n{m.content}')
+    print(f'<<--- *** --->>')
+
+# ------------------------------------------------------ #
+# NODES
+# ------------------------------------------------------ #
+def preprocessing(state: AgentState):
+    # state['messages'] = [state['messages'][0]]
+    step_print(None, 'Preprocessing')
+    if state['file_name'] != '':
+        # state['messages'] += f"\nfile_name: {state['file_name']}"
+        state['messages'][0].content += f"\nfile_name: {state['file_name']}"
+    messages_print(state['messages'])
+    return {
+        "messages": [SystemMessage(content=DEFAULT_SYSTEM_PROMPT)] + state["messages"]
+    }
+
+
+def assistant(state: AgentState):
+    # state["messages"] = [SystemMessage(content=DEFAULT_SYSTEM_PROMPT)] + state["messages"]
+    step_print(state, 'assistant')
+    ai_message = chat_llm.invoke(state["messages"])
+    messages_print([ai_message])
+    return {
+        'messages': state["messages"] + [ai_message]
+    }
+
+
+base_tool_node = ToolNode(tools)
+def wrapped_tool_node(state: AgentState):
+    step_print(state, 'Tools')
+    # Call the original ToolNode
+    result = base_tool_node.invoke(state)
+    messages_print(result["messages"])
+    # Append to the messages list instead of replacing it
+    state["messages"] += result["messages"]
+    return {"messages": state["messages"]}
+
+
+def checker_final_answer(state: AgentState):
+    step_print(state, 'Final Check')
+    s = state['messages'][-1].content
+    if "FINAL ANSWER: " not in s:
+        return {
+        'messages': state["messages"],
+        'final_output_is_good': False
+    }
+    return {
+        'final_output_is_good': True
+    }
+
+# ------------------------------------------------------ #
+# CONDITIONAL FUNCTIONS
+# ------------------------------------------------------ #
+def condition_output(state: AgentState) -> Literal["assistant", "__end__"]:
+    if state['final_output_is_good']:
+        return END
+    return "assistant"
+
+
+def condition_tools_or_continue(
+    state: Union[list[AnyMessage], dict[str, Any], BaseModel],
+    messages_key: str = "messages",
+) -> Literal["tools", "checker_final_answer"]:
+
+    if isinstance(state, list):
+        ai_message = state[-1]
+    elif isinstance(state, dict) and (messages := state.get(messages_key, [])):
+        ai_message = messages[-1]
+    elif messages := getattr(state, messages_key, []):
+        ai_message = messages[-1]
+    else:
+        # pass
+        raise ValueError(f"No messages found in input state to tool_edge: {state}")
+    if hasattr(ai_message, "tool_calls") and len(ai_message.tool_calls) > 0:
+        return "tools"
+    return "checker_final_answer"
+    # return "__end__"
+
+
+# ------------------------------------------------------ #
+# BUILDERS
+# ------------------------------------------------------ #
+def workflow_simple() -> Tuple[StateGraph, str]:
+    i_builder = StateGraph(AgentState)
+    # Nodes
+    i_builder.add_node('preprocessing', preprocessing)
+    i_builder.add_node('assistant', assistant)
+
+    # Edges
+    i_builder.add_edge(START, 'preprocessing')
+    i_builder.add_edge('preprocessing', 'assistant')
+    return i_builder, 'workflow_simple'
+
+
+def workflow_tools() -> Tuple[StateGraph, str]:
+    i_builder = StateGraph(AgentState)
+
+    # Nodes
+    i_builder.add_node('preprocessing', preprocessing)
+    i_builder.add_node('assistant', assistant)
+    i_builder.add_node('tools', wrapped_tool_node)
+    i_builder.add_node('checker_final_answer', checker_final_answer)
+
+    # Edges
+    i_builder.add_edge(START, 'preprocessing')
+    i_builder.add_edge('preprocessing', 'assistant')
+    i_builder.add_conditional_edges('assistant', condition_tools_or_continue)
+    i_builder.add_edge('tools', 'assistant')
+    i_builder.add_conditional_edges('checker_final_answer', condition_output)
+    return i_builder, 'workflow_tools'
+
+
+@traceable
+def main():
+    # Laminar.initialize(project_api_key=LAMINAR_API_KEY)
+    # ------------------------------------------------------ #
+    # COMPILATION
+    # ------------------------------------------------------ #
+    # builder, builder_name = workflow_simple()
+    builder, builder_name = workflow_tools()
+
+    alfred = builder.compile()
+    # print(alfred.get_graph().draw_ascii())
+    # print(alfred.get_graph().draw_mermaid())
+    # with open(f"{builder_name}.png", "wb") as f:
+    #     f.write(alfred.get_graph().draw_mermaid_png())
+
+    # ------------------------------------------------------ #
+    # EXAMPLES
+    # ------------------------------------------------------ #
+    # response = alfred.invoke({'messages': "What is an apple?"})
+    # ---
+    question = """
+        If Eliud Kipchoge could maintain his record-making marathon pace indefinitely,
+        how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach?
+        Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation.
+        Round your result to the nearest 1000 hours and do not use any comma separators if necessary.
+        """
+    # response = alfred.invoke({'messages': [HumanMessage(content=question.replace('\n', ""))]})
+    response = alfred.invoke({'messages': [HumanMessage(content="Who is the president of USA in 2025?")]})
+
+    print(f"--- OUTPUT --- \n{response['messages'][-1].content}\n--- --- ---")
+
+
+if __name__ == '__main__':
+    main()

requirements.txt

@@ -0,0 +1,2 @@
+gradio
+requests

togetherai_chat_example.py

@@ -0,0 +1,20 @@
+import os
+from langchain_together import ChatTogether
+from dotenv import load_dotenv
+load_dotenv()
+from langchain_community.tools import DuckDuckGoSearchRun
+
+
+llm = ChatTogether(model="meta-llama/Llama-3.3-70B-Instruct-Turbo-Free", api_key=os.getenv("TOGETHER_API_KEY"))
+
+search_tool = DuckDuckGoSearchRun()
+
+# Augment the LLM with tools
+llm_with_tools = llm.bind_tools([search_tool])
+
+# Invoke the LLM with input that triggers the tool call
+response = llm_with_tools.invoke("If Eliud Kipchoge could maintain his record-making marathon pace indefinitely, how many thousand hours would it take him to run the distance between the Earth and the Moon its closest approach? Please use the minimum perigee value on the Wikipedia page for the Moon when carrying out your calculation. Round your result to the nearest 1000 hours and do not use any comma separators if necessary.")
+
+print(response)
+# Get the tool call
+print(response.tool_calls)

togetherai_pic_generation_example.py

@@ -0,0 +1,66 @@
+from together import Together
+import os
+from langchain_together import ChatTogether
+from dotenv import load_dotenv
+load_dotenv()
+import base64
+#%%
+client = Together()
+
+getDescriptionPrompt = "what is in the image? describe in detail"
+
+imagePath= "pics/IMG_3651.jpg"
+
+def encode_image(image_path):
+        with open(image_path, "rb") as image_file:
+            return base64.b64encode(image_file.read()).decode('utf-8')
+
+base64_image = encode_image(imagePath)
+
+stream = client.chat.completions.create(
+    # model="meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
+    model="meta-llama/Llama-Vision-Free",
+    messages=[
+        {
+            "role": "user",
+            "content": [
+                {"type": "text", "text": getDescriptionPrompt},
+                {
+                    "type": "image_url",
+                    "image_url": {
+                        "url": f"data:image/jpeg;base64,{base64_image}",
+                    },
+                },
+            ],
+        }
+    ],
+    stream=False,
+)
+#%%
+prompt = stream.choices[0].message.content
+#%%
+client = Together()
+response = client.images.generate(
+    prompt=prompt,
+    model="black-forest-labs/FLUX.1-schnell-Free",
+    steps=4,
+    n=4
+)
+print(response.data[0].url)
+
+# ---
+
+# from together import Together
+# import os
+# from langchain_together import ChatTogether
+# from dotenv import load_dotenv
+# load_dotenv()
+#
+# client = Together()
+# response = client.images.generate(
+#     prompt="Cats fighting boats with atomic bombs",
+#     model="black-forest-labs/FLUX.1-schnell-Free",
+#     steps=4,
+#     n=4
+# )
+# print(response.data[0].url)

tools.py

@@ -0,0 +1,179 @@
+from globals import *
+from global_functions import *
+from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor
+import torch
+import torchaudio.transforms as T
+import pydub
+import numpy as np
+
+# ------------------------------------------------------ #
+# CONSTANTS FOR TOOLS
+# ------------------------------------------------------ #
+audio_model_dir = './models_for_proj/wav2vec2-base-960h'
+
+
+# ------------------------------------------------------ #
+# FUNCTIONS FOR TOOLS
+# ------------------------------------------------------ #
+def read_mp3(f, normalized=False):
+    """Read MP3 file to numpy array."""
+    a = pydub.AudioSegment.from_mp3(f)
+    y = np.array(a.get_array_of_samples())
+    if a.channels == 2:
+        y = y.reshape((-1, 2))
+        # y = y.mean(axis=1)
+        y = y[:,1]
+    if normalized:
+        return a.frame_rate, np.float32(y) / 2**15
+    else:
+        return a.frame_rate, y
+
+
+# ------------------------------------------------------ #
+# MODELS FOR TOOLS
+# ------------------------------------------------------ #
+client = Together()
+
+# audio
+model = Wav2Vec2ForCTC.from_pretrained(audio_model_dir)
+processor = Wav2Vec2Processor.from_pretrained(audio_model_dir)
+
+# ------------------------------------------------------ #
+# TOOLS
+# ------------------------------------------------------ #
+# search
+search_tool = DuckDuckGoSearchRun()
+
+
+# png
+def describe_image_tool(file_name: str) -> str:
+    """
+    This tool receives a file name of an image, uploads the image and returns a detailed description of the image.
+    Inputs: file_name as str
+    Outputs: image detailed description as str
+    """
+    assert '.png' in file_name
+    pic_dir = f'[describe_image_tool] files/{file_name}'
+    getDescriptionPrompt = "What is in the image? describe in detail. Use professional notations when applicable. For example, if the image is a chess position, describe the position of ALL pieces with classical chess algebraic notation. BE PRECISE!"
+    base64_image = encode_image(pic_dir)
+    model_out = client.chat.completions.create(
+        # model="meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo",
+        model="meta-llama/Llama-Vision-Free",
+        messages=[
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "text",
+                        "text": getDescriptionPrompt},
+                    {
+                        "type": "image_url",
+                        "image_url": {"url": f"data:image/jpeg;base64,{base64_image}",},
+                    },
+                ],
+            }
+        ],
+        stream=False,
+    )
+    description = model_out.choices[0].message.content
+    # state["messages"] += [HumanMessage(content='Do not use the image. Use the description provided further by tools.')]
+    return f"Do not use the image. Instead, use the description provided further by the tool. Here is the detailed description of the image. {description}"
+
+
+# mp3
+def describe_audio_tool(file_name: str) -> str:
+    """
+    This tool receives a file name of an audio, uploads the audio and returns a detailed description of the audio.
+    Inputs: file_name as str
+    Outputs: audio detailed description as str
+    """
+    # --------------------------------------------------------------------------- #
+    file_dir = f'files/{file_name}'
+    print(f"[describe_audio_tool] {file_dir=}")
+    audio_input_sr, audio_input_np = read_mp3(file_dir)
+    audio_input_t = torch.tensor(audio_input_np, dtype=torch.float32)
+    target_sr = 16000
+    resampler = T.Resample(audio_input_sr, target_sr, dtype=audio_input_t.dtype)
+    resampled_audio_input_t: torch.Tensor = resampler(audio_input_t)
+    resampled_audio_input_np = resampled_audio_input_t.numpy()
+    # --------------------------------------------------------------------------- #
+    inputs = processor(resampled_audio_input_np, sampling_rate=16000, return_tensors="pt", padding=True)
+    # Inference
+    with torch.no_grad():
+        logits = model(**inputs).logits
+    # Decode
+    predicted_ids = torch.argmax(logits, dim=-1)
+    transcription = processor.decode(predicted_ids[0])
+    return transcription
+
+
+# py
+def python_repl_tool(file_name: str) -> str:
+    """
+    This tool receives a file name of a python code and executes it. Then, it returns a an output of the code.
+    Inputs: file_name as str
+    Outputs: code's output as str
+    """
+    file_dir = f'files/{file_name}'
+    print(f"[python_repl_tool] {file_dir=}")
+    if os.path.exists(file_dir):
+        result = subprocess.run(["python", file_dir], capture_output=True, text=True)
+        return result.stdout
+    else:
+        return 'No such file.'
+
+
+# xlsx
+def excel_repl_tool(file_name: str) -> str:
+    """
+    This tool receives a file name of an Excel file and reads it. Then, it returns a string of the content of the file.
+    Inputs: file_name as str
+    Outputs: file's content as str
+    """
+    file_dir = f'files/{file_name}'
+    print(f"{file_dir=}")
+    loader = UnstructuredExcelLoader(file_dir, mode="elements")
+    docs = loader.load()
+    return docs[0].metadata['text_as_html']
+
+
+# youtube
+def youtube_extractor_tool(url: str) -> str:
+    """
+    This tool receives a url of the youtube video and reads it. Then, it returns a string of the content of the video.
+    Inputs: url as str
+    Outputs: video's content as str
+    """
+    file_name = 'my_audio_file'
+    ydl_opts = {
+        'format': 'bestaudio/best',
+        'outtmpl': f'files/{file_name}.%(ext)s',  # <-- set your custom filename here
+        'postprocessors': [{
+            'key': 'FFmpegExtractAudio',
+            'preferredcodec': 'mp3',
+            'preferredquality': '192',
+        }],
+    }
+
+    with yt_dlp.YoutubeDL(ydl_opts) as ydl:
+        ydl.download([url])
+    return describe_audio_tool(file_name=f'{file_name}.mp3')
+
+
+# wiki
+def wikipedia_tool(query: str) -> str:
+    """
+    This tool receives a query to search inside the Wikipedia website, reads the page and returns the relevant information as a string.
+    Inputs: query as str
+    Outputs: Wikipedia's relevant content as str
+    """
+    print(f"[wiki tool] {query=}")
+    wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())
+    respond = wikipedia.run(query)
+    return respond
+
+
+# pdf
+
+
+# web

x_audio_analysis.ipynb

@@ -0,0 +1,165 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Audio",
+   "id": "8b8c1a352260e82a"
+  },
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2025-06-10T09:38:10.760409Z",
+     "start_time": "2025-06-10T09:38:10.617508Z"
+    }
+   },
+   "source": [
+    "from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor\n",
+    "import torch\n",
+    "import torchaudio.transforms as T\n",
+    "import pydub\n",
+    "import numpy as np"
+   ],
+   "outputs": [],
+   "execution_count": 5
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T09:43:53.684713Z",
+     "start_time": "2025-06-10T09:43:53.681866Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# CONSTANTS\n",
+    "audio_model_dir = './models_for_proj/wav2vec2-base-960h'\n",
+    "\n",
+    "# audio_dir = 'files/1f975693-876d-457b-a649-393859e79bf3.mp3'\n",
+    "audio_dir = 'files/99c9cc74-fdc8-46c6-8f8d-3ce2d3bfeea3.mp3'"
+   ],
+   "id": "3ee50d096b2c9d44",
+   "outputs": [],
+   "execution_count": 19
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T09:43:54.053411Z",
+     "start_time": "2025-06-10T09:43:54.006676Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "\n",
+    "model = Wav2Vec2ForCTC.from_pretrained(audio_model_dir)\n",
+    "processor = Wav2Vec2Processor.from_pretrained(audio_model_dir)"
+   ],
+   "id": "b51a485af7b9cf14",
+   "outputs": [],
+   "execution_count": 20
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T09:43:54.603559Z",
+     "start_time": "2025-06-10T09:43:54.414677Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "def read_mp3(f, normalized=False):\n",
+    "    \"\"\"Read MP3 file to numpy array.\"\"\"\n",
+    "    a = pydub.AudioSegment.from_mp3(f)\n",
+    "    y = np.array(a.get_array_of_samples())\n",
+    "    if a.channels == 2:\n",
+    "        y = y.reshape((-1, 2))\n",
+    "    if normalized:\n",
+    "        return a.frame_rate, np.float32(y) / 2**15\n",
+    "    else:\n",
+    "        return a.frame_rate, y\n",
+    "\n",
+    "# Usage\n",
+    "audio_input_sr, audio_input_np = read_mp3(audio_dir)"
+   ],
+   "id": "ac7e2b43ace4d232",
+   "outputs": [],
+   "execution_count": 21
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T09:43:56.920665Z",
+     "start_time": "2025-06-10T09:43:56.244101Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# --------------------------------------------------------------------------- #\n",
+    "# audio_input_sr, audio_input_np = audio_input\n",
+    "audio_input_t = torch.tensor(audio_input_np, dtype=torch.float32)\n",
+    "target_sr = 16000\n",
+    "resampler = T.Resample(audio_input_sr, target_sr, dtype=audio_input_t.dtype)\n",
+    "resampled_audio_input_t: torch.Tensor = resampler(audio_input_t)\n",
+    "resampled_audio_input_np = resampled_audio_input_t.numpy()\n",
+    "# --------------------------------------------------------------------------- #\n",
+    "# result = asr_pipe_default(resampled_audio_input_np)\n",
+    "inputs = processor(resampled_audio_input_np, sampling_rate=16000, return_tensors=\"pt\", padding=True)\n",
+    "# Inference\n",
+    "with torch.no_grad():\n",
+    "    logits = model(**inputs).logits\n",
+    "# Decode\n",
+    "predicted_ids = torch.argmax(logits, dim=-1)\n",
+    "transcription = processor.decode(predicted_ids[0])\n",
+    "# print(\"Transcription:\", transcription)\n",
+    "transcription"
+   ],
+   "id": "2a4738e9d038985",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'IN A SAUCEPAN COMBINE RIPE STRAWBERRIES GRANULATED SUGAR FRESHLY SQUEEZED LEMON JUICE AND CORNSTARCH COOK THE MIXTURE OF A MEDIUM HEAT STIRRING CONSTANTLY UNTIL IT THICKENS TO A SMOOTH CONSISTENCY REMOVE FROM HEAT AND STIR IN A DASH OF PURE VANILLA EXTRACT ALLOW THE STRAWBERRY PIE FEELING TO COOL BEFORE USING IT AS A DELICIOUS AND FRUITY FILLING FOR YOUR PIE CRUST'"
+      ]
+     },
+     "execution_count": 22,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 22
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "",
+   "id": "f159c2955f140600"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

x_exel_files_loader.ipynb

@@ -0,0 +1,109 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "id": "a49a961ef9dafc8b",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T15:26:54.606280Z",
+     "start_time": "2025-06-10T15:26:54.499875Z"
+    }
+   },
+   "source": "from langchain_community.document_loaders import UnstructuredExcelLoader",
+   "outputs": [],
+   "execution_count": 3
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T15:26:54.806898Z",
+     "start_time": "2025-06-10T15:26:54.804638Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "file_dir = 'files/7bd855d8-463d-4ed5-93ca-5fe35145f733.xlsx'",
+   "id": "7f1454e97563e93",
+   "outputs": [],
+   "execution_count": 4
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T15:29:12.643058Z",
+     "start_time": "2025-06-10T15:29:12.625239Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "\n",
+    "loader = UnstructuredExcelLoader(file_dir, mode=\"elements\")\n",
+    "docs = loader.load()\n",
+    "\n",
+    "print(len(docs))\n",
+    "\n",
+    "# docs"
+   ],
+   "id": "initial_id",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "1\n"
+     ]
+    }
+   ],
+   "execution_count": 7
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T15:32:40.555855Z",
+     "start_time": "2025-06-10T15:32:40.553019Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "print(docs[0].metadata['text_as_html'])",
+   "id": "6c69b91ca45b0039",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "<table><tr><td>Location</td><td>Burgers</td><td>Hot Dogs</td><td>Salads</td><td>Fries</td><td>Ice Cream</td><td>Soda</td></tr><tr><td>Pinebrook</td><td>1594</td><td>1999</td><td>2002</td><td>2005</td><td>1977</td><td>1980</td></tr><tr><td>Wharvton</td><td>1983</td><td>2008</td><td>2014</td><td>2015</td><td>2017</td><td>2018</td></tr><tr><td>Sagrada</td><td>2019</td><td>2022</td><td>2022</td><td>2023</td><td>2021</td><td>2019</td></tr><tr><td>Algrimand</td><td>1958</td><td>1971</td><td>1982</td><td>1989</td><td>1998</td><td>2009</td></tr><tr><td>Marztep</td><td>2015</td><td>2016</td><td>2018</td><td>2019</td><td>2021</td><td>2022</td></tr><tr><td>San Cecelia</td><td>2011</td><td>2010</td><td>2012</td><td>2013</td><td>2015</td><td>2016</td></tr><tr><td>Pimento</td><td>2017</td><td>1999</td><td>2001</td><td>2003</td><td>1969</td><td>2967</td></tr><tr><td>Tinseles</td><td>1967</td><td>1969</td><td>1982</td><td>1994</td><td>2005</td><td>2006</td></tr><tr><td>Rosdale</td><td>2007</td><td>2009</td><td>2021</td><td>1989</td><td>2005</td><td>2011</td></tr></table>\n"
+     ]
+    }
+   ],
+   "execution_count": 11
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "",
+   "id": "29d83c36757726aa"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

x_pic_generation.ipynb

@@ -0,0 +1,92 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Picture generations\n",
+   "id": "d93a01c4260ba9d2"
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true
+   },
+   "outputs": [],
+   "source": [
+    "from together import Together\n",
+    "import os\n",
+    "from langchain_together import ChatTogether\n",
+    "from dotenv import load_dotenv\n",
+    "\n",
+    "load_dotenv()\n",
+    "import base64\n",
+    "\n",
+    "client = Together()\n",
+    "\n",
+    "getDescriptionPrompt = \"what is in the image? describe in detail\"\n",
+    "\n",
+    "imagePath = \"pics/IMG_3651.jpg\"\n",
+    "\n",
+    "\n",
+    "def encode_image(image_path):\n",
+    "    with open(image_path, \"rb\") as image_file:\n",
+    "        return base64.b64encode(image_file.read()).decode('utf-8')\n",
+    "\n",
+    "\n",
+    "base64_image = encode_image(imagePath)\n",
+    "\n",
+    "stream = client.chat.completions.create(\n",
+    "    # model=\"meta-llama/Llama-3.2-11B-Vision-Instruct-Turbo\",\n",
+    "    model=\"meta-llama/Llama-Vision-Free\",\n",
+    "    messages=[\n",
+    "        {\n",
+    "            \"role\": \"user\",\n",
+    "            \"content\": [\n",
+    "                {\"type\": \"text\", \"text\": getDescriptionPrompt},\n",
+    "                {\n",
+    "                    \"type\": \"image_url\",\n",
+    "                    \"image_url\": {\n",
+    "                        \"url\": f\"data:image/jpeg;base64,{base64_image}\",\n",
+    "                    },\n",
+    "                },\n",
+    "            ],\n",
+    "        }\n",
+    "    ],\n",
+    "    stream=False,\n",
+    ")\n",
+    "prompt = stream.choices[0].message.content\n",
+    "\n",
+    "response = client.images.generate(\n",
+    "    prompt=prompt,\n",
+    "    model=\"black-forest-labs/FLUX.1-schnell-Free\",\n",
+    "    steps=4,\n",
+    "    n=4\n",
+    ")\n",
+    "print(response.data[0].url)"
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

x_python_code_executor.ipynb

@@ -0,0 +1,200 @@
+{
+ "cells": [
+  {
+   "metadata": {},
+   "cell_type": "markdown",
+   "source": "Python Code Executor",
+   "id": "f96e89bb67a640f5"
+  },
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2025-06-10T15:11:36.621661Z",
+     "start_time": "2025-06-10T15:11:36.617741Z"
+    }
+   },
+   "source": [
+    "from langchain_core.tools import Tool\n",
+    "from langchain_experimental.utilities import PythonREPL\n",
+    "import subprocess"
+   ],
+   "outputs": [],
+   "execution_count": 10
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T14:54:42.141759Z",
+     "start_time": "2025-06-10T14:54:42.138854Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "file_dir = 'files/f918266a-b3e0-4914-865d-4faa564f1aef.py'",
+   "id": "1f0aed71e203012d",
+   "outputs": [],
+   "execution_count": 6
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T14:44:45.063803Z",
+     "start_time": "2025-06-10T14:44:45.061618Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "python_repl = PythonREPL()",
+   "id": "acea852beeb1035e",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T14:55:05.802715Z",
+     "start_time": "2025-06-10T14:55:05.797934Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "\n",
+    "with open(file_dir, \"r\", encoding=\"utf-8\") as f:\n",
+    "    code = f.read()\n",
+    "    print(code)\n"
+   ],
+   "id": "620b184072e95086",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "from random import randint\n",
+      "import time\n",
+      "\n",
+      "class UhOh(Exception):\n",
+      "    pass\n",
+      "\n",
+      "class Hmm:\n",
+      "    def __init__(self):\n",
+      "        self.value = randint(-100, 100)\n",
+      "\n",
+      "    def Yeah(self):\n",
+      "        if self.value == 0:\n",
+      "            return True\n",
+      "        else:\n",
+      "            raise UhOh()\n",
+      "\n",
+      "def Okay():\n",
+      "    while True:\n",
+      "        yield Hmm()\n",
+      "\n",
+      "def keep_trying(go, first_try=True):\n",
+      "    maybe = next(go)\n",
+      "    try:\n",
+      "        if maybe.Yeah():\n",
+      "            return maybe.value\n",
+      "    except UhOh:\n",
+      "        if first_try:\n",
+      "            print(\"Working...\")\n",
+      "            print(\"Please wait patiently...\")\n",
+      "        time.sleep(0.1)\n",
+      "        return keep_trying(go, first_try=False)\n",
+      "\n",
+      "if __name__ == \"__main__\":\n",
+      "    go = Okay()\n",
+      "    print(f\"{keep_trying(go)}\")\n",
+      "\n"
+     ]
+    }
+   ],
+   "execution_count": 8
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T14:55:08.665931Z",
+     "start_time": "2025-06-10T14:55:08.661026Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "print(python_repl.run(code))",
+   "id": "c55e78888adc58f2",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "\n"
+     ]
+    }
+   ],
+   "execution_count": 9
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T15:13:00.580769Z",
+     "start_time": "2025-06-10T15:12:56.064064Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "def run_as_main(filename):\n",
+    "    result = subprocess.run([\"python\", filename], capture_output=True, text=True)\n",
+    "    return result.stdout\n",
+    "print(run_as_main(file_dir))"
+   ],
+   "id": "c7b145cdb13aea01",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "Working...\n",
+      "Please wait patiently...\n",
+      "0\n",
+      "\n"
+     ]
+    }
+   ],
+   "execution_count": 13
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": [
+    "repl_tool = Tool(\n",
+    "    name=\"python_repl\",\n",
+    "    description=\"A Python shell. Use this to execute python commands. Input should be a valid python command. If you want to see the output of a value, you should print it out with `print(...)`.\",\n",
+    "    func=python_repl.run,\n",
+    ")"
+   ],
+   "id": "1789b291aa070b8b"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

x_wikipedia.ipynb

@@ -0,0 +1,90 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "id": "initial_id",
+   "metadata": {
+    "collapsed": true,
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:45:09.274873Z",
+     "start_time": "2025-06-10T20:45:08.953896Z"
+    }
+   },
+   "source": [
+    "from langchain_community.tools import WikipediaQueryRun\n",
+    "from langchain_community.utilities import WikipediaAPIWrapper"
+   ],
+   "outputs": [],
+   "execution_count": 1
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:45:16.805090Z",
+     "start_time": "2025-06-10T20:45:16.743407Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "wikipedia = WikipediaQueryRun(api_wrapper=WikipediaAPIWrapper())",
+   "id": "516d65340769e70b",
+   "outputs": [],
+   "execution_count": 2
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:49:46.749788Z",
+     "start_time": "2025-06-10T20:49:43.387220Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "respond = wikipedia.run(\"HUNTER X HUNTER\")\n",
+    "respond"
+   ],
+   "id": "c54ff01d863ca54f",
+   "outputs": [
+    {
+     "data": {
+      "text/plain": [
+       "'Page: Hunter × Hunter\\nSummary: Hunter × Hunter (pronounced \"hunter hunter\") is a Japanese manga series written and illustrated by Yoshihiro Togashi. It has been serialized in Shueisha\\'s shōnen manga magazine Weekly Shōnen Jump since March 1998, although the manga has frequently gone on extended hiatuses since 2006. Its chapters have been collected in 38 tankōbon volumes as of September 2024. The story focuses on a young boy named Gon Freecss who discovers that his father, who left him at a young age, is actually a world-renowned Hunter, a licensed professional who specializes in fantastical pursuits such as locating rare or unidentified animal species, treasure hunting, surveying unexplored enclaves, or hunting down lawless individuals. Gon departs on a journey to become a Hunter and eventually find his father. Along the way, Gon meets various other Hunters and encounters the paranormal.\\nHunter × Hunter was adapted into a 62-episode anime television series by Nippon Animation and directed by Kazuhiro Furuhashi, which ran on Fuji Television from October 1999 to March 2001. Three separate original video animations (OVAs) totaling 30 episodes were subsequently produced by Nippon Animation and released in Japan from 2002 to 2004. A second anime television series by Madhouse aired on Nippon Television from October 2011 to September 2014, totaling 148 episodes, with two animated theatrical films released in 2013. There are also numerous audio albums, video games, musicals, and other media based on Hunter × Hunter.\\nThe manga has been licensed for English release in North America by Viz Media since April 2005. Both television series have been also licensed by Viz Media, with the first series having aired on the Funimation Channel in 2009 and the second series broadcast on Adult Swim\\'s Toonami programming block from April 2016 to June 2019.\\nHunter × Hunter has been a huge critical and financial success and has become one of the best-selling manga series of all time, having over 84 million copies in circulation by July 2022.\\n\\n\\n\\nPage: Hunter × Hunter (2011 TV series)\\nSummary: Hunter × Hunter is an anime television series that aired from 2011 to 2014 based on Yoshihiro Togashi\\'s manga series Hunter × Hunter. The story begins with a young boy named Gon Freecss, who one day discovers that the father who he thought was dead, is in fact alive and well. He learns that his father, Ging, is a legendary \"Hunter\", an individual who has proven themselves an elite member of humanity. Despite the fact that Ging left his son with his relatives in order to pursue his own dreams, Gon becomes determined to follow in his father\\'s footsteps, pass the rigorous \"Hunter Examination\", and eventually find his father to become a Hunter in his own right.\\nThis second anime television series adaptation of Hunter × Hunter was announced on July 24, 2011. It is a complete reboot starting from the beginning of the original manga, with no connection to the first anime television series from 1999. Produced by Nippon TV, VAP, Shueisha and Madhouse, the series is directed by Hiroshi Kōjina, with Atsushi Maekawa and Tsutomu Kamishiro handling series composition, Takahiro Yoshimatsu designing the characters and Yoshihisa Hirano composing the music. Instead of having the old cast reprise their roles for the new adaptation, the series features an entirely new cast to voice the characters. The new series premiered airing weekly on Nippon TV and the nationwide Nippon News Network from October 2, 2011.  The series started to be collected in both DVD and Blu-ray format on January 25, 2012. Viz Media has licensed the anime for a DVD/Blu-ray release in North America with an English dub. On television, the series began airing on Adult Swim\\'s Toonami programming block on April 17, 2016, and ended on June 23, 2019.\\nThe anime series\\' opening theme is alternated between the song \"Departure!\" and an alternate version titled \"Departure! -Second Version-\" both sung by Galneryus\\' vocalist Ma'"
+      ]
+     },
+     "execution_count": 4,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 4
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "",
+   "id": "b5d559230ecc3190"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}

x_youtube_loader.ipynb

@@ -0,0 +1,347 @@
+{
+ "cells": [
+  {
+   "cell_type": "code",
+   "id": "6369bdabdf59b658",
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:28:20.833977Z",
+     "start_time": "2025-06-10T20:28:14.932967Z"
+    }
+   },
+   "source": [
+    "from langchain.document_loaders import YoutubeLoader\n",
+    "from langchain_yt_dlp.youtube_loader import YoutubeLoaderDL\n",
+    "from globals import *\n",
+    "import torch\n",
+    "import torchaudio.transforms as T\n",
+    "import pydub\n",
+    "import numpy as np\n",
+    "from transformers import Wav2Vec2ForCTC, Wav2Vec2Processor"
+   ],
+   "outputs": [],
+   "execution_count": 33
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:05:04.414620Z",
+     "start_time": "2025-06-10T20:05:04.412354Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "url = \"https://www.youtube.com/watch?v=1htKBjuUWec\"\n",
+   "id": "666e521f8ecf3f47",
+   "outputs": [],
+   "execution_count": 14
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:26:57.491908Z",
+     "start_time": "2025-06-10T20:26:57.489481Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# Load transcript as LangChain Documents\n",
+    "# loader = YoutubeLoader.from_youtube_url(url, add_video_info=False)\n",
+    "# loader = YoutubeLoaderDL.from_youtube_url(\n",
+    "#     url, add_video_info=True\n",
+    "# )\n",
+    "# docs = loader.load()\n",
+    "#\n",
+    "# # Print the transcript content\n",
+    "# for doc in docs:\n",
+    "#     print(doc.page_content)\n",
+    "\n",
+    "# Optionally, save to a file\n",
+    "# with open(\"transcript.txt\", \"w\", encoding=\"utf-8\") as f:\n",
+    "#     for doc in docs:\n",
+    "#         f.write(doc.page_content)"
+   ],
+   "id": "initial_id",
+   "outputs": [],
+   "execution_count": 30
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:27:03.519450Z",
+     "start_time": "2025-06-10T20:27:03.517474Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "# from pytube import YouTube\n",
+    "#\n",
+    "# yt = YouTube(url)\n",
+    "#\n",
+    "# # Download the audio stream (usually mp4)\n",
+    "# stream = yt.streams.filter(only_audio=True).first()\n",
+    "# stream.download(firstilename=f\"{yt.title}.mp3\")"
+   ],
+   "id": "ec4885c3a15d9a2b",
+   "outputs": [],
+   "execution_count": 31
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:04:18.601366Z",
+     "start_time": "2025-06-10T20:04:18.597488Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "import ssl\n",
+    "import certifi\n",
+    "# Correct: assign a lambda (function) that returns a properly configured SSL context\n",
+    "ssl._create_default_https_context = lambda: ssl.create_default_context(cafile=certifi.where())"
+   ],
+   "id": "167af702547c15e4",
+   "outputs": [],
+   "execution_count": 12
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:07:53.667018Z",
+     "start_time": "2025-06-10T20:07:52.627871Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "\n",
+    "from pytube import YouTube\n",
+    "\n",
+    "def download_video(url, output_path='.'):\n",
+    "    try:\n",
+    "        yt = YouTube(url)\n",
+    "        print('here')\n",
+    "        stream = yt.streams.get_highest_resolution()\n",
+    "        print(f\"Downloading: {yt.title}\")\n",
+    "        stream.download(output_path=output_path)\n",
+    "        print(\"Download completed.\")\n",
+    "    except Exception as e:\n",
+    "        print(f\"Error: {e}\")\n",
+    "\n",
+    "# Example usage\n",
+    "download_video(url)"
+   ],
+   "id": "289b9a4321ea487b",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "here\n",
+      "Error: HTTP Error 400: Bad Request\n"
+     ]
+    }
+   ],
+   "execution_count": 23
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:08:47.590897Z",
+     "start_time": "2025-06-10T20:08:44.115350Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "import yt_dlp\n",
+    "\n",
+    "ydl_opts = {\n",
+    "    'format': 'best',  # or 'bestvideo+bestaudio'\n",
+    "    'outtmpl': '%(title)s.%(ext)s',  # save as video title\n",
+    "}\n",
+    "\n",
+    "with yt_dlp.YoutubeDL(ydl_opts) as ydl:\n",
+    "    ydl.download([url])"
+   ],
+   "id": "4eb045792318e67a",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[youtube] Extracting URL: https://www.youtube.com/watch?v=1htKBjuUWec\n",
+      "[youtube] 1htKBjuUWec: Downloading webpage\n",
+      "[youtube] 1htKBjuUWec: Downloading tv client config\n",
+      "[youtube] 1htKBjuUWec: Downloading tv player API JSON\n",
+      "[youtube] 1htKBjuUWec: Downloading ios player API JSON\n",
+      "[youtube] 1htKBjuUWec: Downloading m3u8 information\n",
+      "[info] 1htKBjuUWec: Downloading 1 format(s): 18\n",
+      "[download] Destination: Teal'c coffee first time.mp4\n",
+      "[download] 100% of    1.19MiB in 00:00:01 at 1.09MiB/s   \n"
+     ]
+    }
+   ],
+   "execution_count": 24
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:22:32.706482Z",
+     "start_time": "2025-06-10T20:22:29.843517Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "import yt_dlp\n",
+    "\n",
+    "file_name = 'my_audio_file'\n",
+    "ydl_opts = {\n",
+    "    'format': 'bestaudio/best',\n",
+    "    'outtmpl': f'files/{file_name}.%(ext)s',  # <-- set your custom filename here\n",
+    "    'postprocessors': [{\n",
+    "        'key': 'FFmpegExtractAudio',\n",
+    "        'preferredcodec': 'mp3',\n",
+    "        'preferredquality': '192',\n",
+    "    }],\n",
+    "}\n",
+    "\n",
+    "with yt_dlp.YoutubeDL(ydl_opts) as ydl:\n",
+    "    ydl.download([url])"
+   ],
+   "id": "68b51ca78254d8f",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "[youtube] Extracting URL: https://www.youtube.com/watch?v=1htKBjuUWec\n",
+      "[youtube] 1htKBjuUWec: Downloading webpage\n",
+      "[youtube] 1htKBjuUWec: Downloading tv client config\n",
+      "[youtube] 1htKBjuUWec: Downloading tv player API JSON\n",
+      "[youtube] 1htKBjuUWec: Downloading ios player API JSON\n",
+      "[youtube] 1htKBjuUWec: Downloading m3u8 information\n",
+      "[info] 1htKBjuUWec: Downloading 1 format(s): 251\n",
+      "[download] Destination: files/my_audio_file.webm\n",
+      "[download] 100% of  444.93KiB in 00:00:00 at 3.41MiB/s     \n",
+      "[ExtractAudio] Destination: files/my_audio_file.mp3\n",
+      "Deleting original file files/my_audio_file.webm (pass -k to keep)\n"
+     ]
+    }
+   ],
+   "execution_count": 26
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:35:23.558866Z",
+     "start_time": "2025-06-10T20:35:23.515883Z"
+    }
+   },
+   "cell_type": "code",
+   "source": [
+    "audio_model_dir = './models_for_proj/wav2vec2-base-960h'\n",
+    "model = Wav2Vec2ForCTC.from_pretrained(audio_model_dir)\n",
+    "processor = Wav2Vec2Processor.from_pretrained(audio_model_dir)\n",
+    "\n",
+    "def read_mp3(f, normalized=False):\n",
+    "    \"\"\"Read MP3 file to numpy array.\"\"\"\n",
+    "    a = pydub.AudioSegment.from_mp3(f)\n",
+    "    y = np.array(a.get_array_of_samples())\n",
+    "    if a.channels == 2:\n",
+    "        y = y.reshape((-1, 2))\n",
+    "        # y = y.mean(axis=1)\n",
+    "        y = y[:,1]\n",
+    "    if normalized:\n",
+    "        return a.frame_rate, np.float32(y) / 2**15\n",
+    "    else:\n",
+    "        return a.frame_rate, y\n",
+    "\n",
+    "def describe_audio_tool(file_name: str) -> str:\n",
+    "    \"\"\"\n",
+    "    This tool receives a file name of an audio, uploads the audio and returns a detailed description of the audio.\n",
+    "    Inputs: file_name as str\n",
+    "    Outputs: audio detailed description as str\n",
+    "    \"\"\"\n",
+    "    # --------------------------------------------------------------------------- #\n",
+    "    file_dir = f'files/{file_name}'\n",
+    "    print(f\"{file_dir=}\")\n",
+    "    audio_input_sr, audio_input_np = read_mp3(file_dir)\n",
+    "    audio_input_t = torch.tensor(audio_input_np, dtype=torch.float32)\n",
+    "    target_sr = 16000\n",
+    "    resampler = T.Resample(audio_input_sr, target_sr, dtype=audio_input_t.dtype)\n",
+    "    resampled_audio_input_t: torch.Tensor = resampler(audio_input_t)\n",
+    "    resampled_audio_input_np = resampled_audio_input_t.numpy()\n",
+    "    # --------------------------------------------------------------------------- #\n",
+    "    inputs = processor(resampled_audio_input_np, sampling_rate=16000, return_tensors=\"pt\", padding=True)\n",
+    "    # Inference\n",
+    "    with torch.no_grad():\n",
+    "        logits = model(**inputs).logits\n",
+    "    # Decode\n",
+    "    predicted_ids = torch.argmax(logits, dim=-1)\n",
+    "    transcription = processor.decode(predicted_ids[0])\n",
+    "    return transcription"
+   ],
+   "id": "64f438af2b38765f",
+   "outputs": [],
+   "execution_count": 43
+  },
+  {
+   "metadata": {
+    "ExecuteTime": {
+     "end_time": "2025-06-10T20:35:27.235493Z",
+     "start_time": "2025-06-10T20:35:26.202459Z"
+    }
+   },
+   "cell_type": "code",
+   "source": "describe_audio_tool(file_name=f'{file_name}.mp3')",
+   "id": "b4a6ae10e1cbbcae",
+   "outputs": [
+    {
+     "name": "stdout",
+     "output_type": "stream",
+     "text": [
+      "file_dir='files/my_audio_file.mp3'\n"
+     ]
+    },
+    {
+     "data": {
+      "text/plain": [
+       "\"ALIS COFFEE'S GRAY WO IS JUST THINKING  YET HE TAT SOMESCHICKERY A CHIC TEK H IS NOT HOT EXTREMELY\""
+      ]
+     },
+     "execution_count": 44,
+     "metadata": {},
+     "output_type": "execute_result"
+    }
+   ],
+   "execution_count": 44
+  },
+  {
+   "metadata": {},
+   "cell_type": "code",
+   "outputs": [],
+   "execution_count": null,
+   "source": "",
+   "id": "ce9aaf764346b7e4"
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 2
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython2",
+   "version": "2.7.6"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 5
+}