diff --git a/.github/workflows/quality.yml b/.github/workflows/quality.yml index 37749d759..2e4f5c67f 100644 --- a/.github/workflows/quality.yml +++ b/.github/workflows/quality.yml @@ -13,7 +13,7 @@ jobs: - name: Set up Python uses: actions/setup-python@v2 with: - python-version: "3.10" + python-version: "3.12" # Setup venv # TODO: revisit when https://github.com/astral-sh/uv/issues/1526 is addressed. diff --git a/README.md b/README.md index 1383c13c5..368283269 100644 --- a/README.md +++ b/README.md @@ -38,6 +38,8 @@ limitations under the License. 🌐 **Support for any LLM**: it supports models hosted on the Hub loaded in their `transformers` version or through our inference API, but also supports models from OpenAI, Anthropic and many others via our [LiteLLM](https://www.litellm.ai/) integration. +Full documentation can be found [here](https://huggingface.co/docs/smolagents/index). + > [!NOTE] > Check the our [launch blog post](https://huggingface.co/blog/smolagents) to learn more about `smolagents`! diff --git a/docs/source/en/examples/multiagents.md b/docs/source/en/examples/multiagents.md index 4ea4e51b2..7901de2b6 100644 --- a/docs/source/en/examples/multiagents.md +++ b/docs/source/en/examples/multiagents.md @@ -48,10 +48,10 @@ Run the line below to install the required dependencies: Let's login in order to call the HF Inference API: -```py -from huggingface_hub import notebook_login +``` +from huggingface_hub import login -notebook_login() +login() ``` ⚡️ Our agent will be powered by [Qwen/Qwen2.5-Coder-32B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct) using `HfApiModel` class that uses HF's Inference API: the Inference API allows to quickly and easily run any OS model. diff --git a/docs/source/en/examples/rag.md b/docs/source/en/examples/rag.md index acbdf14f6..46ae7b785 100644 --- a/docs/source/en/examples/rag.md +++ b/docs/source/en/examples/rag.md @@ -137,7 +137,7 @@ _Note:_ The Inference API hosts models based on various criteria, and deployed m from smolagents import HfApiModel, CodeAgent agent = CodeAgent( - tools=[retriever_tool], model=HfApiModel("meta-llama/Llama-3.3-70B-Instruct"), max_steps=4, verbose=True + tools=[retriever_tool], model=HfApiModel("meta-llama/Llama-3.3-70B-Instruct"), max_steps=4, verbosity_level=2 ) ``` diff --git a/docs/source/en/guided_tour.md b/docs/source/en/guided_tour.md index 4e2fe44d4..b44d1a882 100644 --- a/docs/source/en/guided_tour.md +++ b/docs/source/en/guided_tour.md @@ -113,8 +113,7 @@ The Python interpreter also doesn't allow imports by default outside of a safe l You can authorize additional imports by passing the authorized modules as a list of strings in argument `additional_authorized_imports` upon initialization of your [`CodeAgent`]: ```py -from smolagents import CodeAgent - +model = HfApiModel() agent = CodeAgent(tools=[], model=model, additional_authorized_imports=['requests', 'bs4']) agent.run("Could you get me the title of the page at url 'https://huggingface.co/blog'?") ``` @@ -161,15 +160,15 @@ When the agent is initialized, the tool attributes are used to generate a tool d Transformers comes with a default toolbox for empowering agents, that you can add to your agent upon initialization with argument `add_base_tools = True`: - **DuckDuckGo web search***: performs a web search using DuckDuckGo browser. -- **Python code interpreter**: runs your the LLM generated Python code in a secure environment. This tool will only be added to [`ToolCallingAgent`] if you initialize it with `add_base_tools=True`, since code-based agent can already natively execute Python code +- **Python code interpreter**: runs your LLM generated Python code in a secure environment. This tool will only be added to [`ToolCallingAgent`] if you initialize it with `add_base_tools=True`, since code-based agent can already natively execute Python code - **Transcriber**: a speech-to-text pipeline built on Whisper-Turbo that transcribes an audio to text. -You can manually use a tool by calling the [`load_tool`] function and a task to perform. +You can manually use a tool by calling it with its arguments. ```python -from smolagents import load_tool +from smolagents import DuckDuckGoSearchTool -search_tool = load_tool("web_search") +search_tool = DuckDuckGoSearchTool() print(search_tool("Who's the current president of Russia?")) ``` diff --git a/docs/source/en/index.md b/docs/source/en/index.md index 7392cfc4a..fbcfba065 100644 --- a/docs/source/en/index.md +++ b/docs/source/en/index.md @@ -15,7 +15,7 @@ rendered properly in your Markdown viewer. # `smolagents` -This library is the simplest framework out there to build powerful agents! By the way, wtf are "agents"? We provide our definition [in this page](conceptual_guides/intro_agents), whe're you'll also find tips for when to use them or not (spoilers: you'll often be better off without agents). +This library is the simplest framework out there to build powerful agents! By the way, wtf are "agents"? We provide our definition [in this page](conceptual_guides/intro_agents), where you'll also find tips for when to use them or not (spoilers: you'll often be better off without agents). This library offers: diff --git a/docs/source/en/reference/tools.md b/docs/source/en/reference/tools.md index 41064c4ec..022ad35d2 100644 --- a/docs/source/en/reference/tools.md +++ b/docs/source/en/reference/tools.md @@ -39,10 +39,6 @@ contains the API docs for the underlying classes. [[autodoc]] Tool -### Toolbox - -[[autodoc]] Toolbox - ### launch_gradio_demo [[autodoc]] launch_gradio_demo diff --git a/docs/source/en/tutorials/secure_code_execution.md b/docs/source/en/tutorials/secure_code_execution.md index d8a6109ae..60887f63a 100644 --- a/docs/source/en/tutorials/secure_code_execution.md +++ b/docs/source/en/tutorials/secure_code_execution.md @@ -30,7 +30,7 @@ Code is just a better way to express actions on a computer. It has better: - **Composability:** could you nest JSON actions within each other, or define a set of JSON actions to re-use later, the same way you could just define a python function? - **Object management:** how do you store the output of an action like `generate_image` in JSON? - **Generality:** code is built to express simply anything you can do have a computer do. -- **Representation in LLM training corpuses:** why not leverage this benediction of the sky that plenty of quality actions have already been included in LLM training corpuses? +- **Representation in LLM training corpus:** why not leverage this benediction of the sky that plenty of quality actions have already been included in LLM training corpus? This is illustrated on the figure below, taken from [Executable Code Actions Elicit Better LLM Agents](https://huggingface.co/papers/2402.01030). diff --git a/docs/source/en/tutorials/tools.md b/docs/source/en/tutorials/tools.md index c86da5736..bcaaa0f4a 100644 --- a/docs/source/en/tutorials/tools.md +++ b/docs/source/en/tutorials/tools.md @@ -177,7 +177,7 @@ agent.run("How many more blocks (also denoted as layers) are in BERT base encode ### Manage your agent's toolbox -You can manage an agent's toolbox by adding or replacing a tool. +You can manage an agent's toolbox by adding or replacing a tool in attribute `agent.tools`, since it is a standard dictionary. Let's add the `model_download_tool` to an existing agent initialized with only the default toolbox. @@ -187,7 +187,7 @@ from smolagents import HfApiModel model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct") agent = CodeAgent(tools=[], model=model, add_base_tools=True) -agent.toolbox.add_tool(model_download_tool) +agent.tools[model_download_tool.name] = model_download_tool ``` Now we can leverage the new tool: @@ -202,11 +202,6 @@ agent.run( > Beware of not adding too many tools to an agent: this can overwhelm weaker LLM engines. -Use the `agent.toolbox.update_tool()` method to replace an existing tool in the agent's toolbox. -This is useful if your new tool is a one-to-one replacement of the existing tool because the agent already knows how to perform that specific task. -Just make sure the new tool follows the same API as the replaced tool or adapt the system prompt template to ensure all examples using the replaced tool are updated. - - ### Use a collection of tools You can leverage tool collections by using the ToolCollection object, with the slug of the collection you want to use. diff --git a/examples/benchmark.ipynb b/examples/benchmark.ipynb index ff3b5a225..7a7b776e5 100644 --- a/examples/benchmark.ipynb +++ b/examples/benchmark.ipynb @@ -21,15 +21,13 @@ }, { "cell_type": "code", - "execution_count": 1, + "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/Users/aymeric/venv/test/lib/python3.12/site-packages/tqdm/auto.py:21: TqdmWarning: IProgress not found. Please update jupyter and ipywidgets. See https://ipywidgets.readthedocs.io/en/stable/user_install.html\n", - " from .autonotebook import tqdm as notebook_tqdm\n", "Using the latest cached version of the dataset since m-ric/smolagentsbenchmark couldn't be found on the Hugging Face Hub\n", "Found the latest cached dataset configuration 'default' at /Users/aymeric/.cache/huggingface/datasets/m-ric___smolagentsbenchmark/default/0.0.0/0ad5fb2293ab185eece723a4ac0e4a7188f71add (last modified on Wed Jan 8 17:50:13 2025).\n" ] @@ -174,7 +172,7 @@ "[132 rows x 4 columns]" ] }, - "execution_count": 1, + "execution_count": 3, "metadata": {}, "output_type": "execute_result" } @@ -197,19 +195,9 @@ }, { "cell_type": "code", - "execution_count": 2, + "execution_count": 4, "metadata": {}, - "outputs": [ - { - "name": "stderr", - "output_type": "stream", - "text": [ - "/Users/aymeric/venv/test/lib/python3.12/site-packages/pydantic/_internal/_config.py:345: UserWarning: Valid config keys have changed in V2:\n", - "* 'fields' has been removed\n", - " warnings.warn(message, UserWarning)\n" - ] - } - ], + "outputs": [], "source": [ "import time\n", "import json\n", @@ -243,7 +231,9 @@ " return str(obj)\n", "\n", "\n", - "def answer_questions(eval_ds, file_name, agent, model_id, action_type):\n", + "def answer_questions(\n", + " eval_ds, file_name, agent, model_id, action_type, is_vanilla_llm=False\n", + "):\n", " answered_questions = []\n", " if os.path.exists(file_name):\n", " with open(file_name, \"r\") as f:\n", @@ -260,17 +250,22 @@ " if question in answered_questions:\n", " continue\n", " start_time = time.time()\n", - " answer = agent.run(question)\n", - " end_time = time.time()\n", - " for step_log in agent.logs:\n", - " if hasattr(step_log, \"memory\"):\n", - " step_log.memory = None\n", "\n", - " # Remove memory from logs to make them more compact.\n", - " for step in agent.logs:\n", - " if isinstance(step, ActionStep):\n", - " step.agent_memory = None\n", + " if is_vanilla_llm:\n", + " llm = agent\n", + " answer = llm([{\"role\": \"user\", \"content\": question}])\n", + " token_count = llm.last_input_token_count + llm.last_output_token_count\n", + " intermediate_steps = []\n", + " else:\n", + " answer = agent.run(question)\n", + " token_count = agent.monitor.get_total_token_counts()\n", + " intermediate_steps = str(agent.logs)\n", + " # Remove memory from logs to make them more compact.\n", + " for step in agent.logs:\n", + " if isinstance(step, ActionStep):\n", + " step.agent_memory = None\n", "\n", + " end_time = time.time()\n", " annotated_example = {\n", " \"model_id\": model_id,\n", " \"agent_action_type\": action_type,\n", @@ -278,10 +273,10 @@ " \"answer\": answer,\n", " \"true_answer\": example[\"true_answer\"],\n", " \"source\": example[\"source\"],\n", - " \"intermediate_steps\": str(agent.logs),\n", + " \"intermediate_steps\": intermediate_steps,\n", " \"start_time\": start_time,\n", " \"end_time\": end_time,\n", - " \"token_counts\": agent.monitor.get_total_token_counts(),\n", + " \"token_counts\": token_count,\n", " }\n", "\n", " with open(file_name, \"a\") as f:\n", @@ -394,7 +389,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "## Run benchmark\n", + "## Benchmark agents\n", "\n", "### Open models" ] @@ -412,6 +407,7 @@ " \"Qwen/Qwen2.5-Coder-32B-Instruct\",\n", " \"meta-llama/Llama-3.2-3B-Instruct\",\n", " \"meta-llama/Llama-3.1-8B-Instruct\",\n", + " \"mistralai/Mistral-Nemo-Instruct-2407\",\n", " # \"HuggingFaceTB/SmolLM2-1.7B-Instruct\",\n", " # \"meta-llama/Llama-3.1-70B-Instruct\",\n", "]\n", @@ -435,7 +431,15 @@ " max_steps=10,\n", " )\n", " file_name = f\"output/{model_id.replace('/', '_')}-{action_type}-26-dec-2024.jsonl\"\n", - " answer_questions(eval_ds, file_name, agent, model_id, action_type)" + " answer_questions(eval_ds, file_name, agent, model_id, action_type)\n", + "\n", + " # Also evaluate vanilla model\n", + " action_type = \"vanilla\"\n", + " llm = HfApiModel(model_id)\n", + " file_name = f\"output/{model_id.replace('/', '_')}-{action_type}-26-dec-2024.jsonl\"\n", + " answer_questions(\n", + " eval_ds, file_name, llm, model_id, action_type, is_vanilla_llm=True\n", + " )" ] }, { @@ -478,45 +482,22 @@ " max_steps=10,\n", " )\n", " file_name = f\"output/{model_id.replace('/', '_')}-{action_type}-26-dec-2024.jsonl\"\n", - " answer_questions(eval_ds, file_name, agent, model_id, action_type)" + " answer_questions(eval_ds, file_name, agent, model_id, action_type)\n", + "\n", + " # Also evaluate vanilla model\n", + " action_type = \"vanilla\"\n", + " llm = LiteLLMModel(model_id)\n", + " file_name = f\"output/{model_id.replace('/', '_')}-{action_type}-26-dec-2024.jsonl\"\n", + " answer_questions(\n", + " eval_ds, file_name, llm, model_id, action_type, is_vanilla_llm=True\n", + " )" ] }, { "cell_type": "code", - "execution_count": 3, + "execution_count": 23, "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "output/Qwen_Qwen2.5-Coder-32B-Instruct-code-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/meta-llama_Llama-3.3-70B-Instruct-code-26-dec-2024.jsonl\n", - "Removed 124 lines.\n", - "output/Qwen_Qwen2.5-72B-Instruct-code-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/anthropic_claude-3-5-sonnet-latest-tool_calling-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/meta-llama_Llama-3.3-70B-Instruct-tool_calling-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/anthropic_claude-3-5-sonnet-latest-code-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/Qwen_Qwen2.5-72B-Instruct-tool_calling-26-dec-2024.jsonl\n", - "Removed 99 lines.\n", - "output/HuggingFaceTB_SmolLM2-1.7B-Instruct-code-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/gpt-4o-code-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/meta-llama_Llama-3.1-70B-Instruct-code-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/meta-llama_Llama-3.2-3B-Instruct-code-26-dec-2024.jsonl\n", - "Removed 109 lines.\n", - "output/gpt-4o-tool_calling-26-dec-2024.jsonl\n", - "Removed 109 lines.\n" - ] - } - ], + "outputs": [], "source": [ "# import glob\n", "# import json\n", @@ -553,17 +534,15 @@ }, { "cell_type": "code", - "execution_count": 66, + "execution_count": 31, "metadata": {}, "outputs": [ { "name": "stderr", "output_type": "stream", "text": [ - "/var/folders/6m/9b1tts6d5w960j80wbw9tx3m0000gn/T/ipykernel_17219/1724525657.py:154: UserWarning:\n", - "\n", - "Answer lists have different lengths, returning False.\n", - "\n" + "/var/folders/6m/9b1tts6d5w960j80wbw9tx3m0000gn/T/ipykernel_74415/3026956094.py:163: UserWarning: Answer lists have different lengths, returning False.\n", + " warnings.warn(\n" ] } ], @@ -572,13 +551,15 @@ "import glob\n", "\n", "res = []\n", - "for f in glob.glob(\"output/*.jsonl\"):\n", - " res.append(pd.read_json(f, lines=True))\n", + "for file_path in glob.glob(\"output/*.jsonl\"):\n", + " smoldf = pd.read_json(file_path, lines=True)\n", + " smoldf[\"action_type\"] = \"vanilla\" if \"-vanilla-\" in file_path else \"code\"\n", + " res.append(smoldf)\n", "result_df = pd.concat(res)\n", "\n", "\n", "def get_correct(row):\n", - " if row[\"source\"] == \"MATH\":\n", + " if row[\"source\"] == \"MATH\": # Checks the last number in answer\n", " numbers_answer = extract_numbers(str(row[\"answer\"]))\n", " if len(numbers_answer) == 0:\n", " return False\n", @@ -589,74 +570,27 @@ "\n", "result_df[\"correct\"] = result_df.apply(get_correct, axis=1)\n", "\n", - "result_df = result_df.loc[\n", - " (result_df[\"agent_action_type\"] == \"code\")\n", - " & (\n", - " ~result_df[\"model_id\"].isin(\n", - " [\n", - " \"meta-llama/Llama-3.2-3B-Instruct\",\n", - " \"meta-llama/Llama-3.1-70B-Instruct\",\n", - " \"HuggingFaceTB/SmolLM2-1.7B-Instruct\",\n", - " ]\n", - " )\n", - " )\n", - "]\n", "result_df = (\n", - " (result_df.groupby([\"model_id\", \"source\"])[[\"correct\"]].mean() * 100)\n", + " (result_df.groupby([\"model_id\", \"source\", \"action_type\"])[[\"correct\"]].mean() * 100)\n", " .round(1)\n", " .reset_index()\n", - ")\n", - "result_df[\"type\"] = \"agent\"" + ")" ] }, { "cell_type": "code", - "execution_count": 67, + "execution_count": 33, "metadata": {}, "outputs": [], "source": [ - "vanilla_data = [\n", - " [\"gpt-4o\", \"SimpleQA\", 38.2],\n", - " [\"gpt-4o\", \"GAIA\", 9.3],\n", - " [\"Qwen/Qwen2.5-72B-Instruct\", \"SimpleQA\", 9.1],\n", - " [\"anthropic/claude-3-5-sonnet-latest\", \"SimpleQA\", 28.4],\n", - " [\"gpt-4o\", \"GSM8K\", 94.3],\n", - " [\"anthropic/claude-3-5-sonnet-latest\", \"GSM8K\", 96.4],\n", - " [\"meta-llama/Llama-3.3-70B-Instruct\", \"GSM8K\", 95.1],\n", - " [\n", - " \"meta-llama/Llama-3.3-70B-Instruct\",\n", - " \"MATH\",\n", - " 30.7,\n", - " ], # As per Open LLM Leaderboard for 3.1, score for 3.3 is too low. https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard#/?search=llama-3.1\n", - " [\n", - " \"Qwen/Qwen2.5-Coder-32B-Instruct\",\n", - " \"MATH\",\n", - " 30.6,\n", - " ], # As per Open LLM Leaderboard for the base model, score for instruct too low. https://huggingface.co/spaces/open-llm-leaderboard/open_llm_leaderboard#/?search=llama-3.1\n", - "]\n", - "\n", - "df2 = pd.DataFrame(vanilla_data, columns=[\"model_id\", \"source\", \"correct\"])\n", - "df2[\"type\"] = \"vanilla\"\n", - "\n", - "combined_df = pd.concat([result_df, df2], ignore_index=True)\n", - "\n", - "pivot_df = combined_df.pivot_table(\n", + "pivot_df = result_df.pivot_table(\n", " index=[\"model_id\", \"source\"],\n", - " columns=[\"type\"],\n", + " columns=[\"action_type\"],\n", " values=\"correct\",\n", " fill_value=float(\"nan\"),\n", ").reset_index()" ] }, - { - "cell_type": "code", - "execution_count": 68, - "metadata": {}, - "outputs": [], - "source": [ - "pivot_df = pivot_df.loc[~pivot_df[\"source\"].isin([\"GSM8K\"])]" - ] - }, { "cell_type": "markdown", "metadata": {}, @@ -666,7 +600,7 @@ }, { "cell_type": "code", - "execution_count": 69, + "execution_count": 34, "metadata": {}, "outputs": [ { @@ -689,10 +623,10 @@ "\n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", " \n", @@ -701,128 +635,176 @@ " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", - " \n", + " \n", " \n", " \n", - " \n", - " \n", + " \n", + " \n", " \n", " \n", "
typeaction_typemodel_idsourceagentcodevanilla
0Qwen/Qwen2.5-72B-InstructGAIA12.5NaN28.16.2
21Qwen/Qwen2.5-72B-InstructMATH77.5NaN74.031.9
32Qwen/Qwen2.5-72B-InstructSimpleQA42.59.170.010.0
43Qwen/Qwen2.5-Coder-32B-InstructGAIA28.1NaN18.83.1
64Qwen/Qwen2.5-Coder-32B-InstructMATH85.030.676.060.0
75Qwen/Qwen2.5-Coder-32B-InstructSimpleQA42.5NaN86.08.0
86anthropic/claude-3-5-sonnet-latestGAIA43.8NaN40.63.1
107anthropic/claude-3-5-sonnet-latestMATH85.0NaN67.050.0
118anthropic/claude-3-5-sonnet-latestSimpleQA47.528.490.034.0
129gpt-4oGAIA25.09.328.13.1
1410gpt-4oMATH77.5NaN70.040.0
1511gpt-4oSimpleQA60.038.288.06.0
12meta-llama/Llama-3.1-8B-InstructGAIA0.00.0
13meta-llama/Llama-3.1-8B-InstructMATH42.018.0
14meta-llama/Llama-3.1-8B-InstructSimpleQA54.06.0
15meta-llama/Llama-3.2-3B-InstructGAIA3.10.0
16meta-llama/Llama-3.2-3B-InstructMATH32.012.0
17meta-llama/Llama-3.2-3B-InstructSimpleQA4.00.0
18meta-llama/Llama-3.3-70B-InstructGAIA21.9NaN34.43.1
1819meta-llama/Llama-3.3-70B-InstructMATH82.130.782.040.0
1920meta-llama/Llama-3.3-70B-InstructSimpleQA30.9NaN84.012.0
\n", "" ], "text/plain": [ - "type model_id source agent vanilla\n", - "0 Qwen/Qwen2.5-72B-Instruct GAIA 12.5 NaN\n", - "2 Qwen/Qwen2.5-72B-Instruct MATH 77.5 NaN\n", - "3 Qwen/Qwen2.5-72B-Instruct SimpleQA 42.5 9.1\n", - "4 Qwen/Qwen2.5-Coder-32B-Instruct GAIA 28.1 NaN\n", - "6 Qwen/Qwen2.5-Coder-32B-Instruct MATH 85.0 30.6\n", - "7 Qwen/Qwen2.5-Coder-32B-Instruct SimpleQA 42.5 NaN\n", - "8 anthropic/claude-3-5-sonnet-latest GAIA 43.8 NaN\n", - "10 anthropic/claude-3-5-sonnet-latest MATH 85.0 NaN\n", - "11 anthropic/claude-3-5-sonnet-latest SimpleQA 47.5 28.4\n", - "12 gpt-4o GAIA 25.0 9.3\n", - "14 gpt-4o MATH 77.5 NaN\n", - "15 gpt-4o SimpleQA 60.0 38.2\n", - "16 meta-llama/Llama-3.3-70B-Instruct GAIA 21.9 NaN\n", - "18 meta-llama/Llama-3.3-70B-Instruct MATH 82.1 30.7\n", - "19 meta-llama/Llama-3.3-70B-Instruct SimpleQA 30.9 NaN" + "action_type model_id source code vanilla\n", + "0 Qwen/Qwen2.5-72B-Instruct GAIA 28.1 6.2\n", + "1 Qwen/Qwen2.5-72B-Instruct MATH 74.0 31.9\n", + "2 Qwen/Qwen2.5-72B-Instruct SimpleQA 70.0 10.0\n", + "3 Qwen/Qwen2.5-Coder-32B-Instruct GAIA 18.8 3.1\n", + "4 Qwen/Qwen2.5-Coder-32B-Instruct MATH 76.0 60.0\n", + "5 Qwen/Qwen2.5-Coder-32B-Instruct SimpleQA 86.0 8.0\n", + "6 anthropic/claude-3-5-sonnet-latest GAIA 40.6 3.1\n", + "7 anthropic/claude-3-5-sonnet-latest MATH 67.0 50.0\n", + "8 anthropic/claude-3-5-sonnet-latest SimpleQA 90.0 34.0\n", + "9 gpt-4o GAIA 28.1 3.1\n", + "10 gpt-4o MATH 70.0 40.0\n", + "11 gpt-4o SimpleQA 88.0 6.0\n", + "12 meta-llama/Llama-3.1-8B-Instruct GAIA 0.0 0.0\n", + "13 meta-llama/Llama-3.1-8B-Instruct MATH 42.0 18.0\n", + "14 meta-llama/Llama-3.1-8B-Instruct SimpleQA 54.0 6.0\n", + "15 meta-llama/Llama-3.2-3B-Instruct GAIA 3.1 0.0\n", + "16 meta-llama/Llama-3.2-3B-Instruct MATH 32.0 12.0\n", + "17 meta-llama/Llama-3.2-3B-Instruct SimpleQA 4.0 0.0\n", + "18 meta-llama/Llama-3.3-70B-Instruct GAIA 34.4 3.1\n", + "19 meta-llama/Llama-3.3-70B-Instruct MATH 82.0 40.0\n", + "20 meta-llama/Llama-3.3-70B-Instruct SimpleQA 84.0 12.0" ] }, "metadata": {}, @@ -835,12 +817,12 @@ }, { "cell_type": "code", - "execution_count": 84, + "execution_count": 36, "metadata": {}, "outputs": [ { "data": { - "image/png": "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", + "image/png": "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", "text/plain": [ "
" ] @@ -877,7 +859,7 @@ "for i, source in enumerate(sources):\n", " source_data = pivot_df[pivot_df[\"source\"] == source]\n", " agent_scores = [\n", - " source_data[source_data[\"model_id\"] == model][\"agent\"].values[0]\n", + " source_data[source_data[\"model_id\"] == model][\"code\"].values[0]\n", " if len(source_data[source_data[\"model_id\"] == model]) > 0\n", " else np.nan\n", " for model in models\n", @@ -1013,7 +995,7 @@ ], "metadata": { "kernelspec": { - "display_name": "test", + "display_name": "compare-agents", "language": "python", "name": "python3" }, diff --git a/examples/rag.py b/examples/rag.py index bd40854c6..4096d57f0 100644 --- a/examples/rag.py +++ b/examples/rag.py @@ -60,7 +60,7 @@ def forward(self, query: str) -> str: retriever_tool = RetrieverTool(docs_processed) agent = CodeAgent( - tools=[retriever_tool], model=HfApiModel("meta-llama/Llama-3.3-70B-Instruct"), max_steps=4, verbose=True + tools=[retriever_tool], model=HfApiModel("meta-llama/Llama-3.3-70B-Instruct"), max_steps=4, verbosity_level=2 ) agent_output = agent.run("For a transformers model training, which is slower, the forward or the backward pass?") diff --git a/pyproject.toml b/pyproject.toml index 978c1fb9f..1fc22662f 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta" [project] name = "smolagents" -version = "1.2.0.dev0" +version = "1.3.0.dev" description = "🤗 smolagents: a barebones library for agents. Agents write python code to call tools or orchestrate other agents." authors = [ { name="Aymeric Roucher", email="aymeric@hf.co" }, { name="Thomas Wolf"}, @@ -12,9 +12,6 @@ authors = [ readme = "README.md" requires-python = ">=3.10" dependencies = [ - "torch", - "torchaudio", - "torchvision", "transformers>=4.0.0", "requests>=2.32.3", "rich>=13.9.4", @@ -30,10 +27,22 @@ dependencies = [ ] [tool.ruff] -ignore = ["F403"] +lint.ignore = ["F403"] [project.optional-dependencies] +dev = [ + "torch", + "torchaudio", + "torchvision", + "sqlalchemy", + "accelerate", + "soundfile", + "litellm>=1.55.10", +] test = [ + "torch", + "torchaudio", + "torchvision", "pytest>=8.1.0", "sqlalchemy", "ruff>=0.5.0", diff --git a/server.py b/server.py deleted file mode 100644 index b381d5333..000000000 --- a/server.py +++ /dev/null @@ -1,46 +0,0 @@ -import socket -import sys -import traceback -import io - -exec_globals = {} -exec_locals = {} - -def execute_code(code): - stdout = io.StringIO() - stderr = io.StringIO() - sys.stdout = stdout - sys.stderr = stderr - - try: - exec(code, exec_globals, exec_locals) - except Exception: - traceback.print_exc(file=stderr) - - output = stdout.getvalue() - error = stderr.getvalue() - - # Restore original stdout and stderr - sys.stdout = sys.__stdout__ - sys.stderr = sys.__stderr__ - - return output + error - -def start_server(host='0.0.0.0', port=65432): - with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s: - s.bind((host, port)) - s.listen() - print(f"Server listening on {host}:{port}") - while True: - conn, addr = s.accept() - with conn: - print(f"Connected by {addr}") - data = conn.recv(1024) - if not data: - break - code = data.decode('utf-8') - output = execute_code(code) - conn.sendall(output.encode('utf-8')) - -if __name__ == "__main__": - start_server() \ No newline at end of file diff --git a/src/smolagents/__init__.py b/src/smolagents/__init__.py index bccbf47e7..055fba7fc 100644 --- a/src/smolagents/__init__.py +++ b/src/smolagents/__init__.py @@ -14,7 +14,7 @@ # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. # See the License for the specific language governing permissions and # limitations under the License. -__version__ = "1.2.0.dev0" +__version__ = "1.3.0.dev" from typing import TYPE_CHECKING diff --git a/src/smolagents/agents.py b/src/smolagents/agents.py index d8c8c4fab..66bbdef24 100644 --- a/src/smolagents/agents.py +++ b/src/smolagents/agents.py @@ -18,13 +18,16 @@ from dataclasses import dataclass from typing import Any, Callable, Dict, List, Optional, Tuple, Union +from enum import IntEnum +from rich import box from rich.console import Group from rich.panel import Panel from rich.rule import Rule from rich.syntax import Syntax from rich.text import Text +from rich.console import Console -from .default_tools import FinalAnswerTool +from .default_tools import FinalAnswerTool, TOOL_MAPPING from .e2b_executor import E2BExecutor from .local_python_executor import ( BASE_BUILTIN_MODULES, @@ -49,7 +52,6 @@ from .tools import ( DEFAULT_TOOL_DESCRIPTION_TEMPLATE, Tool, - Toolbox, get_tool_description_with_args, ) from .types import AgentAudio, AgentImage, handle_agent_output_types @@ -107,18 +109,27 @@ class SystemPromptStep(AgentStep): system_prompt: str +def get_tool_descriptions( + tools: Dict[str, Tool], tool_description_template: str +) -> str: + return "\n".join( + [ + get_tool_description_with_args(tool, tool_description_template) + for tool in tools.values() + ] + ) + + def format_prompt_with_tools( - toolbox: Toolbox, prompt_template: str, tool_description_template: str + tools: Dict[str, Tool], prompt_template: str, tool_description_template: str ) -> str: - tool_descriptions = toolbox.show_tool_descriptions(tool_description_template) + tool_descriptions = get_tool_descriptions(tools, tool_description_template) prompt = prompt_template.replace("{{tool_descriptions}}", tool_descriptions) - if "{{tool_names}}" in prompt: prompt = prompt.replace( "{{tool_names}}", - ", ".join([f"'{tool_name}'" for tool_name in toolbox.tools.keys()]), + ", ".join([f"'{tool.name}'" for tool in tools.values()]), ) - return prompt @@ -155,6 +166,22 @@ def format_prompt_with_managed_agents_descriptions( YELLOW_HEX = "#d4b702" +class LogLevel(IntEnum): + ERROR = 0 # Only errors + INFO = 1 # Normal output (default) + DEBUG = 2 # Detailed output + + +class AgentLogger: + def __init__(self, level: LogLevel = LogLevel.INFO): + self.level = level + self.console = Console() + + def log(self, *args, level: LogLevel = LogLevel.INFO, **kwargs): + if level <= self.level: + console.print(*args, **kwargs) + + class MultiStepAgent: """ Agent class that solves the given task step by step, using the ReAct framework: @@ -163,16 +190,16 @@ class MultiStepAgent: def __init__( self, - tools: Union[List[Tool], Toolbox], + tools: List[Tool], model: Callable[[List[Dict[str, str]]], str], system_prompt: Optional[str] = None, tool_description_template: Optional[str] = None, max_steps: int = 6, tool_parser: Optional[Callable] = None, add_base_tools: bool = False, - verbose: bool = False, + verbosity_level: int = 1, grammar: Optional[Dict[str, str]] = None, - managed_agents: Optional[Dict] = None, + managed_agents: Optional[List] = None, step_callbacks: Optional[List[Callable]] = None, planning_interval: Optional[int] = None, ): @@ -198,33 +225,28 @@ def __init__( if managed_agents is not None: self.managed_agents = {agent.name: agent for agent in managed_agents} - if isinstance(tools, Toolbox): - self._toolbox = tools - if add_base_tools: - self._toolbox.add_base_tools( - add_python_interpreter=(self.__class__ == ToolCallingAgent) - ) - else: - self._toolbox = Toolbox(tools, add_base_tools=add_base_tools) - self._toolbox.add_tool(FinalAnswerTool()) + self.tools = {tool.name: tool for tool in tools} + if add_base_tools: + for tool_name, tool_class in TOOL_MAPPING.items(): + if ( + tool_name != "python_interpreter" + or self.__class__.__name__ == "ToolCallingAgent" + ): + self.tools[tool_name] = tool_class() + self.tools["final_answer"] = FinalAnswerTool() self.system_prompt = self.initialize_system_prompt() self.input_messages = None self.logs = [] self.task = None - self.verbose = verbose - self.monitor = Monitor(self.model) + self.logger = AgentLogger(level=verbosity_level) + self.monitor = Monitor(self.model, self.logger) self.step_callbacks = step_callbacks if step_callbacks is not None else [] self.step_callbacks.append(self.monitor.update_metrics) - @property - def toolbox(self) -> Toolbox: - """Get the toolbox currently available to the agent""" - return self._toolbox - def initialize_system_prompt(self): self.system_prompt = format_prompt_with_tools( - self._toolbox, + self.tools, self.system_prompt_template, self.tool_description_template, ) @@ -384,10 +406,10 @@ def execute_tool_call( This method replaces arguments with the actual values from the state if they refer to state variables. Args: - tool_name (`str`): Name of the Tool to execute (should be one from self.toolbox). + tool_name (`str`): Name of the Tool to execute (should be one from self.tools). arguments (Dict[str, str]): Arguments passed to the Tool. """ - available_tools = {**self.toolbox.tools, **self.managed_agents} + available_tools = {**self.tools, **self.managed_agents} if tool_name not in available_tools: error_msg = f"Unknown tool {tool_name}, should be instead one of {list(available_tools.keys())}." raise AgentExecutionError(error_msg) @@ -415,7 +437,7 @@ def execute_tool_call( raise AgentExecutionError(error_msg) return observation except Exception as e: - if tool_name in self.toolbox.tools: + if tool_name in self.tools: tool_description = get_tool_description_with_args( available_tools[tool_name] ) @@ -448,9 +470,9 @@ def run( Args: task (`str`): The task to perform. - stream (`bool`): Wether to run in a streaming way. - reset (`bool`): Wether to reset the conversation or keep it going from previous run. - single_step (`bool`): Should the agent run in one shot or multi-step fashion? + stream (`bool`): Whether to run in a streaming way. + reset (`bool`): Whether to reset the conversation or keep it going from previous run. + single_step (`bool`): Whether to run the agent in one-shot fashion. additional_args (`dict`): Any other variables that you want to pass to the agent run, for instance images or dataframes. Give them clear names! Example: @@ -480,14 +502,15 @@ def run( else: self.logs.append(system_prompt_step) - console.print( + self.logger.log( Panel( f"\n[bold]{self.task.strip()}\n", title="[bold]New run", subtitle=f"{type(self.model).__name__} - {(self.model.model_id if hasattr(self.model, 'model_id') else '')}", border_style=YELLOW_HEX, subtitle_align="left", - ) + ), + level=LogLevel.INFO, ) self.logs.append(TaskStep(task=self.task)) @@ -512,20 +535,27 @@ def stream_run(self, task: str): Runs the agent in streaming mode, yielding steps as they are executed: should be launched only in the `run` method. """ final_answer = None - step_number = 0 - while final_answer is None and step_number < self.max_steps: + self.step_number = 0 + while final_answer is None and self.step_number < self.max_steps: step_start_time = time.time() - step_log = ActionStep(step=step_number, start_time=step_start_time) + step_log = ActionStep(step=self.step_number, start_time=step_start_time) try: if ( self.planning_interval is not None - and step_number % self.planning_interval == 0 + and self.step_number % self.planning_interval == 0 ): self.planning_step( - task, is_first_step=(step_number == 0), step=step_number + task, + is_first_step=(self.step_number == 0), + step=self.step_number, ) - console.print( - Rule(f"[bold]Step {step_number}", characters="━", style=YELLOW_HEX) + self.logger.log( + Rule( + f"[bold]Step {self.step_number}", + characters="━", + style=YELLOW_HEX, + ), + level=LogLevel.INFO, ) # Run one step! @@ -538,15 +568,15 @@ def stream_run(self, task: str): self.logs.append(step_log) for callback in self.step_callbacks: callback(step_log) - step_number += 1 + self.step_number += 1 yield step_log - if final_answer is None and step_number == self.max_steps: + if final_answer is None and self.step_number == self.max_steps: error_message = "Reached max steps." final_step_log = ActionStep(error=AgentMaxStepsError(error_message)) self.logs.append(final_step_log) final_answer = self.provide_final_answer(task) - console.print(Text(f"Final answer: {final_answer}")) + self.logger.log(Text(f"Final answer: {final_answer}"), level=LogLevel.INFO) final_step_log.action_output = final_answer final_step_log.end_time = time.time() final_step_log.duration = step_log.end_time - step_start_time @@ -561,20 +591,27 @@ def direct_run(self, task: str): Runs the agent in direct mode, returning outputs only at the end: should be launched only in the `run` method. """ final_answer = None - step_number = 0 - while final_answer is None and step_number < self.max_steps: + self.step_number = 0 + while final_answer is None and self.step_number < self.max_steps: step_start_time = time.time() - step_log = ActionStep(step=step_number, start_time=step_start_time) + step_log = ActionStep(step=self.step_number, start_time=step_start_time) try: if ( self.planning_interval is not None - and step_number % self.planning_interval == 0 + and self.step_number % self.planning_interval == 0 ): self.planning_step( - task, is_first_step=(step_number == 0), step=step_number + task, + is_first_step=(self.step_number == 0), + step=self.step_number, ) - console.print( - Rule(f"[bold]Step {step_number}", characters="━", style=YELLOW_HEX) + self.logger.log( + Rule( + f"[bold]Step {self.step_number}", + characters="━", + style=YELLOW_HEX, + ), + level=LogLevel.INFO, ) # Run one step! @@ -589,14 +626,14 @@ def direct_run(self, task: str): self.logs.append(step_log) for callback in self.step_callbacks: callback(step_log) - step_number += 1 + self.step_number += 1 - if final_answer is None and step_number == self.max_steps: + if final_answer is None and self.step_number == self.max_steps: error_message = "Reached max steps." final_step_log = ActionStep(error=AgentMaxStepsError(error_message)) self.logs.append(final_step_log) final_answer = self.provide_final_answer(task) - console.print(Text(f"Final answer: {final_answer}")) + self.logger.log(Text(f"Final answer: {final_answer}"), level=LogLevel.INFO) final_step_log.action_output = final_answer final_step_log.duration = 0 for callback in self.step_callbacks: @@ -637,8 +674,8 @@ def planning_step(self, task, is_first_step: bool, step: int): "role": MessageRole.USER, "content": USER_PROMPT_PLAN.format( task=task, - tool_descriptions=self._toolbox.show_tool_descriptions( - self.tool_description_template + tool_descriptions=get_tool_descriptions( + self.tools, self.tool_description_template ), managed_agents_descriptions=( show_agents_descriptions(self.managed_agents) @@ -662,8 +699,10 @@ def planning_step(self, task, is_first_step: bool, step: int): self.logs.append( PlanningStep(plan=final_plan_redaction, facts=final_facts_redaction) ) - console.print( - Rule("[bold]Initial plan", style="orange"), Text(final_plan_redaction) + self.logger.log( + Rule("[bold]Initial plan", style="orange"), + Text(final_plan_redaction), + level=LogLevel.INFO, ) else: # update plan agent_memory = self.write_inner_memory_from_logs( @@ -692,8 +731,8 @@ def planning_step(self, task, is_first_step: bool, step: int): "role": MessageRole.USER, "content": USER_PROMPT_PLAN_UPDATE.format( task=task, - tool_descriptions=self._toolbox.show_tool_descriptions( - self.tool_description_template + tool_descriptions=get_tool_descriptions( + self.tools, self.tool_description_template ), managed_agents_descriptions=( show_agents_descriptions(self.managed_agents) @@ -718,8 +757,10 @@ def planning_step(self, task, is_first_step: bool, step: int): self.logs.append( PlanningStep(plan=final_plan_redaction, facts=final_facts_redaction) ) - console.print( - Rule("[bold]Updated plan", style="orange"), Text(final_plan_redaction) + self.logger.log( + Rule("[bold]Updated plan", style="orange"), + Text(final_plan_redaction), + level=LogLevel.INFO, ) @@ -759,11 +800,15 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: log_entry.agent_memory = agent_memory.copy() try: - tool_name, tool_arguments, tool_call_id = self.model.get_tool_call( + model_message = self.model( self.input_messages, - available_tools=list(self.toolbox._tools.values()), + tools_to_call_from=list(self.tools.values()), stop_sequences=["Observation:"], ) + tool_calls = model_message.tool_calls[0] + tool_arguments = tool_calls.function.arguments + tool_name, tool_call_id = tool_calls.function.name, tool_calls.id + except Exception as e: raise AgentGenerationError( f"Error in generating tool call with model:\n{e}" @@ -774,8 +819,11 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: ) # Execute - console.print( - Panel(Text(f"Calling tool: '{tool_name}' with arguments: {tool_arguments}")) + self.logger.log( + Panel( + Text(f"Calling tool: '{tool_name}' with arguments: {tool_arguments}") + ), + level=LogLevel.INFO, ) if tool_name == "final_answer": if isinstance(tool_arguments, dict): @@ -789,13 +837,15 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: isinstance(answer, str) and answer in self.state.keys() ): # if the answer is a state variable, return the value final_answer = self.state[answer] - console.print( - f"[bold {YELLOW_HEX}]Final answer:[/bold {YELLOW_HEX}] Extracting key '{answer}' from state to return value '{final_answer}'." + self.logger.log( + f"[bold {YELLOW_HEX}]Final answer:[/bold {YELLOW_HEX}] Extracting key '{answer}' from state to return value '{final_answer}'.", + level=LogLevel.INFO, ) else: final_answer = answer - console.print( - Text(f"Final answer: {final_answer}", style=f"bold {YELLOW_HEX}") + self.logger.log( + Text(f"Final answer: {final_answer}", style=f"bold {YELLOW_HEX}"), + level=LogLevel.INFO, ) log_entry.action_output = final_answer @@ -816,7 +866,7 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: updated_information = f"Stored '{observation_name}' in memory." else: updated_information = str(observation).strip() - console.print(f"Observations: {updated_information}") + self.logger.log(f"Observations: {updated_information}", level=LogLevel.INFO) log_entry.observations = updated_information return None @@ -856,7 +906,7 @@ def __init__( f"You passed both {use_e2b_executor=} and some managed agents. Managed agents is not yet supported with remote code execution." ) - all_tools = {**self.toolbox.tools, **self.managed_agents} + all_tools = {**self.tools, **self.managed_agents} if use_e2b_executor: self.python_executor = E2BExecutor( self.additional_authorized_imports, list(all_tools.values()) @@ -896,27 +946,27 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: self.input_messages, stop_sequences=["", "Observation:"], **additional_args, - ) + ).content log_entry.llm_output = llm_output except Exception as e: raise AgentGenerationError(f"Error in generating model output:\n{e}") - if self.verbose: - console.print( - Group( - Rule( - "[italic]Output message of the LLM:", - align="left", - style="orange", - ), - Syntax( - llm_output, - lexer="markdown", - theme="github-dark", - word_wrap=True, - ), - ) - ) + self.logger.log( + Group( + Rule( + "[italic]Output message of the LLM:", + align="left", + style="orange", + ), + Syntax( + llm_output, + lexer="markdown", + theme="github-dark", + word_wrap=True, + ), + ), + level=LogLevel.DEBUG, + ) # Parse try: @@ -934,18 +984,19 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: ) # Execute - console.print( + self.logger.log( Panel( Syntax( code_action, lexer="python", theme="monokai", word_wrap=True, - line_numbers=True, ), title="[bold]Executing this code:", title_align="left", - ) + box=box.HORIZONTALS, + ), + level=LogLevel.INFO, ) observation = "" is_final_answer = False @@ -972,8 +1023,9 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: else: error_msg = str(e) if "Import of " in str(e) and " is not allowed" in str(e): - console.print( - "[bold red]Warning to user: Code execution failed due to an unauthorized import - Consider passing said import under `additional_authorized_imports` when initializing your CodeAgent." + self.logger.log( + "[bold red]Warning to user: Code execution failed due to an unauthorized import - Consider passing said import under `additional_authorized_imports` when initializing your CodeAgent.", + level=LogLevel.INFO, ) raise AgentExecutionError(error_msg) @@ -987,7 +1039,7 @@ def step(self, log_entry: ActionStep) -> Union[None, Any]: style=(f"bold {YELLOW_HEX}" if is_final_answer else ""), ), ] - console.print(Group(*execution_outputs_console)) + self.logger.log(Group(*execution_outputs_console), level=LogLevel.INFO) log_entry.action_output = output return output if is_final_answer else None @@ -1045,5 +1097,4 @@ def __call__(self, request, **kwargs): "MultiStepAgent", "CodeAgent", "ToolCallingAgent", - "Toolbox", ] diff --git a/src/smolagents/default_tools.py b/src/smolagents/default_tools.py index 5959cda9e..75fe8d017 100644 --- a/src/smolagents/default_tools.py +++ b/src/smolagents/default_tools.py @@ -20,11 +20,9 @@ from typing import Dict, Optional from huggingface_hub import hf_hub_download, list_spaces -from transformers.models.whisper import ( - WhisperForConditionalGeneration, - WhisperProcessor, -) -from transformers.utils import is_offline_mode + + +from transformers.utils import is_offline_mode, is_torch_available from .local_python_executor import ( BASE_BUILTIN_MODULES, @@ -34,6 +32,15 @@ from .tools import TOOL_CONFIG_FILE, PipelineTool, Tool from .types import AgentAudio +if is_torch_available(): + from transformers.models.whisper import ( + WhisperForConditionalGeneration, + WhisperProcessor, + ) +else: + WhisperForConditionalGeneration = object + WhisperProcessor = object + @dataclass class PreTool: @@ -322,6 +329,15 @@ def decode(self, outputs): return self.pre_processor.batch_decode(outputs, skip_special_tokens=True)[0] +TOOL_MAPPING = { + tool_class.name: tool_class + for tool_class in [ + PythonInterpreterTool, + DuckDuckGoSearchTool, + VisitWebpageTool, + ] +} + __all__ = [ "PythonInterpreterTool", "FinalAnswerTool", diff --git a/src/smolagents/models.py b/src/smolagents/models.py index 32d08f451..fd686075e 100644 --- a/src/smolagents/models.py +++ b/src/smolagents/models.py @@ -20,20 +20,25 @@ import random from copy import deepcopy from enum import Enum -from typing import Dict, List, Optional, Tuple, Union +from typing import Dict, List, Optional + +from huggingface_hub import ( + InferenceClient, + ChatCompletionOutputMessage, + ChatCompletionOutputToolCall, + ChatCompletionOutputFunctionDefinition, +) -import torch -from huggingface_hub import InferenceClient from transformers import ( AutoModelForCausalLM, AutoTokenizer, StoppingCriteria, StoppingCriteriaList, + is_torch_available, ) import openai from .tools import Tool -from .utils import parse_json_tool_call logger = logging.getLogger(__name__) @@ -142,21 +147,12 @@ def __init__(self): self.last_input_token_count = None self.last_output_token_count = None - def get_token_counts(self): + def get_token_counts(self) -> Dict[str, int]: return { "input_token_count": self.last_input_token_count, "output_token_count": self.last_output_token_count, } - def generate( - self, - messages: List[Dict[str, str]], - stop_sequences: Optional[List[str]] = None, - grammar: Optional[str] = None, - max_tokens: int = 1500, - ): - raise NotImplementedError - def __call__( self, messages: List[Dict[str, str]], @@ -226,63 +222,50 @@ def __init__( model_id: str = "Qwen/Qwen2.5-Coder-32B-Instruct", token: Optional[str] = None, timeout: Optional[int] = 120, + temperature: float = 0.5, ): super().__init__() self.model_id = model_id if token is None: token = os.getenv("HF_TOKEN") self.client = InferenceClient(self.model_id, token=token, timeout=timeout) + self.temperature = temperature - def generate( + def __call__( self, messages: List[Dict[str, str]], stop_sequences: Optional[List[str]] = None, grammar: Optional[str] = None, max_tokens: int = 1500, + tools_to_call_from: Optional[List[Tool]] = None, ) -> str: - """Generates a text completion for the given message list""" + """ + Gets an LLM output message for the given list of input messages. + If argument `tools_to_call_from` is passed, the model's tool calling options will be used to return a tool call. + """ messages = get_clean_message_list( messages, role_conversions=tool_role_conversions ) - - # Send messages to the Hugging Face Inference API - if grammar is not None: - output = self.client.chat_completion( - messages, + if tools_to_call_from: + response = self.client.chat.completions.create( + messages=messages, + tools=[get_json_schema(tool) for tool in tools_to_call_from], + tool_choice="auto", stop=stop_sequences, - response_format=grammar, max_tokens=max_tokens, + temperature=self.temperature, ) else: - output = self.client.chat.completions.create( - messages, stop=stop_sequences, max_tokens=max_tokens + response = self.client.chat.completions.create( + model=self.model_id, + messages=messages, + stop=stop_sequences, + max_tokens=max_tokens, + temperature=self.temperature, ) - - response = output.choices[0].message.content - self.last_input_token_count = output.usage.prompt_tokens - self.last_output_token_count = output.usage.completion_tokens - return response - - def get_tool_call( - self, - messages: List[Dict[str, str]], - available_tools: List[Tool], - stop_sequences, - ): - """Generates a tool call for the given message list. This method is used only by `ToolCallingAgent`.""" - messages = get_clean_message_list( - messages, role_conversions=tool_role_conversions - ) - response = self.client.chat.completions.create( - messages=messages, - tools=[get_json_schema(tool) for tool in available_tools], - tool_choice="auto", - stop=stop_sequences, - ) - tool_call = response.choices[0].message.tool_calls[0] self.last_input_token_count = response.usage.prompt_tokens self.last_output_token_count = response.usage.completion_tokens - return tool_call.function.name, tool_call.function.arguments, tool_call.id + return response.choices[0].message class TransformersModel(Model): @@ -297,6 +280,10 @@ class TransformersModel(Model): def __init__(self, model_id: Optional[str] = None, device: Optional[str] = None): super().__init__() + if not is_torch_available(): + raise ImportError("Please install torch in order to use TransformersModel.") + import torch + default_model_id = "HuggingFaceTB/SmolLM2-1.7B-Instruct" if model_id is None: model_id = default_model_id @@ -346,23 +333,32 @@ def __call__(self, input_ids, scores, **kwargs): return StoppingCriteriaList([StopOnStrings(stop_sequences, self.tokenizer)]) - def generate( + def __call__( self, messages: List[Dict[str, str]], stop_sequences: Optional[List[str]] = None, grammar: Optional[str] = None, max_tokens: int = 1500, + tools_to_call_from: Optional[List[Tool]] = None, ) -> str: messages = get_clean_message_list( messages, role_conversions=tool_role_conversions ) - # Get LLM output - prompt_tensor = self.tokenizer.apply_chat_template( - messages, - return_tensors="pt", - return_dict=True, - ) + if tools_to_call_from is not None: + prompt_tensor = self.tokenizer.apply_chat_template( + messages, + tools=[get_json_schema(tool) for tool in tools_to_call_from], + return_tensors="pt", + return_dict=True, + add_generation_prompt=True, + ) + else: + prompt_tensor = self.tokenizer.apply_chat_template( + messages, + return_tensors="pt", + return_dict=True, + ) prompt_tensor = prompt_tensor.to(self.model.device) count_prompt_tokens = prompt_tensor["input_ids"].shape[1] @@ -374,56 +370,31 @@ def generate( ), ) generated_tokens = out[0, count_prompt_tokens:] - response = self.tokenizer.decode(generated_tokens, skip_special_tokens=True) - - self.last_input_token_count = count_prompt_tokens - self.last_output_token_count = len(generated_tokens) - - if stop_sequences is not None: - response = remove_stop_sequences(response, stop_sequences) - return response - - def get_tool_call( - self, - messages: List[Dict[str, str]], - available_tools: List[Tool], - stop_sequences: Optional[List[str]] = None, - max_tokens: int = 500, - ) -> Tuple[str, Union[str, None], str]: - messages = get_clean_message_list( - messages, role_conversions=tool_role_conversions - ) - - prompt = self.tokenizer.apply_chat_template( - messages, - tools=[get_json_schema(tool) for tool in available_tools], - return_tensors="pt", - return_dict=True, - add_generation_prompt=True, - ) - prompt = prompt.to(self.model.device) - count_prompt_tokens = prompt["input_ids"].shape[1] - - out = self.model.generate( - **prompt, - max_new_tokens=max_tokens, - stopping_criteria=( - self.make_stopping_criteria(stop_sequences) if stop_sequences else None - ), - ) - generated_tokens = out[0, count_prompt_tokens:] - response = self.tokenizer.decode(generated_tokens, skip_special_tokens=True) + output = self.tokenizer.decode(generated_tokens, skip_special_tokens=True) self.last_input_token_count = count_prompt_tokens self.last_output_token_count = len(generated_tokens) if stop_sequences is not None: - response = remove_stop_sequences(response, stop_sequences) - - tool_name, tool_input = parse_json_tool_call(response) - call_id = "".join(random.choices("0123456789", k=5)) + output = remove_stop_sequences(output, stop_sequences) - return tool_name, tool_input, call_id + if tools_to_call_from is None: + return ChatCompletionOutputMessage(role="assistant", content=output) + else: + tool_name, tool_arguments = json.load(output) + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="".join(random.choices("0123456789", k=5)), + type="function", + function=ChatCompletionOutputFunctionDefinition( + name=tool_name, arguments=tool_arguments + ), + ) + ], + ) class LiteLLMModel(Model): @@ -452,50 +423,36 @@ def __call__( stop_sequences: Optional[List[str]] = None, grammar: Optional[str] = None, max_tokens: int = 1500, + tools_to_call_from: Optional[List[Tool]] = None, ) -> str: messages = get_clean_message_list( messages, role_conversions=tool_role_conversions ) - - response = litellm.completion( - model=self.model_id, - messages=messages, - stop=stop_sequences, - max_tokens=max_tokens, - api_base=self.api_base, - api_key=self.api_key, - **self.kwargs, - ) - self.last_input_token_count = response.usage.prompt_tokens - self.last_output_token_count = response.usage.completion_tokens - return response.choices[0].message.content - - def get_tool_call( - self, - messages: List[Dict[str, str]], - available_tools: List[Tool], - stop_sequences: Optional[List[str]] = None, - max_tokens: int = 1500, - ): - messages = get_clean_message_list( - messages, role_conversions=tool_role_conversions - ) - response = litellm.completion( - model=self.model_id, - messages=messages, - tools=[get_json_schema(tool) for tool in available_tools], - tool_choice="required", - stop=stop_sequences, - max_tokens=max_tokens, - api_base=self.api_base, - api_key=self.api_key, - **self.kwargs, - ) - tool_calls = response.choices[0].message.tool_calls[0] + if tools_to_call_from: + response = litellm.completion( + model=self.model_id, + messages=messages, + tools=[get_json_schema(tool) for tool in tools_to_call_from], + tool_choice="required", + stop=stop_sequences, + max_tokens=max_tokens, + api_base=self.api_base, + api_key=self.api_key, + **self.kwargs, + ) + else: + response = litellm.completion( + model=self.model_id, + messages=messages, + stop=stop_sequences, + max_tokens=max_tokens, + api_base=self.api_base, + api_key=self.api_key, + **self.kwargs, + ) self.last_input_token_count = response.usage.prompt_tokens self.last_output_token_count = response.usage.completion_tokens - arguments = json.loads(tool_calls.function.arguments) - return tool_calls.function.name, arguments, tool_calls.id + return response.choices[0].message class OpenAIServerModel(Model): @@ -531,64 +488,40 @@ def __init__( self.temperature = temperature self.kwargs = kwargs - def generate( + def __call__( self, messages: List[Dict[str, str]], stop_sequences: Optional[List[str]] = None, grammar: Optional[str] = None, max_tokens: int = 1500, + tools_to_call_from: Optional[List[Tool]] = None, ) -> str: - """Generates a text completion for the given message list""" - messages = get_clean_message_list( - messages, role_conversions=tool_role_conversions - ) - - response = self.client.chat.completions.create( - model=self.model_id, - messages=messages, - stop=stop_sequences, - max_tokens=max_tokens, - temperature=self.temperature, - **self.kwargs, - ) - - self.last_input_token_count = response.usage.prompt_tokens - self.last_output_token_count = response.usage.completion_tokens - return response.choices[0].message.content - - def get_tool_call( - self, - messages: List[Dict[str, str]], - available_tools: List[Tool], - stop_sequences: Optional[List[str]] = None, - max_tokens: int = 500, - ) -> Tuple[str, Union[str, Dict], str]: - """Generates a tool call for the given message list""" messages = get_clean_message_list( messages, role_conversions=tool_role_conversions ) - - response = self.client.chat.completions.create( - model=self.model_id, - messages=messages, - tools=[get_json_schema(tool) for tool in available_tools], - tool_choice="auto", - stop=stop_sequences, - max_tokens=max_tokens, - temperature=self.temperature, - **self.kwargs, - ) - - tool_calls = response.choices[0].message.tool_calls[0] + if tools_to_call_from: + response = self.client.chat.completions.create( + model=self.model_id, + messages=messages, + tools=[get_json_schema(tool) for tool in tools_to_call_from], + tool_choice="auto", + stop=stop_sequences, + max_tokens=max_tokens, + temperature=self.temperature, + **self.kwargs, + ) + else: + response = self.client.chat.completions.create( + model=self.model_id, + messages=messages, + stop=stop_sequences, + max_tokens=max_tokens, + temperature=self.temperature, + **self.kwargs, + ) self.last_input_token_count = response.usage.prompt_tokens self.last_output_token_count = response.usage.completion_tokens - - try: - arguments = json.loads(tool_calls.function.arguments) - except json.JSONDecodeError: - arguments = tool_calls.function.arguments - - return tool_calls.function.name, arguments, tool_calls.id + return response.choices[0].message __all__ = [ diff --git a/src/smolagents/monitoring.py b/src/smolagents/monitoring.py index daa53cd2a..b6ba78f60 100644 --- a/src/smolagents/monitoring.py +++ b/src/smolagents/monitoring.py @@ -16,13 +16,12 @@ # limitations under the License. from rich.text import Text -from .utils import console - class Monitor: - def __init__(self, tracked_model): + def __init__(self, tracked_model, logger): self.step_durations = [] self.tracked_model = tracked_model + self.logger = logger if ( getattr(self.tracked_model, "last_input_token_count", "Not found") != "Not found" @@ -53,7 +52,7 @@ def update_metrics(self, step_log): self.total_output_token_count += self.tracked_model.last_output_token_count console_outputs += f"| Input tokens: {self.total_input_token_count:,} | Output tokens: {self.total_output_token_count:,}" console_outputs += "]" - console.print(Text(console_outputs, style="dim")) + self.logger.log(Text(console_outputs, style="dim"), level=1) __all__ = ["Monitor"] diff --git a/src/smolagents/tools.py b/src/smolagents/tools.py index 7acff0d9b..2638f542d 100644 --- a/src/smolagents/tools.py +++ b/src/smolagents/tools.py @@ -25,9 +25,8 @@ import textwrap from functools import lru_cache, wraps from pathlib import Path -from typing import Callable, Dict, List, Optional, Union, get_type_hints +from typing import Callable, Dict, Optional, Union, get_type_hints -import torch from huggingface_hub import ( create_repo, get_collection, @@ -37,7 +36,6 @@ ) from huggingface_hub.utils import RepositoryNotFoundError from packaging import version -from transformers import AutoProcessor from transformers.dynamic_module_utils import get_imports from transformers.utils import ( TypeHintParsingException, @@ -54,13 +52,14 @@ logger = logging.getLogger(__name__) - -if is_torch_available(): - pass - if is_accelerate_available(): - pass + from accelerate import PartialState + from accelerate.utils import send_to_device +if is_torch_available(): + from transformers import AutoProcessor +else: + AutoProcessor = object TOOL_CONFIG_FILE = "tool_config.json" @@ -85,18 +84,6 @@ def get_repo_type(repo_id, repo_type=None, **hub_kwargs): return "space" -def setup_default_tools(): - default_tools = {} - main_module = importlib.import_module("smolagents") - - for task_name, tool_class_name in TOOL_MAPPING.items(): - tool_class = getattr(main_module, tool_class_name) - tool_instance = tool_class() - default_tools[tool_class.name] = tool_instance - - return default_tools - - def validate_after_init(cls): original_init = cls.__init__ @@ -727,10 +714,10 @@ def get_tool_description_with_args( if description_template is None: description_template = DEFAULT_TOOL_DESCRIPTION_TEMPLATE compiled_template = compile_jinja_template(description_template) - rendered = compiled_template.render( + tool_description = compiled_template.render( tool=tool, ) - return rendered + return tool_description @lru_cache @@ -779,8 +766,10 @@ def launch_gradio_demo(tool: Tool): "number": gr.Textbox, } - def fn(*args, **kwargs): - return tool(*args, **kwargs, sanitize_inputs_outputs=True) + def tool_forward(*args, **kwargs): + return tool(*args, sanitize_inputs_outputs=True, **kwargs) + + tool_forward.__signature__ = inspect.signature(tool.forward) gradio_inputs = [] for input_name, input_details in tool.inputs.items(): @@ -794,21 +783,16 @@ def fn(*args, **kwargs): gradio_output = output_gradio_componentclass(label="Output") gr.Interface( - fn=fn, + fn=tool_forward, inputs=gradio_inputs, outputs=gradio_output, title=tool.name, article=tool.description, + description=tool.description, + api_name=tool.name, ).launch() -TOOL_MAPPING = { - "python_interpreter": "PythonInterpreterTool", - "web_search": "DuckDuckGoSearchTool", - "transcriber": "SpeechToTextTool", -} - - def load_tool( task_or_repo_id, model_repo_id: Optional[str] = None, @@ -817,7 +801,7 @@ def load_tool( **kwargs, ): """ - Main function to quickly load a tool, be it on the Hub or in the Transformers library. + Main function to quickly load a tool from the Hub. @@ -850,20 +834,13 @@ def load_tool( `cache_dir`, `revision`, `subfolder`) will be used when downloading the files for your tool, and the others will be passed along to its init. """ - if task_or_repo_id in TOOL_MAPPING: - tool_class_name = TOOL_MAPPING[task_or_repo_id] - main_module = importlib.import_module("smolagents") - tools_module = main_module - tool_class = getattr(tools_module, tool_class_name) - return tool_class(token=token, **kwargs) - else: - return Tool.from_hub( - task_or_repo_id, - model_repo_id=model_repo_id, - token=token, - trust_remote_code=trust_remote_code, - **kwargs, - ) + return Tool.from_hub( + task_or_repo_id, + model_repo_id=model_repo_id, + token=token, + trust_remote_code=trust_remote_code, + **kwargs, + ) def add_description(description): @@ -957,107 +934,6 @@ def __init__(self, name, description, inputs, output_type, function): return simple_tool -HUGGINGFACE_DEFAULT_TOOLS = {} - - -class Toolbox: - """ - The toolbox contains all tools that the agent can perform operations with, as well as a few methods to - manage them. - - Args: - tools (`List[Tool]`): - The list of tools to instantiate the toolbox with - add_base_tools (`bool`, defaults to `False`, *optional*, defaults to `False`): - Whether to add the tools available within `transformers` to the toolbox. - """ - - def __init__(self, tools: List[Tool], add_base_tools: bool = False): - self._tools = {tool.name: tool for tool in tools} - if add_base_tools: - self.add_base_tools() - - def add_base_tools(self, add_python_interpreter: bool = False): - global HUGGINGFACE_DEFAULT_TOOLS - if len(HUGGINGFACE_DEFAULT_TOOLS.keys()) == 0: - HUGGINGFACE_DEFAULT_TOOLS = setup_default_tools() - for tool in HUGGINGFACE_DEFAULT_TOOLS.values(): - if tool.name != "python_interpreter" or add_python_interpreter: - self.add_tool(tool) - - @property - def tools(self) -> Dict[str, Tool]: - """Get all tools currently in the toolbox""" - return self._tools - - def show_tool_descriptions( - self, tool_description_template: Optional[str] = None - ) -> str: - """ - Returns the description of all tools in the toolbox - - Args: - tool_description_template (`str`, *optional*): - The template to use to describe the tools. If not provided, the default template will be used. - """ - return "\n".join( - [ - get_tool_description_with_args(tool, tool_description_template) - for tool in self._tools.values() - ] - ) - - def add_tool(self, tool: Tool): - """ - Adds a tool to the toolbox - - Args: - tool (`Tool`): - The tool to add to the toolbox. - """ - if tool.name in self._tools: - raise KeyError(f"Error: tool '{tool.name}' already exists in the toolbox.") - self._tools[tool.name] = tool - - def remove_tool(self, tool_name: str): - """ - Removes a tool from the toolbox - - Args: - tool_name (`str`): - The tool to remove from the toolbox. - """ - if tool_name not in self._tools: - raise KeyError( - f"Error: tool {tool_name} not found in toolbox for removal, should be instead one of {list(self._tools.keys())}." - ) - del self._tools[tool_name] - - def update_tool(self, tool: Tool): - """ - Updates a tool in the toolbox according to its name. - - Args: - tool (`Tool`): - The tool to update to the toolbox. - """ - if tool.name not in self._tools: - raise KeyError( - f"Error: tool {tool.name} not found in toolbox for update, should be instead one of {list(self._tools.keys())}." - ) - self._tools[tool.name] = tool - - def clear_toolbox(self): - """Clears the toolbox""" - self._tools = {} - - def __repr__(self): - toolbox_description = "Toolbox contents:\n" - for tool in self._tools.values(): - toolbox_description += f"\t{tool.name}: {tool.description}\n" - return toolbox_description - - class PipelineTool(Tool): """ A [`Tool`] tailored towards Transformer models. On top of the class attributes of the base class [`Tool`], you will @@ -1149,8 +1025,6 @@ def setup(self): """ Instantiates the `pre_processor`, `model` and `post_processor` if necessary. """ - from accelerate import PartialState - if isinstance(self.pre_processor, str): self.pre_processor = self.pre_processor_class.from_pretrained( self.pre_processor, **self.hub_kwargs @@ -1189,6 +1063,8 @@ def forward(self, inputs): """ Sends the inputs through the `model`. """ + import torch + with torch.no_grad(): return self.model(**inputs) @@ -1199,6 +1075,8 @@ def decode(self, outputs): return self.post_processor(outputs) def __call__(self, *args, **kwargs): + import torch + args, kwargs = handle_agent_input_types(*args, **kwargs) if not self.is_initialized: @@ -1206,9 +1084,6 @@ def __call__(self, *args, **kwargs): encoded_inputs = self.encode(*args, **kwargs) - import torch - from accelerate.utils import send_to_device - tensor_inputs = { k: v for k, v in encoded_inputs.items() if isinstance(v, torch.Tensor) } @@ -1230,6 +1105,5 @@ def __call__(self, *args, **kwargs): "tool", "load_tool", "launch_gradio_demo", - "Toolbox", "ToolCollection", ] diff --git a/src/smolagents/types.py b/src/smolagents/types.py index dbc5d5bd7..d88293f41 100644 --- a/src/smolagents/types.py +++ b/src/smolagents/types.py @@ -22,10 +22,10 @@ import numpy as np import requests from transformers.utils import ( - is_soundfile_availble, is_torch_available, is_vision_available, ) +from transformers.utils.import_utils import _is_package_available logger = logging.getLogger(__name__) @@ -41,7 +41,7 @@ else: Tensor = object -if is_soundfile_availble(): +if _is_package_available("soundfile"): import soundfile as sf @@ -189,7 +189,7 @@ class AgentAudio(AgentType, str): def __init__(self, value, samplerate=16_000): super().__init__(value) - if not is_soundfile_availble(): + if not _is_package_available("soundfile"): raise ImportError("soundfile must be installed in order to handle audio.") self._path = None @@ -253,7 +253,7 @@ def to_string(self): INSTANCE_TYPE_MAPPING = { str: AgentText, ImageType: AgentImage, - torch.Tensor: AgentAudio, + Tensor: AgentAudio, } if is_torch_available(): @@ -277,7 +277,10 @@ def handle_agent_output_types(output, output_type=None): # If the class does not have defined output, then we map according to the type for _k, _v in INSTANCE_TYPE_MAPPING.items(): if isinstance(output, _k): - return _v(output) + if ( + _k is not object + ): # avoid converting to audio if torch is not installed + return _v(output) return output diff --git a/tests/test_agents.py b/tests/test_agents.py index 2d666e62a..f51ce9fe9 100644 --- a/tests/test_agents.py +++ b/tests/test_agents.py @@ -18,20 +18,23 @@ import uuid from pathlib import Path -import pytest from transformers.testing_utils import get_tests_dir from smolagents.agents import ( AgentMaxStepsError, CodeAgent, ManagedAgent, - Toolbox, ToolCall, ToolCallingAgent, ) from smolagents.default_tools import PythonInterpreterTool from smolagents.tools import tool from smolagents.types import AgentImage, AgentText +from huggingface_hub import ( + ChatCompletionOutputMessage, + ChatCompletionOutputToolCall, + ChatCompletionOutputFunctionDefinition, +) def get_new_path(suffix="") -> str: @@ -40,54 +43,106 @@ def get_new_path(suffix="") -> str: class FakeToolCallModel: - def get_tool_call( - self, messages, available_tools, stop_sequences=None, grammar=None + def __call__( + self, messages, tools_to_call_from=None, stop_sequences=None, grammar=None ): if len(messages) < 3: - return "python_interpreter", {"code": "2*3.6452"}, "call_0" + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="call_0", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="python_interpreter", arguments={"code": "2*3.6452"} + ), + ) + ], + ) else: - return "final_answer", {"answer": "7.2904"}, "call_1" + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="call_1", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="final_answer", arguments={"answer": "7.2904"} + ), + ) + ], + ) class FakeToolCallModelImage: - def get_tool_call( - self, messages, available_tools, stop_sequences=None, grammar=None + def __call__( + self, messages, tools_to_call_from=None, stop_sequences=None, grammar=None ): if len(messages) < 3: - return ( - "fake_image_generation_tool", - {"prompt": "An image of a cat"}, - "call_0", + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="call_0", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="fake_image_generation_tool", + arguments={"prompt": "An image of a cat"}, + ), + ) + ], + ) + else: + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="call_1", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="final_answer", arguments="image.png" + ), + ) + ], ) - - else: # We're at step 2 - return "final_answer", "image.png", "call_1" def fake_code_model(messages, stop_sequences=None, grammar=None) -> str: prompt = str(messages) if "special_marker" not in prompt: - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I should multiply 2 by 3.6452. special_marker Code: ```py result = 2**3.6452 ``` -""" +""", + ) else: # We're at step 2 - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I can now answer the initial question Code: ```py final_answer(7.2904) ``` -""" +""", + ) def fake_code_model_error(messages, stop_sequences=None) -> str: prompt = str(messages) if "special_marker" not in prompt: - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I should multiply 2 by 3.6452. special_marker Code: ```py @@ -96,21 +151,27 @@ def fake_code_model_error(messages, stop_sequences=None) -> str: print = 2 print("Ok, calculation done!") ``` -""" +""", + ) else: # We're at step 2 - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I can now answer the initial question Code: ```py final_answer("got an error") ``` -""" +""", + ) def fake_code_model_syntax_error(messages, stop_sequences=None) -> str: prompt = str(messages) if "special_marker" not in prompt: - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I should multiply 2 by 3.6452. special_marker Code: ```py @@ -119,32 +180,41 @@ def fake_code_model_syntax_error(messages, stop_sequences=None) -> str: print("Failing due to unexpected indent") print("Ok, calculation done!") ``` -""" +""", + ) else: # We're at step 2 - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I can now answer the initial question Code: ```py final_answer("got an error") ``` -""" +""", + ) def fake_code_model_import(messages, stop_sequences=None) -> str: - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I can answer the question Code: ```py import numpy as np final_answer("got an error") ``` -""" +""", + ) def fake_code_functiondef(messages, stop_sequences=None) -> str: prompt = str(messages) if "special_marker" not in prompt: - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: Let's define the function. special_marker Code: ```py @@ -153,9 +223,12 @@ def fake_code_functiondef(messages, stop_sequences=None) -> str: def moving_average(x, w): return np.convolve(x, np.ones(w), 'valid') / w ``` -""" +""", + ) else: # We're at step 2 - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I can now answer the initial question Code: ```py @@ -163,29 +236,36 @@ def moving_average(x, w): res = moving_average(x, w) final_answer(res) ``` -""" +""", + ) def fake_code_model_single_step(messages, stop_sequences=None, grammar=None) -> str: - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I should multiply 2 by 3.6452. special_marker Code: ```py result = python_interpreter(code="2*3.6452") final_answer(result) ``` -""" +""", + ) def fake_code_model_no_return(messages, stop_sequences=None, grammar=None) -> str: - return """ + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: I should multiply 2 by 3.6452. special_marker Code: ```py result = python_interpreter(code="2*3.6452") print(result) ``` -""" +""", + ) class AgentTests(unittest.TestCase): @@ -289,37 +369,35 @@ def test_fails_max_steps(self): assert len(agent.logs) == 8 assert type(agent.logs[-1].error) is AgentMaxStepsError + def test_tool_descriptions_get_baked_in_system_prompt(self): + tool = PythonInterpreterTool() + tool.name = "fake_tool_name" + tool.description = "fake_tool_description" + agent = CodeAgent(tools=[tool], model=fake_code_model) + agent.run("Empty task") + assert tool.name in agent.system_prompt + assert tool.description in agent.system_prompt + def test_init_agent_with_different_toolsets(self): toolset_1 = [] agent = CodeAgent(tools=toolset_1, model=fake_code_model) assert ( - len(agent.toolbox.tools) == 1 + len(agent.tools) == 1 ) # when no tools are provided, only the final_answer tool is added by default toolset_2 = [PythonInterpreterTool(), PythonInterpreterTool()] agent = CodeAgent(tools=toolset_2, model=fake_code_model) assert ( - len(agent.toolbox.tools) == 2 + len(agent.tools) == 2 ) # deduplication of tools, so only one python_interpreter tool is added in addition to final_answer - toolset_3 = Toolbox(toolset_2) - agent = CodeAgent(tools=toolset_3, model=fake_code_model) - assert ( - len(agent.toolbox.tools) == 2 - ) # same as previous one, where toolset_3 is an instantiation of previous one - - # check that add_base_tools will not interfere with existing tools - with pytest.raises(KeyError) as e: - agent = ToolCallingAgent( - tools=toolset_3, model=FakeToolCallModel(), add_base_tools=True - ) - assert "already exists in the toolbox" in str(e) - - # check that python_interpreter base tool does not get added to code agents + # check that python_interpreter base tool does not get added to CodeAgent agent = CodeAgent(tools=[], model=fake_code_model, add_base_tools=True) - assert ( - len(agent.toolbox.tools) == 3 - ) # added final_answer tool + search + transcribe + assert len(agent.tools) == 3 # added final_answer tool + search + visit_webpage + + # check that python_interpreter base tool gets added to ToolCallingAgent + agent = ToolCallingAgent(tools=[], model=fake_code_model, add_base_tools=True) + assert len(agent.tools) == 4 # added final_answer tool + search + visit_webpage def test_function_persistence_across_steps(self): agent = CodeAgent( @@ -364,52 +442,92 @@ def test_code_agent_missing_import_triggers_advice_in_error_log(self): def test_multiagents(self): class FakeModelMultiagentsManagerAgent: - def __call__(self, messages, stop_sequences=None, grammar=None): - if len(messages) < 3: - return """ + def __call__( + self, + messages, + stop_sequences=None, + grammar=None, + tools_to_call_from=None, + ): + if tools_to_call_from is not None: + if len(messages) < 3: + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="call_0", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="search_agent", + arguments="Who is the current US president?", + ), + ) + ], + ) + else: + assert "Report on the current US president" in str(messages) + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="call_0", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="final_answer", arguments="Final report." + ), + ) + ], + ) + else: + if len(messages) < 3: + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: Let's call our search agent. Code: ```py result = search_agent("Who is the current US president?") ``` -""" - else: - assert "Report on the current US president" in str(messages) - return """ +""", + ) + else: + assert "Report on the current US president" in str(messages) + return ChatCompletionOutputMessage( + role="assistant", + content=""" Thought: Let's return the report. Code: ```py final_answer("Final report.") ``` -""" - - def get_tool_call( - self, messages, available_tools, stop_sequences=None, grammar=None - ): - if len(messages) < 3: - return ( - "search_agent", - "Who is the current US president?", - "call_0", - ) - else: - assert "Report on the current US president" in str(messages) - return ( - "final_answer", - "Final report.", - "call_0", - ) +""", + ) manager_model = FakeModelMultiagentsManagerAgent() class FakeModelMultiagentsManagedAgent: - def get_tool_call( - self, messages, available_tools, stop_sequences=None, grammar=None + def __call__( + self, + messages, + tools_to_call_from=None, + stop_sequences=None, + grammar=None, ): - return ( - "final_answer", - {"report": "Report on the current US president"}, - "call_0", + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="call_0", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="final_answer", + arguments="Report on the current US president", + ), + ) + ], ) managed_model = FakeModelMultiagentsManagedAgent() @@ -447,13 +565,16 @@ def get_tool_call( def test_code_nontrivial_final_answer_works(self): def fake_code_model_final_answer(messages, stop_sequences=None, grammar=None): - return """Code: + return ChatCompletionOutputMessage( + role="assistant", + content="""Code: ```py def nested_answer(): final_answer("Correct!") nested_answer() -```""" +```""", + ) agent = CodeAgent(tools=[], model=fake_code_model_final_answer) diff --git a/tests/test_all_docs.py b/tests/test_all_docs.py index 343335210..3ad901d30 100644 --- a/tests/test_all_docs.py +++ b/tests/test_all_docs.py @@ -92,7 +92,6 @@ def setup_class(cls): raise ValueError(f"Docs directory not found at {cls.docs_dir}") load_dotenv() - cls.hf_token = os.getenv("HF_TOKEN") cls.md_files = list(cls.docs_dir.rglob("*.md")) if not cls.md_files: @@ -115,6 +114,7 @@ def test_single_doc(self, doc_path: Path): "from_langchain", # Langchain is not a dependency "while llm_should_continue(memory):", # This is pseudo code "ollama_chat/llama3.2", # Exclude ollama building in guided tour + "model = TransformersModel(model_id=model_id)", # Exclude testing with transformers model ] code_blocks = [ block @@ -131,10 +131,15 @@ def test_single_doc(self, doc_path: Path): ast.parse(block) # Create and execute test script + print("\n\nCollected code block:==========\n".join(code_blocks)) try: code_blocks = [ - block.replace("", self.hf_token).replace( - "{your_username}", "m-ric" + ( + block.replace( + "", os.getenv("HF_TOKEN") + ) + .replace("YOUR_ANTHROPIC_API_KEY", os.getenv("ANTHROPIC_API_KEY")) + .replace("{your_username}", "m-ric") ) for block in code_blocks ] diff --git a/tests/test_monitoring.py b/tests/test_monitoring.py index 5f2401de5..11594e7ff 100644 --- a/tests/test_monitoring.py +++ b/tests/test_monitoring.py @@ -22,42 +22,57 @@ ToolCallingAgent, stream_to_gradio, ) +from huggingface_hub import ( + ChatCompletionOutputMessage, + ChatCompletionOutputToolCall, + ChatCompletionOutputFunctionDefinition, +) -class MonitoringTester(unittest.TestCase): - def test_code_agent_metrics(self): - class FakeLLMModel: - def __init__(self): - self.last_input_token_count = 10 - self.last_output_token_count = 20 - - def __call__(self, prompt, **kwargs): - return """ +class FakeLLMModel: + def __init__(self): + self.last_input_token_count = 10 + self.last_output_token_count = 20 + + def __call__(self, prompt, tools_to_call_from=None, **kwargs): + if tools_to_call_from is not None: + return ChatCompletionOutputMessage( + role="assistant", + content="", + tool_calls=[ + ChatCompletionOutputToolCall( + id="fake_id", + type="function", + function=ChatCompletionOutputFunctionDefinition( + name="final_answer", arguments={"answer": "image"} + ), + ) + ], + ) + else: + return ChatCompletionOutputMessage( + role="assistant", + content=""" Code: ```py final_answer('This is the final answer.') -```""" +```""", + ) + +class MonitoringTester(unittest.TestCase): + def test_code_agent_metrics(self): agent = CodeAgent( tools=[], model=FakeLLMModel(), max_steps=1, ) - agent.run("Fake task") self.assertEqual(agent.monitor.total_input_token_count, 10) self.assertEqual(agent.monitor.total_output_token_count, 20) def test_json_agent_metrics(self): - class FakeLLMModel: - def __init__(self): - self.last_input_token_count = 10 - self.last_output_token_count = 20 - - def get_tool_call(self, prompt, **kwargs): - return "final_answer", {"answer": "image"}, "fake_id" - agent = ToolCallingAgent( tools=[], model=FakeLLMModel(), @@ -70,17 +85,19 @@ def get_tool_call(self, prompt, **kwargs): self.assertEqual(agent.monitor.total_output_token_count, 20) def test_code_agent_metrics_max_steps(self): - class FakeLLMModel: + class FakeLLMModelMalformedAnswer: def __init__(self): self.last_input_token_count = 10 self.last_output_token_count = 20 def __call__(self, prompt, **kwargs): - return "Malformed answer" + return ChatCompletionOutputMessage( + role="assistant", content="Malformed answer" + ) agent = CodeAgent( tools=[], - model=FakeLLMModel(), + model=FakeLLMModelMalformedAnswer(), max_steps=1, ) @@ -90,7 +107,7 @@ def __call__(self, prompt, **kwargs): self.assertEqual(agent.monitor.total_output_token_count, 40) def test_code_agent_metrics_generation_error(self): - class FakeLLMModel: + class FakeLLMModelGenerationException: def __init__(self): self.last_input_token_count = 10 self.last_output_token_count = 20 @@ -102,7 +119,7 @@ def __call__(self, prompt, **kwargs): agent = CodeAgent( tools=[], - model=FakeLLMModel(), + model=FakeLLMModelGenerationException(), max_steps=1, ) agent.run("Fake task") @@ -113,16 +130,9 @@ def __call__(self, prompt, **kwargs): self.assertEqual(agent.monitor.total_output_token_count, 0) def test_streaming_agent_text_output(self): - def dummy_model(prompt, **kwargs): - return """ -Code: -```py -final_answer('This is the final answer.') -```""" - agent = CodeAgent( tools=[], - model=dummy_model, + model=FakeLLMModel(), max_steps=1, ) @@ -135,16 +145,9 @@ def dummy_model(prompt, **kwargs): self.assertIn("This is the final answer.", final_message.content) def test_streaming_agent_image_output(self): - class FakeLLM: - def __init__(self): - pass - - def get_tool_call(self, messages, **kwargs): - return "final_answer", {"answer": "image"}, "fake_id" - agent = ToolCallingAgent( tools=[], - model=FakeLLM(), + model=FakeLLMModel(), max_steps=1, ) diff --git a/tests/test_python_interpreter.py b/tests/test_python_interpreter.py index 5f4ffc485..59440665b 100644 --- a/tests/test_python_interpreter.py +++ b/tests/test_python_interpreter.py @@ -18,8 +18,7 @@ import numpy as np import pytest -from smolagents import load_tool -from smolagents.default_tools import BASE_PYTHON_TOOLS +from smolagents.default_tools import BASE_PYTHON_TOOLS, PythonInterpreterTool from smolagents.local_python_executor import ( InterpreterError, evaluate_python_code, @@ -37,7 +36,7 @@ def add_two(x): class PythonInterpreterToolTester(unittest.TestCase, ToolTesterMixin): def setUp(self): - self.tool = load_tool("python_interpreter", authorized_imports=["sqlite3"]) + self.tool = PythonInterpreterTool(authorized_imports=["sqlite3"]) self.tool.setup() def test_exact_match_arg(self): diff --git a/tests/test_search.py b/tests/test_search.py index 488b97b69..7fc6c26df 100644 --- a/tests/test_search.py +++ b/tests/test_search.py @@ -15,14 +15,14 @@ import unittest -from smolagents import load_tool +from smolagents import DuckDuckGoSearchTool from .test_tools import ToolTesterMixin class DuckDuckGoSearchToolTester(unittest.TestCase, ToolTesterMixin): def setUp(self): - self.tool = load_tool("web_search") + self.tool = DuckDuckGoSearchTool() self.tool.setup() def test_exact_match_arg(self): diff --git a/tests/test_types.py b/tests/test_types.py index e988e8b20..aa58a8f07 100644 --- a/tests/test_types.py +++ b/tests/test_types.py @@ -18,20 +18,19 @@ import uuid from pathlib import Path -import torch from PIL import Image from transformers.testing_utils import ( require_soundfile, require_torch, require_vision, ) -from transformers.utils import ( - is_soundfile_availble, +from transformers.utils.import_utils import ( + _is_package_available, ) from smolagents.types import AgentAudio, AgentImage, AgentText -if is_soundfile_availble(): +if _is_package_available("soundfile"): import soundfile as sf @@ -44,6 +43,8 @@ def get_new_path(suffix="") -> str: @require_torch class AgentAudioTests(unittest.TestCase): def test_from_tensor(self): + import torch + tensor = torch.rand(12, dtype=torch.float64) - 0.5 agent_type = AgentAudio(tensor) path = str(agent_type.to_string()) @@ -61,6 +62,8 @@ def test_from_tensor(self): self.assertTrue(torch.allclose(tensor, torch.tensor(new_tensor), atol=1e-4)) def test_from_string(self): + import torch + tensor = torch.rand(12, dtype=torch.float64) - 0.5 path = get_new_path(suffix=".wav") sf.write(path, tensor, 16000) @@ -75,6 +78,8 @@ def test_from_string(self): @require_torch class AgentImageTests(unittest.TestCase): def test_from_tensor(self): + import torch + tensor = torch.randint(0, 256, (64, 64, 3)) agent_type = AgentImage(tensor) path = str(agent_type.to_string())