+ 
+ 
+ 
+
+
+
+
+
+
+
+ A smol library to build great agents!
+
+ 
+
+
+
+Writing actions in code rather than JSON-like snippets provides 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 have a computer do.
+- **Representation in LLM training data:** plenty of quality code actions are already included in LLMs’ training data which means they’re already trained for this!
diff --git a/docs/source/en/conceptual_guides/react.mdx b/docs/source/en/conceptual_guides/react.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..f07c41896e0a91838083b9d5dcc999ffa4fcb665
--- /dev/null
+++ b/docs/source/en/conceptual_guides/react.mdx
@@ -0,0 +1,63 @@
+
+# How do multi-step agents work?
+
+The ReAct framework ([Yao et al., 2022](https://huggingface.co/papers/2210.03629)) is currently the main approach to building agents.
+
+The name is based on the concatenation of two words, "Reason" and "Act." Indeed, agents following this architecture will solve their task in as many steps as needed, each step consisting of a Reasoning step, then an Action step where it formulates tool calls that will bring it closer to solving the task at hand.
+
+All agents in `smolagents` are based on singular `MultiStepAgent` class, which is an abstraction of ReAct framework.
+
+On a basic level, this class performs actions on a cycle of following steps, where existing variables and knowledge is incorporated into the agent logs like below:
+
+Initialization: the system prompt is stored in a `SystemPromptStep`, and the user query is logged into a `TaskStep` .
+
+While loop (ReAct loop):
+
+- Use `agent.write_memory_to_messages()` to write the agent logs into a list of LLM-readable [chat messages](https://huggingface.co/docs/transformers/en/chat_templating).
+- Send these messages to a `Model` object to get its completion. Parse the completion to get the action (a JSON blob for `ToolCallingAgent`, a code snippet for `CodeAgent`).
+- Execute the action and logs result into memory (an `ActionStep`).
+- At the end of each step, we run all callback functions defined in `agent.step_callbacks` .
+
+Optionally, when planning is activated, a plan can be periodically revised and stored in a `PlanningStep` . This includes feeding facts about the task at hand to the memory.
+
+For a `CodeAgent`, it looks like the figure below.
+
+
+
+
+
+Learn the basics and become familiar with using Agents. Start here if you are using Agents for the first time!
+ +Practical guides to help you achieve a specific goal: create an agent to generate and test SQL queries!
+ +High-level explanations for building a better understanding of important topics.
+ +Horizontal tutorials that cover important aspects of building agents.
+ +
+
+
+You can see that the CodeAgent called its managed ToolCallingAgent (by the way, the managed agent could have been a CodeAgent as well) to ask it to run the web search for the U.S. 2024 growth rate. Then the managed agent returned its report and the manager agent acted upon it to calculate the economy doubling time! Sweet, isn't it?
+
+## Setting up telemetry with Langfuse
+
+This part shows how to monitor and debug your Hugging Face **smolagents** with **Langfuse** using the `SmolagentsInstrumentor`.
+
+> **What is Langfuse?** [Langfuse](https://langfuse.com) is an open-source platform for LLM engineering. It provides tracing and monitoring capabilities for AI agents, helping developers debug, analyze, and optimize their products. Langfuse integrates with various tools and frameworks via native integrations, OpenTelemetry, and SDKs.
+
+### Step 1: Install Dependencies
+
+```python
+%pip install smolagents
+%pip install opentelemetry-sdk opentelemetry-exporter-otlp openinference-instrumentation-smolagents
+```
+
+### Step 2: Set Up Environment Variables
+
+Set your Langfuse API keys and configure the OpenTelemetry endpoint to send traces to Langfuse. Get your Langfuse API keys by signing up for [Langfuse Cloud](https://cloud.langfuse.com) or [self-hosting Langfuse](https://langfuse.com/self-hosting).
+
+Also, add your [Hugging Face token](https://huggingface.co/settings/tokens) (`HF_TOKEN`) as an environment variable.
+
+```python
+import os
+import base64
+
+LANGFUSE_PUBLIC_KEY="pk-lf-..."
+LANGFUSE_SECRET_KEY="sk-lf-..."
+LANGFUSE_AUTH=base64.b64encode(f"{LANGFUSE_PUBLIC_KEY}:{LANGFUSE_SECRET_KEY}".encode()).decode()
+
+os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "https://cloud.langfuse.com/api/public/otel" # EU data region
+# os.environ["OTEL_EXPORTER_OTLP_ENDPOINT"] = "https://us.cloud.langfuse.com/api/public/otel" # US data region
+os.environ["OTEL_EXPORTER_OTLP_HEADERS"] = f"Authorization=Basic {LANGFUSE_AUTH}"
+
+# your Hugging Face token
+os.environ["HF_TOKEN"] = "hf_..."
+```
+
+### Step 3: Initialize the `SmolagentsInstrumentor`
+
+Initialize the `SmolagentsInstrumentor` before your application code. Configure `tracer_provider` and add a span processor to export traces to Langfuse. `OTLPSpanExporter()` uses the endpoint and headers from the environment variables.
+
+
+```python
+from opentelemetry.sdk.trace import TracerProvider
+
+from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+from opentelemetry.exporter.otlp.proto.http.trace_exporter import OTLPSpanExporter
+from opentelemetry.sdk.trace.export import SimpleSpanProcessor
+
+trace_provider = TracerProvider()
+trace_provider.add_span_processor(SimpleSpanProcessor(OTLPSpanExporter()))
+
+SmolagentsInstrumentor().instrument(tracer_provider=trace_provider)
+```
+
+### Step 4: Run your smolagent
+
+```python
+from smolagents import (
+ CodeAgent,
+ ToolCallingAgent,
+ DuckDuckGoSearchTool,
+ VisitWebpageTool,
+ HfApiModel,
+)
+
+model = HfApiModel(
+ model_id="deepseek-ai/DeepSeek-R1-Distill-Qwen-32B"
+)
+
+search_agent = ToolCallingAgent(
+ tools=[DuckDuckGoSearchTool(), VisitWebpageTool()],
+ model=model,
+ name="search_agent",
+ description="This is an agent that can do web search.",
+)
+
+manager_agent = CodeAgent(
+ tools=[],
+ model=model,
+ managed_agents=[search_agent],
+)
+manager_agent.run(
+ "How can Langfuse be used to monitor and improve the reasoning and decision-making of smolagents when they execute multi-step tasks, like dynamically adjusting a recipe based on user feedback or available ingredients?"
+)
+```
+
+### Step 5: View Traces in Langfuse
+
+After running the agent, you can view the traces generated by your smolagents application in [Langfuse](https://cloud.langfuse.com). You should see detailed steps of the LLM interactions, which can help you debug and optimize your AI agent.
+
+
+
+_[Public example trace in Langfuse](https://cloud.langfuse.com/project/cloramnkj0002jz088vzn1ja4/traces/ce5160f9bfd5a6cd63b07d2bfcec6f54?timestamp=2025-02-11T09%3A25%3A45.163Z&display=details)_
diff --git a/docs/source/en/tutorials/memory.mdx b/docs/source/en/tutorials/memory.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..d038387a220d2ffdc06661a6c1d64bed99814f6a
--- /dev/null
+++ b/docs/source/en/tutorials/memory.mdx
@@ -0,0 +1,148 @@
+
+# 📚 Manage your agent's memory
+
+[[open-in-colab]]
+
+In the end, an agent can be defined by simple components: it has tools, prompts.
+And most importantly, it has a memory of past steps, drawing a history of planning, execution, and errors.
+
+### Replay your agent's memory
+
+We propose several features to inspect a past agent run.
+
+You can instrument the agent's run to display it in a great UI that lets you zoom in/out on specific steps, as highlighted in the [instrumentation guide](./inspect_runs).
+
+You can also use `agent.replay()`, as follows:
+
+After the agent has run:
+```py
+from smolagents import HfApiModel, CodeAgent
+
+agent = CodeAgent(tools=[], model=HfApiModel(), verbosity_level=0)
+
+result = agent.run("What's the 20th Fibonacci number?")
+```
+
+If you want to replay this last run, just use:
+```py
+agent.replay()
+```
+
+### Dynamically change the agent's memory
+
+Many advanced use cases require dynamic modification of the agent's memory.
+
+You can access the agent's memory using:
+
+```py
+from smolagents import ActionStep
+
+system_prompt_step = agent.memory.system_prompt
+print("The system prompt given to the agent was:")
+print(system_prompt_step.system_prompt)
+
+task_step = agent.memory.steps[0]
+print("\n\nThe first task step was:")
+print(task_step.task)
+
+for step in agent.memory.steps:
+ if isinstance(step, ActionStep):
+ if step.error is not None:
+ print(f"\nStep {step.step_number} got this error:\n{step.error}\n")
+ else:
+ print(f"\nStep {step.step_number} got these observations:\n{step.observations}\n")
+```
+
+Use `agent.memory.get_full_steps()` to get full steps as dictionaries.
+
+You can also use step callbacks to dynamically change the agent's memory.
+
+Step callbacks can access the `agent` itself in their arguments, so they can access any memory step as highlighted above, and change it if needed. For instance, let's say you are observing screenshots of each step performed by a web browser agent. You want to log the newest screenshot, and remove the images from ancient steps to save on token costs.
+
+You culd run something like the following.
+_Note: this code is incomplete, some imports and object definitions have been removed for the sake of concision, visit [the original script](https://github.com/huggingface/smolagents/blob/main/src/smolagents/vision_web_browser.py) to get the full working code._
+
+```py
+import helium
+from PIL import Image
+from io import BytesIO
+from time import sleep
+
+def update_screenshot(memory_step: ActionStep, agent: CodeAgent) -> None:
+ sleep(1.0) # Let JavaScript animations happen before taking the screenshot
+ driver = helium.get_driver()
+ latest_step = memory_step.step_number
+ for previous_memory_step in agent.memory.steps: # Remove previous screenshots from logs for lean processing
+ if isinstance(previous_memory_step, ActionStep) and previous_memory_step.step_number <= latest_step - 2:
+ previous_memory_step.observations_images = None
+ png_bytes = driver.get_screenshot_as_png()
+ image = Image.open(BytesIO(png_bytes))
+ memory_step.observations_images = [image.copy()]
+```
+
+Then you should pass this function in the `step_callbacks` argument upon initialization of your agent:
+
+```py
+CodeAgent(
+ tools=[DuckDuckGoSearchTool(), go_back, close_popups, search_item_ctrl_f],
+ model=model,
+ additional_authorized_imports=["helium"],
+ step_callbacks=[update_screenshot],
+ max_steps=20,
+ verbosity_level=2,
+)
+```
+
+Head to our [vision web browser code](https://github.com/huggingface/smolagents/blob/main/src/smolagents/vision_web_browser.py) to see the full working example.
+
+### Run agents one step at a time
+
+This can be useful in case you have tool calls that take days: you can just run your agents step by step.
+This will also let you update the memory on each step.
+
+```py
+from smolagents import HfApiModel, CodeAgent, ActionStep, TaskStep
+
+agent = CodeAgent(tools=[], model=HfApiModel(), verbosity_level=1)
+print(agent.memory.system_prompt)
+
+task = "What is the 20th Fibonacci number?"
+
+# You could modify the memory as needed here by inputting the memory of another agent.
+# agent.memory.steps = previous_agent.memory.steps
+
+# Let's start a new task!
+agent.memory.steps.append(TaskStep(task=task, task_images=[]))
+
+final_answer = None
+step_number = 1
+while final_answer is None and step_number <= 10:
+ memory_step = ActionStep(
+ step_number=step_number,
+ observations_images=[],
+ )
+ # Run one step.
+ final_answer = agent.step(memory_step)
+ agent.memory.steps.append(memory_step)
+ step_number += 1
+
+ # Change the memory as you please!
+ # For instance to update the latest step:
+ # agent.memory.steps[-1] = ...
+
+print("The final answer is:", final_answer)
+```
\ No newline at end of file
diff --git a/docs/source/en/tutorials/secure_code_execution.mdx b/docs/source/en/tutorials/secure_code_execution.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..c71f42d8892b26c30d60e810539581ca43305367
--- /dev/null
+++ b/docs/source/en/tutorials/secure_code_execution.mdx
@@ -0,0 +1,317 @@
+
+# Secure code execution
+
+[[open-in-colab]]
+
+> [!TIP]
+> If you're new to building agents, make sure to first read the [intro to agents](../conceptual_guides/intro_agents) and the [guided tour of smolagents](../guided_tour).
+
+### Code agents
+
+[Multiple](https://huggingface.co/papers/2402.01030) [research](https://huggingface.co/papers/2411.01747) [papers](https://huggingface.co/papers/2401.00812) have shown that having the LLM write its actions (the tool calls) in code is much better than the current standard format for tool calling, which is across the industry different shades of "writing actions as a JSON of tools names and arguments to use".
+
+Why is code better? Well, because we crafted our code languages specifically to be great at expressing actions performed by a computer. If JSON snippets were a better way, this package would have been written in JSON snippets and the devil would be laughing at us.
+
+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 have a computer do.
+- **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).
+
+
+
+This is why we put emphasis on proposing code agents, in this case python agents, which meant putting higher effort on building secure python interpreters.
+
+### Local code execution??
+
+By default, the `CodeAgent` runs LLM-generated code in your environment.
+
+This is inherently risky, LLM-generated code could be harmful to your environment.
+One could argue that on the [spectrum of agency](../conceptual_guides/intro_agents), code agents give much higher agency to the LLM on your system than other less agentic setups: this goes hand-in-hand with higher risk.
+
+So you need to be mindful of security.
+
+To add a first layer of security, code execution in `smolagents` is not performed by the vanilla Python interpreter.
+We have re-built a more secure `LocalPythonExecutor` from the ground up.
+
+To be precise, this interpreter works by loading the Abstract Syntax Tree (AST) from your Code and executes it operation by operation, making sure to always follow certain rules:
+- By default, imports are disallowed unless they have been explicitly added to an authorization list by the user.
+ - Even so, because some innocuous packages like `re` can give access to potentially harmful packages as in `re.subprocess`, subpackages that match a list of dangerous patterns are not imported.
+ - The total count of elementary operations processed is capped to prevent infinite loops and resource bloating.
+ - Any operation that has not been explicitly defined in our custom interpreter will raise an error.
+
+As a result, this interpreter is safer. We have used it on a diversity of use cases, without ever observing any damage to the environment.
+
+However, this solution is certainly not watertight, as no local python sandbox can really be: one could imagine occasions where LLMs fine-tuned for malignant actions could still hurt your environment.
+
+For instance, if you have allowed an innocuous package like `Pillow` to process images, the LLM could generate thousands of image saves to bloat your hard drive.
+Other examples of attacks can be found [here](https://gynvael.coldwind.pl/n/python_sandbox_escape).
+
+Running these targeted malicious code snippet require a supply chain attack, meaning the LLM you use has been intoxicated.
+
+The likelihood of this happening is low when using well-known LLMs from trusted inference providers, but it is still non-zero.
+
+> [!WARNING]
+> The only way to run LLM-generated code securely is to isolate the execution from your local environment.
+
+So if you want to exercise caution, you should use a remote execution sandbox.
+
+Here are examples of how to do it.
+
+## Sandbox setup for secure code execution
+
+When working with AI agents that execute code, security is paramount. This guide describes how to set up and use secure sandboxes for your agent applications using either E2B cloud sandboxes or local Docker containers.
+
+### E2B setup
+
+#### Installation
+
+1. Create an E2B account at [e2b.dev](https://e2b.dev)
+2. Install the required packages:
+```bash
+pip install 'smolagents[e2b]'
+```
+
+#### Running your agent in E2B: mono agents
+
+We provide a simple way to use an E2B Sandbox: simply add `executor_type="e2b"` to the agent initialization, like:
+```py
+from smolagents import HfApiModel, CodeAgent
+
+agent = CodeAgent(model=HfApiModel(), tools=[], executor_type="e2b")
+
+agent.run("Can you give me the 100th Fibonacci number?")
+```
+
+However, this does not work (yet) with more complicated multi-agent setups.
+
+#### Running your agent in E2B: multi-agents
+
+To use multi-agents in an E2B sandbox, you need to run your agents completely from within E2B.
+
+Here is how to do it:
+
+```python
+from e2b_code_interpreter import Sandbox
+import os
+
+# Create the sandbox
+sandbox = Sandbox()
+
+# Install required packages
+sandbox.commands.run("pip install smolagents")
+
+def run_code_raise_errors(sandbox, code: str, verbose: bool = False) -> str:
+ execution = sandbox.run_code(
+ code,
+ envs={'HF_TOKEN': os.getenv('HF_TOKEN')}
+ )
+ if execution.error:
+ execution_logs = "\n".join([str(log) for log in execution.logs.stdout])
+ logs = execution_logs
+ logs += execution.error.traceback
+ raise ValueError(logs)
+ return "\n".join([str(log) for log in execution.logs.stdout])
+
+# Define your agent application
+agent_code = """
+import os
+from smolagents import CodeAgent, HfApiModel
+
+# Initialize the agents
+agent = CodeAgent(
+ model=HfApiModel(token=os.getenv("HF_TOKEN"), provider="together"),
+ tools=[],
+ name="coder_agent",
+ description="This agent takes care of your difficult algorithmic problems using code."
+)
+
+manager_agent = CodeAgent(
+ model=HfApiModel(token=os.getenv("HF_TOKEN"), provider="together"),
+ tools=[],
+ managed_agents=[agent],
+)
+
+# Run the agent
+response = manager_agent.run("What's the 20th Fibonacci number?")
+print(response)
+"""
+
+# Run the agent code in the sandbox
+execution_logs = run_code_raise_errors(sandbox, agent_code)
+print(execution_logs)
+```
+
+### Docker setup
+
+#### Installation
+
+1. [Install Docker on your system](https://docs.docker.com/get-started/get-docker/)
+2. Install the required packages:
+```bash
+pip install 'smolagents[docker]'
+```
+
+#### Setting up the docker sandbox
+
+Create a Dockerfile for your agent environment:
+
+```dockerfile
+FROM python:3.10-bullseye
+
+# Install build dependencies
+RUN apt-get update && \
+ apt-get install -y --no-install-recommends \
+ build-essential \
+ python3-dev && \
+ pip install --no-cache-dir --upgrade pip && \
+ pip install --no-cache-dir smolagents && \
+ apt-get clean && \
+ rm -rf /var/lib/apt/lists/*
+
+# Set working directory
+WORKDIR /app
+
+# Run with limited privileges
+USER nobody
+
+# Default command
+CMD ["python", "-c", "print('Container ready')"]
+```
+
+Create a sandbox manager to run code:
+
+```python
+import docker
+import os
+from typing import Optional
+
+class DockerSandbox:
+ def __init__(self):
+ self.client = docker.from_env()
+ self.container = None
+
+ def create_container(self):
+ try:
+ image, build_logs = self.client.images.build(
+ path=".",
+ tag="agent-sandbox",
+ rm=True,
+ forcerm=True,
+ buildargs={},
+ # decode=True
+ )
+ except docker.errors.BuildError as e:
+ print("Build error logs:")
+ for log in e.build_log:
+ if 'stream' in log:
+ print(log['stream'].strip())
+ raise
+
+ # Create container with security constraints and proper logging
+ self.container = self.client.containers.run(
+ "agent-sandbox",
+ command="tail -f /dev/null", # Keep container running
+ detach=True,
+ tty=True,
+ mem_limit="512m",
+ cpu_quota=50000,
+ pids_limit=100,
+ security_opt=["no-new-privileges"],
+ cap_drop=["ALL"],
+ environment={
+ "HF_TOKEN": os.getenv("HF_TOKEN")
+ },
+ )
+
+ def run_code(self, code: str) -> Optional[str]:
+ if not self.container:
+ self.create_container()
+
+ # Execute code in container
+ exec_result = self.container.exec_run(
+ cmd=["python", "-c", code],
+ user="nobody"
+ )
+
+ # Collect all output
+ return exec_result.output.decode() if exec_result.output else None
+
+
+ def cleanup(self):
+ if self.container:
+ try:
+ self.container.stop()
+ except docker.errors.NotFound:
+ # Container already removed, this is expected
+ pass
+ except Exception as e:
+ print(f"Error during cleanup: {e}")
+ finally:
+ self.container = None # Clear the reference
+
+# Example usage:
+sandbox = DockerSandbox()
+
+try:
+ # Define your agent code
+ agent_code = """
+import os
+from smolagents import CodeAgent, HfApiModel
+
+# Initialize the agent
+agent = CodeAgent(
+ model=HfApiModel(token=os.getenv("HF_TOKEN"), provider="together"),
+ tools=[]
+)
+
+# Run the agent
+response = agent.run("What's the 20th Fibonacci number?")
+print(response)
+"""
+
+ # Run the code in the sandbox
+ output = sandbox.run_code(agent_code)
+ print(output)
+
+finally:
+ sandbox.cleanup()
+```
+
+### Best practices for sandboxes
+
+These key practices apply to both E2B and Docker sandboxes:
+
+- Resource management
+ - Set memory and CPU limits
+ - Implement execution timeouts
+ - Monitor resource usage
+- Security
+ - Run with minimal privileges
+ - Disable unnecessary network access
+ - Use environment variables for secrets
+- Environment
+ - Keep dependencies minimal
+ - Use fixed package versions
+ - If you use base images, update them regularly
+
+- Cleanup
+ - Always ensure proper cleanup of resources, especially for Docker containers, to avoid having dangling containers eating up resources.
+
+✨ By following these practices and implementing proper cleanup procedures, you can ensure your agent runs safely and efficiently in a sandboxed environment.
\ No newline at end of file
diff --git a/docs/source/en/tutorials/tools.mdx b/docs/source/en/tutorials/tools.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..cf84e060d0b2022ee14065c7673f56b8d7fcccde
--- /dev/null
+++ b/docs/source/en/tutorials/tools.mdx
@@ -0,0 +1,247 @@
+
+# Tools
+
+[[open-in-colab]]
+
+Here, we're going to see advanced tool usage.
+
+> [!TIP]
+> If you're new to building agents, make sure to first read the [intro to agents](../conceptual_guides/intro_agents) and the [guided tour of smolagents](../guided_tour).
+
+- [Tools](#tools)
+ - [What is a tool, and how to build one?](#what-is-a-tool-and-how-to-build-one)
+ - [Share your tool to the Hub](#share-your-tool-to-the-hub)
+ - [Import a Space as a tool](#import-a-space-as-a-tool)
+ - [Use LangChain tools](#use-langchain-tools)
+ - [Manage your agent's toolbox](#manage-your-agents-toolbox)
+ - [Use a collection of tools](#use-a-collection-of-tools)
+
+### What is a tool, and how to build one?
+
+A tool is mostly a function that an LLM can use in an agentic system.
+
+But to use it, the LLM will need to be given an API: name, tool description, input types and descriptions, output type.
+
+So it cannot be only a function. It should be a class.
+
+So at core, the tool is a class that wraps a function with metadata that helps the LLM understand how to use it.
+
+Here's how it looks:
+
+```python
+from smolagents import Tool
+
+class HFModelDownloadsTool(Tool):
+ name = "model_download_counter"
+ description = """
+ This is a tool that returns the most downloaded model of a given task on the Hugging Face Hub.
+ It returns the name of the checkpoint."""
+ inputs = {
+ "task": {
+ "type": "string",
+ "description": "the task category (such as text-classification, depth-estimation, etc)",
+ }
+ }
+ output_type = "string"
+
+ def forward(self, task: str):
+ from huggingface_hub import list_models
+
+ model = next(iter(list_models(filter=task, sort="downloads", direction=-1)))
+ return model.id
+
+model_downloads_tool = HFModelDownloadsTool()
+```
+
+The custom tool subclasses [`Tool`] to inherit useful methods. The child class also defines:
+- An attribute `name`, which corresponds to the name of the tool itself. The name usually describes what the tool does. Since the code returns the model with the most downloads for a task, let's name it `model_download_counter`.
+- An attribute `description` is used to populate the agent's system prompt.
+- An `inputs` attribute, which is a dictionary with keys `"type"` and `"description"`. It contains information that helps the Python interpreter make educated choices about the input.
+- An `output_type` attribute, which specifies the output type. The types for both `inputs` and `output_type` should be [Pydantic formats](https://docs.pydantic.dev/latest/concepts/json_schema/#generating-json-schema), they can be either of these: [`~AUTHORIZED_TYPES`].
+- A `forward` method which contains the inference code to be executed.
+
+And that's all it needs to be used in an agent!
+
+There's another way to build a tool. In the [guided_tour](../guided_tour), we implemented a tool using the `@tool` decorator. The [`tool`] decorator is the recommended way to define simple tools, but sometimes you need more than this: using several methods in a class for more clarity, or using additional class attributes.
+
+In this case, you can build your tool by subclassing [`Tool`] as described above.
+
+### Share your tool to the Hub
+
+You can share your custom tool to the Hub by calling [`~Tool.push_to_hub`] on the tool. Make sure you've created a repository for it on the Hub and are using a token with read access.
+
+```python
+model_downloads_tool.push_to_hub("{your_username}/hf-model-downloads", token="
+
+Then you can use this tool just like any other tool. For example, let's improve the prompt `a rabbit wearing a space suit` and generate an image of it. This example also shows how you can pass additional arguments to the agent.
+
+```python
+from smolagents import CodeAgent, HfApiModel
+
+model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+agent = CodeAgent(tools=[image_generation_tool], model=model)
+
+agent.run(
+ "Improve this prompt, then generate an image of it.", additional_args={'user_prompt': 'A rabbit wearing a space suit'}
+)
+```
+
+```text
+=== Agent thoughts:
+improved_prompt could be "A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background"
+
+Now that I have improved the prompt, I can use the image generator tool to generate an image based on this prompt.
+>>> Agent is executing the code below:
+image = image_generator(prompt="A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background")
+final_answer(image)
+```
+
+
+
+How cool is this? 🤩
+
+### Use LangChain tools
+
+We love Langchain and think it has a very compelling suite of tools.
+To import a tool from LangChain, use the `from_langchain()` method.
+
+Here is how you can use it to recreate the intro's search result using a LangChain web search tool.
+This tool will need `pip install langchain google-search-results -q` to work properly.
+```python
+from langchain.agents import load_tools
+
+search_tool = Tool.from_langchain(load_tools(["serpapi"])[0])
+
+agent = CodeAgent(tools=[search_tool], model=model)
+
+agent.run("How many more blocks (also denoted as layers) are in BERT base encoder compared to the encoder from the architecture proposed in Attention is All You Need?")
+```
+
+### Manage your agent's toolbox
+
+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.
+
+```python
+from smolagents import HfApiModel
+
+model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+
+agent = CodeAgent(tools=[], model=model, add_base_tools=True)
+agent.tools[model_download_tool.name] = model_download_tool
+```
+Now we can leverage the new tool:
+
+```python
+agent.run(
+ "Can you give me the name of the model that has the most downloads in the 'text-to-video' task on the Hugging Face Hub but reverse the letters?"
+)
+```
+
+
+> [!TIP]
+> Beware of not adding too many tools to an agent: this can overwhelm weaker LLM engines.
+
+
+### Use a collection of tools
+
+You can leverage tool collections by using the `ToolCollection` object. It supports loading either a collection from the Hub or an MCP server tools.
+
+#### Tool Collection from a collection in the Hub
+
+You can leverage it with the slug of the collection you want to use.
+Then pass them as a list to initialize your agent, and start using them!
+
+```py
+from smolagents import ToolCollection, CodeAgent
+
+image_tool_collection = ToolCollection.from_hub(
+ collection_slug="huggingface-tools/diffusion-tools-6630bb19a942c2306a2cdb6f",
+ token="
+
+JSON जैसे स्निपेट्स की बजाय कोड में क्रियाएं लिखने से बेहतर प्राप्त होता है:
+
+- **कम्पोजेबिलिटी:** क्या आप JSON क्रियाओं को एक-दूसरे के भीतर नेस्ट कर सकते हैं, या बाद में पुन: उपयोग करने के लिए JSON क्रियाओं का एक सेट परिभाषित कर सकते हैं, उसी तरह जैसे आप बस एक पायथन फंक्शन परिभाषित कर सकते हैं?
+- **ऑब्जेक्ट प्रबंधन:** आप `generate_image` जैसी क्रिया के आउटपुट को JSON में कैसे स्टोर करते हैं?
+- **सामान्यता:** कोड को सरल रूप से कुछ भी व्यक्त करने के लिए बनाया गया है जो आप कंप्यूटर से करवा सकते हैं।
+- **LLM प्रशिक्षण डेटा में प्रतिनिधित्व:** बहुत सारी गुणवत्तापूर्ण कोड क्रियाएं पहले से ही LLM के ट्रेनिंग डेटा में शामिल हैं जिसका मतलब है कि वे इसके लिए पहले से ही प्रशिक्षित हैं!
\ No newline at end of file
diff --git a/docs/source/hi/conceptual_guides/react.mdx b/docs/source/hi/conceptual_guides/react.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..ebc950f12affe723d0fb30bdda2957eda04225ea
--- /dev/null
+++ b/docs/source/hi/conceptual_guides/react.mdx
@@ -0,0 +1,44 @@
+
+# मल्टी-स्टेप एजेंट्स कैसे काम करते हैं?
+
+ReAct फ्रेमवर्क ([Yao et al., 2022](https://huggingface.co/papers/2210.03629)) वर्तमान में एजेंट्स बनाने का मुख्य दृष्टिकोण है।
+
+नाम दो शब्दों, "Reason" (तर्क) और "Act" (क्रिया) के संयोजन पर आधारित है। वास्तव में, इस आर्किटेक्चर का पालन करने वाले एजेंट अपने कार्य को उतने चरणों में हल करेंगे जितने आवश्यक हों, प्रत्येक चरण में एक Reasoning कदम होगा, फिर एक Action कदम होगा, जहाँ यह टूल कॉल्स तैयार करेगा जो उसे कार्य को हल करने के करीब ले जाएंगे।
+
+ReAct प्रक्रिया में पिछले चरणों की मेमोरी रखना शामिल है।
+
+> [!TIP]
+> मल्टी-स्टेप एजेंट्स के बारे में अधिक जानने के लिए [Open-source LLMs as LangChain Agents](https://huggingface.co/blog/open-source-llms-as-agents) ब्लॉग पोस्ट पढ़ें।
+
+यहाँ एक वीडियो ओवरव्यू है कि यह कैसे काम करता है:
+
+
+
+
+बेसिक्स सीखें और एजेंट्स का उपयोग करने में परिचित हों। यदि आप पहली बार एजेंट्स का उपयोग कर रहे हैं तो यहाँ से शुरू करें!
+ +एक विशिष्ट लक्ष्य प्राप्त करने में मदद के लिए गाइड: SQL क्वेरी जनरेट और टेस्ट करने के लिए एजेंट बनाएं!
+ +महत्वपूर्ण विषयों की बेहतर समझ बनाने के लिए उच्च-स्तरीय व्याख्याएं।
+ +एजेंट्स बनाने के महत्वपूर्ण पहलुओं को कवर करने वाले क्ट्यूटोरियल्स।
+ +
+
+आप देख सकते हैं कि CodeAgent ने अपने मैनेज्ड ToolCallingAgent को (वैसे, मैनेज्ड एजेंट एक CodeAgent भी हो सकता था) U.S. 2024 ग्रोथ रेट के लिए वेब सर्च चलाने के लिए कॉल किया। फिर मैनेज्ड एजेंट ने अपनी रिपोर्ट लौटाई और मैनेजर एजेंट ने अर्थव्यवस्था के दोगुना होने का समय गणना करने के लिए उस पर कार्य किया! अच्छा है, है ना?
\ No newline at end of file
diff --git a/docs/source/hi/tutorials/secure_code_execution.mdx b/docs/source/hi/tutorials/secure_code_execution.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..4c16e9fdaffdc6637bf66b27b13664b9ccdb232d
--- /dev/null
+++ b/docs/source/hi/tutorials/secure_code_execution.mdx
@@ -0,0 +1,82 @@
+
+# सुरक्षित कोड एक्जीक्यूशन
+
+[[open-in-colab]]
+
+> [!TIP]
+> यदि आप एजेंट्स बनाने में नए हैं, तो सबसे पहले [एजेंट्स का परिचय](../conceptual_guides/intro_agents) और [smolagents की गाइडेड टूर](../guided_tour) पढ़ना सुनिश्चित करें।
+
+### कोड Agents
+
+[कई](https://huggingface.co/papers/2402.01030) [शोध](https://huggingface.co/papers/2411.01747) [पत्रों](https://huggingface.co/papers/2401.00812) ने दिखाया है कि LLM द्वारा अपनी क्रियाओं (टूल कॉल्स) को कोड में लिखना, टूल कॉलिंग के वर्तमान मानक प्रारूप से बहुत बेहतर है, जो industry में "टूल्स नेम्स और आर्ग्यूमेंट्स को JSON के रूप में लिखने" के विभिन्न रूप हैं।
+
+कोड बेहतर क्यों है? क्योंकि हमने अपनी कोड भाषाओं को विशेष रूप से कंप्यूटर द्वारा की जाने वाली क्रियाओं को व्यक्त करने के लिए तैयार किया है। यदि JSON स्निपेट्स एक बेहतर तरीका होता, तो यह पैकेज JSON स्निपेट्स में लिखा गया होता और शैतान हम पर हंस रहा होता।
+
+कोड कंप्यूटर पर क्रियाएँ व्यक्त करने का बेहतर तरीका है। इसमें बेहतर है:
+- **कंपोज़ेबिलिटी:** क्या आप JSON क्रियाओं को एक-दूसरे के भीतर नेस्ट कर सकते हैं, या बाद में पुन: उपयोग करने के लिए JSON क्रियाओं का एक सेट परिभाषित कर सकते हैं, जैसे आप बस एक पायथन फ़ंक्शन परिभाषित कर सकते हैं?
+- **ऑब्जेक्ट प्रबंधन:** JSON में `generate_image` जैसी क्रिया का आउटपुट कैसे स्टोर करें?
+- **सामान्यता:** कोड किसी भी कंप्यूटर कार्य को व्यक्त करने के लिए बनाया गया है।
+- **LLM प्रशिक्षण कॉर्पस में प्रतिनिधित्व:** क्यों न इस आशीर्वाद का लाभ उठाएं कि उच्च गुणवत्ता वाले कोड उदाहरण पहले से ही LLM प्रशिक्षण डेटा में शामिल हैं?
+
+यह नीचे दी गई छवि में दर्शाया गया है, जो [Executable Code Actions Elicit Better LLM Agents](https://huggingface.co/papers/2402.01030) से ली गई है।
+
+
+
+यही कारण है कि हमने कोड एजेंट्स, इस मामले में पायथन एजेंट्स पर जोर दिया, जिसका मतलब सुरक्षित पायथन इंटरप्रेटर बनाने पर अधिक प्रयास करना था।
+
+### लोकल पायथन इंटरप्रेटर
+
+डिफ़ॉल्ट रूप से, `CodeAgent` LLM-जनरेटेड कोड को आपके एनवायरनमेंट में चलाता है।
+यह एक्जीक्यूशन वैनिला पायथन इंटरप्रेटर द्वारा नहीं किया जाता: हमने एक अधिक सुरक्षित `LocalPythonExecutor` को शुरू से फिर से बनाया है।
+यह इंटरप्रेटर सुरक्षा के लिए डिज़ाइन किया गया है:
+ - इम्पोर्ट्स को उपयोगकर्ता द्वारा स्पष्ट रूप से पास की गई सूची तक सीमित करना
+ - इनफिनिट लूप्स और रिसोर्स ब्लोटिंग को रोकने के लिए ऑपरेशंस की संख्या को कैप करना
+ - कोई भी ऐसा ऑपरेशन नहीं करेगा जो पूर्व-परिभाषित नहीं है
+
+हमने इसे कई उपयोग मामलों में इस्तेमाल किया है, और कभी भी एनवायरनमेंट को कोई नुकसान नहीं देखा।
+
+हालांकि यह समाधान पूरी तरह से सुरक्षित नहीं है: कोई ऐसे अवसरों की कल्पना कर सकता है जहां दुर्भावनापूर्ण कार्यों के लिए फाइन-ट्यून किए गए LLM अभी भी आपके एनवायरनमेंट को नुकसान पहुंचा सकते हैं। उदाहरण के लिए यदि आपने छवियों को प्रोसेस करने के लिए `Pillow` जैसे मासूम पैकेज की अनुमति दी है, तो LLM आपकी हार्ड ड्राइव को ब्लोट करने के लिए हजारों छवियों को सेव कर सकता है।
+यदि आपने खुद LLM इंजन चुना है तो यह निश्चित रूप से संभावित नहीं है, लेकिन यह हो सकता है।
+
+तो यदि आप अतिरिक्त सावधानी बरतना चाहते हैं, तो आप नीचे वर्णित रिमोट कोड एक्जीक्यूशन विकल्प का उपयोग कर सकते हैं।
+
+### E2B कोड एक्जीक्यूटर
+
+अधिकतम सुरक्षा के लिए, आप कोड को सैंडबॉक्स्ड एनवायरनमेंट में चलाने के लिए E2B के साथ हमारे एकीकरण का उपयोग कर सकते हैं। यह एक रिमोट एक्जीक्यूशन सेवा है जो आपके कोड को एक आइसोलेटेड कंटेनर में चलाती है, जिससे कोड का आपके स्थानीय एनवायरनमेंट को प्रभावित करना असंभव हो जाता है।
+
+इसके लिए, आपको अपना E2B अकाउंट सेटअप करने और अपने एनवायरनमेंट वेरिएबल्स में अपना `E2B_API_KEY` सेट करने की आवश्यकता होगी। अधिक जानकारी के लिए [E2B की क्विकस्टार्ट डॉक्यूमेंटेशन](https://e2b.dev/docs/quickstart) पर जाएं।
+
+फिर आप इसे `pip install e2b-code-interpreter python-dotenv` के साथ इंस्टॉल कर सकते हैं।
+
+अब आप तैयार हैं!
+
+कोड एक्जीक्यूटर को E2B पर सेट करने के लिए, बस अपने `CodeAgent` को इनिशियलाइज़ करते समय `executor_type="e2b"` फ्लैग पास करें।
+ध्यान दें कि आपको `additional_authorized_imports` में सभी टूल की डिपेंडेंसीज़ जोड़नी चाहिए, ताकि एक्जीक्यूटर उन्हें इंस्टॉल करे।
+
+```py
+from smolagents import CodeAgent, VisitWebpageTool, HfApiModel
+agent = CodeAgent(
+ tools = [VisitWebpageTool()],
+ model=HfApiModel(),
+ additional_authorized_imports=["requests", "markdownify"],
+ executor_type="e2b"
+)
+
+agent.run("What was Abraham Lincoln's preferred pet?")
+```
+
+E2B कोड एक्जीक्यूशन वर्तमान में मल्टी-एजेंट्स के साथ काम नहीं करता है - क्योंकि कोड ब्लॉब में एक एजेंट कॉल करना जो रिमोटली एक्जीक्यूट किया जाना चाहिए, यह एक गड़बड़ है। लेकिन हम इसे जोड़ने पर काम कर रहे हैं!
diff --git a/docs/source/hi/tutorials/tools.mdx b/docs/source/hi/tutorials/tools.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..83b829112203f8bdc75ab7731dcd80f9020b60ef
--- /dev/null
+++ b/docs/source/hi/tutorials/tools.mdx
@@ -0,0 +1,247 @@
+
+# Tools
+
+[[open-in-colab]]
+
+यहाँ, हम एडवांस्ड tools उपयोग देखेंगे।
+
+> [!TIP]
+> यदि आप एजेंट्स बनाने में नए हैं, तो सबसे पहले [एजेंट्स का परिचय](../conceptual_guides/intro_agents) और [smolagents की गाइडेड टूर](../guided_tour) पढ़ना सुनिश्चित करें।
+
+- [Tools](#tools)
+ - [टूल क्या है, और इसे कैसे बनाएं?](#टूल-क्या-है-और-इसे-कैसे-बनाएं)
+ - [अपना टूल हब पर शेयर करें](#अपना-टूल-हब-पर-शेयर-करें)
+ - [स्पेस को टूल के रूप में इम्पोर्ट करें](#स्पेस-को-टूल-के-रूप-में-इम्पोर्ट-करें)
+ - [LangChain टूल्स का उपयोग करें](#LangChain-टूल्स-का-उपयोग-करें)
+ - [अपने एजेंट के टूलबॉक्स को मैनेज करें](#अपने-एजेंट-के-टूलबॉक्स-को-मैनेज-करें)
+ - [टूल्स का कलेक्शन उपयोग करें](#टूल्स-का-कलेक्शन-उपयोग-करें)
+
+### टूल क्या है और इसे कैसे बनाएं
+
+टूल मुख्य रूप से एक फ़ंक्शन है जिसे एक LLM एजेंटिक सिस्टम में उपयोग कर सकता है।
+
+लेकिन इसका उपयोग करने के लिए, LLM को एक API दी जाएगी: नाम, टूल विवरण, इनपुट प्रकार और विवरण, आउटपुट प्रकार।
+
+इसलिए यह केवल एक फ़ंक्शन नहीं हो सकता। यह एक क्लास होनी चाहिए।
+
+तो मूल रूप से, टूल एक क्लास है जो एक फ़ंक्शन को मेटाडेटा के साथ रैप करती है जो LLM को समझने में मदद करती है कि इसका उपयोग कैसे करें।
+
+यह कैसा दिखता है:
+
+```python
+from smolagents import Tool
+
+class HFModelDownloadsTool(Tool):
+ name = "model_download_counter"
+ description = """
+ This is a tool that returns the most downloaded model of a given task on the Hugging Face Hub.
+ It returns the name of the checkpoint."""
+ inputs = {
+ "task": {
+ "type": "string",
+ "description": "the task category (such as text-classification, depth-estimation, etc)",
+ }
+ }
+ output_type = "string"
+
+ def forward(self, task: str):
+ from huggingface_hub import list_models
+
+ model = next(iter(list_models(filter=task, sort="downloads", direction=-1)))
+ return model.id
+
+model_downloads_tool = HFModelDownloadsTool()
+```
+
+कस्टम टूल `Tool` को सबक्लास करता है उपयोगी मेथड्स को इनहेरिट करने के लिए। चाइल्ड क्लास भी परिभाषित करती है:
+- एक `name` एट्रिब्यूट, जो टूल के नाम से संबंधित है। नाम आमतौर पर बताता है कि टूल क्या करता है। चूंकि कोड एक टास्क के लिए सबसे अधिक डाउनलोड वाले मॉडल को रिटर्न करता है, इसलिए इसे `model_download_counter` नाम दें।
+- एक `description` एट्रिब्यूट एजेंट के सिस्टम प्रॉम्प्ट को पॉपुलेट करने के लिए उपयोग किया जाता है।
+- एक `inputs` एट्रिब्यूट, जो `"type"` और `"description"` keys वाला डिक्शनरी है। इसमें जानकारी होती है जो पायथन इंटरप्रेटर को इनपुट के बारे में शिक्षित विकल्प चुनने में मदद करती है।
+- एक `output_type` एट्रिब्यूट, जो आउटपुट टाइप को निर्दिष्ट करता है। `inputs` और `output_type` दोनों के लिए टाइप [Pydantic formats](https://docs.pydantic.dev/latest/concepts/json_schema/#generating-json-schema) होने चाहिए, वे इनमें से कोई भी हो सकते हैं: [`~AUTHORIZED_TYPES`]।
+- एक `forward` मेथड जिसमें एक्जीक्यूट किया जाने वाला इन्फरेंस कोड होता है।
+
+एजेंट में उपयोग किए जाने के लिए इतना ही चाहिए!
+
+टूल बनाने का एक और तरीका है। [guided_tour](../guided_tour) में, हमने `@tool` डेकोरेटर का उपयोग करके एक टूल को लागू किया। [`tool`] डेकोरेटर सरल टूल्स को परिभाषित करने का अनुशंसित तरीका है, लेकिन कभी-कभी आपको इससे अधिक की आवश्यकता होती है: अधिक स्पष्टता के लिए एक क्लास में कई मेथड्स का उपयोग करना, या अतिरिक्त क्लास एट्रिब्यूट्स का उपयोग करना।
+
+इस स्थिति में, आप ऊपर बताए अनुसार [`Tool`] को सबक्लास करके अपना टूल बना सकते हैं।
+
+### अपना टूल हब पर शेयर करें
+
+आप टूल पर [`~Tool.push_to_hub`] को कॉल करके अपना कस्टम टूल हब पर शेयर कर सकते हैं। सुनिश्चित करें कि आपने हब पर इसके लिए एक रिपॉजिटरी बनाई है और आप रीड एक्सेस वाला टोकन उपयोग कर रहे हैं।
+
+```python
+model_downloads_tool.push_to_hub("{your_username}/hf-model-downloads", token="
+
+फिर आप इस टूल का उपयोग किसी अन्य टूल की तरह कर सकते हैं। उदाहरण के लिए, चलिए प्रॉम्प्ट `a rabbit wearing a space suit` को सुधारें और इसकी एक इमेज जनरेट करें। यह उदाहरण यह भी दिखाता है कि आप एजेंट को अतिरिक्त आर्ग्यूमेंट्स कैसे पास कर सकते हैं।
+
+```python
+from smolagents import CodeAgent, HfApiModel
+
+model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+agent = CodeAgent(tools=[image_generation_tool], model=model)
+
+agent.run(
+ "Improve this prompt, then generate an image of it.", additional_args={'user_prompt': 'A rabbit wearing a space suit'}
+)
+```
+
+```text
+=== Agent thoughts:
+improved_prompt could be "A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background"
+
+Now that I have improved the prompt, I can use the image generator tool to generate an image based on this prompt.
+>>> Agent is executing the code below:
+image = image_generator(prompt="A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background")
+final_answer(image)
+```
+
+
+
+यह कितना कूल है? 🤩
+
+### LangChain टूल्स का उपयोग करें
+
+हम LangChain को पसंद करते हैं और मानते हैं कि इसके पास टूल्स का एक बहुत आकर्षक संग्रह है।
+LangChain से एक टूल इम्पोर्ट करने के लिए, `from_langchain()` मेथड का उपयोग करें।
+
+यहाँ बताया गया है कि आप LangChain वेब सर्च टूल का उपयोग करके परिचय के सर्च रिजल्ट को कैसे फिर से बना सकते हैं।
+इस टूल को काम करने के लिए `pip install langchain google-search-results -q` की आवश्यकता होगी।
+```python
+from langchain.agents import load_tools
+
+search_tool = Tool.from_langchain(load_tools(["serpapi"])[0])
+
+agent = CodeAgent(tools=[search_tool], model=model)
+
+agent.run("How many more blocks (also denoted as layers) are in BERT base encoder compared to the encoder from the architecture proposed in Attention is All You Need?")
+```
+
+### अपने एजेंट के टूलबॉक्स को मैनेज करें
+
+आप एजेंट के टूलबॉक्स को `agent.tools` एट्रिब्यूट में एक टूल जोड़कर या बदलकर मैनेज कर सकते हैं, क्योंकि यह एक स्टैंडर्ड डिक्शनरी है।
+
+चलिए केवल डिफ़ॉल्ट टूलबॉक्स के साथ इनिशियलाइज़ किए गए मौजूदा एजेंट में `model_download_tool` जोड़ें।
+
+```python
+from smolagents import HfApiModel
+
+model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+
+agent = CodeAgent(tools=[], model=model, add_base_tools=True)
+agent.tools[model_download_tool.name] = model_download_tool
+```
+अब हम नए टूल का लाभ उठा सकते हैं।
+
+```python
+agent.run(
+ "Can you give me the name of the model that has the most downloads in the 'text-to-video' task on the Hugging Face Hub but reverse the letters?"
+)
+```
+
+
+> [!TIP]
+> एजेंट में बहुत अधिक टूल्स न जोड़ने से सावधान रहें: यह कमजोर LLM इंजन को ओवरव्हेल्म कर सकता है।
+
+
+### टूल्स का कलेक्शन उपयोग करें
+
+आप `ToolCollection` ऑब्जेक्ट का उपयोग करके टूल कलेक्शंस का लाभ उठा सकते हैं। यह या तो हब से एक कलेक्शन या MCP सर्वर टूल्स को लोड करने का समर्थन करता है।
+
+#### हब में कलेक्शन से टूल कलेक्शन
+
+आप उस कलेक्शन के स्लग के साथ इसका लाभ उठा सकते हैं जिसका आप उपयोग करना चाहते हैं।
+फिर उन्हें अपने एजेंट को इनिशियलाइज़ करने के लिए एक लिस्ट के रूप में पास करें, और उनका उपयोग शुरू करें!
+
+```py
+from smolagents import ToolCollection, CodeAgent
+
+image_tool_collection = ToolCollection.from_hub(
+ collection_slug="huggingface-tools/diffusion-tools-6630bb19a942c2306a2cdb6f",
+ token="
+
+
+与 JSON 片段相比，用代码编写动作提供了更好的：
+
+- **可组合性：** 你能像定义 python 函数一样，将 JSON 动作嵌套在一起，或定义一组 JSON 动作以供重用吗？
+- **对象管理：** 你如何在 JSON 中存储像 `generate_image` 这样的动作的输出？
+- **通用性：** 代码被构建为简单地表达任何你可以让计算机做的事情。
+- **LLM 训练数据中的表示：** 大量高质量的代码动作已经包含在 LLM 的训练数据中，这意味着它们已经为此进行了训练！
diff --git a/docs/source/zh/conceptual_guides/react.mdx b/docs/source/zh/conceptual_guides/react.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..867157af1edf5af5104d963259317acd292a122e
--- /dev/null
+++ b/docs/source/zh/conceptual_guides/react.mdx
@@ -0,0 +1,44 @@
+
+# 多步骤 agent 是如何工作的？
+
+ReAct 框架（[Yao et al., 2022](https://huggingface.co/papers/2210.03629)）是目前构建 agent 的主要方法。
+
+该名称基于两个词的组合："Reason" （推理）和 "Act" （行动）。实际上，遵循此架构的 agent 将根据需要尽可能多的步骤来解决其任务，每个步骤包括一个推理步骤，然后是一个行动步骤，在该步骤中，它制定工具调用，使其更接近解决手头的任务。
+
+ReAct 过程涉及保留过去步骤的记忆。
+
+> [!TIP]
+> 阅读 [Open-source LLMs as LangChain Agents](https://huggingface.co/blog/open-source-llms-as-agents) 博客文章以了解更多关于多步 agent 的信息。
+
+以下是其工作原理的视频概述：
+
+
+
+
+
+这就是为什么我们强调提出代码智能体，在本例中是 Python 智能体，这意味着我们要在构建安全的 Python 解释器上投入更多精力。
+
+### 本地 Python 解释器
+
+默认情况下，`CodeAgent` 会在你的环境中运行 LLM 生成的代码。
+这个执行不是由普通的 Python 解释器完成的：我们从零开始重新构建了一个更安全的 `LocalPythonExecutor`。
+这个解释器通过以下方式设计以确保安全：
+ - 将导入限制为用户显式传递的列表
+ - 限制操作次数以防止无限循环和资源膨胀
+ - 不会执行任何未预定义的操作
+
+我们已经在许多用例中使用了这个解释器，从未观察到对环境造成任何损害。
+
+然而，这个解决方案并不是万无一失的：可以想象，如果 LLM 被微调用于恶意操作，仍然可能损害你的环境。例如，如果你允许像 `Pillow` 这样无害的包处理图像，LLM 可能会生成数千张图像保存以膨胀你的硬盘。
+如果你自己选择了 LLM 引擎，这当然不太可能，但它可能会发生。
+
+所以如果你想格外谨慎，可以使用下面描述的远程代码执行选项。
+
+### E2B 代码执行器
+
+为了最大程度的安全性，你可以使用我们与 E2B 的集成在沙盒环境中运行代码。这是一个远程执行服务，可以在隔离的容器中运行你的代码，使代码无法影响你的本地环境。
+
+为此，你需要设置你的 E2B 账户并在环境变量中设置 `E2B_API_KEY`。请前往 [E2B 快速入门文档](https://e2b.dev/docs/quickstart) 了解更多信息。
+
+然后你可以通过 `pip install e2b-code-interpreter python-dotenv` 安装它。
+
+现在你已经准备好了！
+
+要将代码执行器设置为 E2B，只需在初始化 `CodeAgent` 时传递标志 `executor_type="e2b"`。
+请注意，你应该将所有工具的依赖项添加到 `additional_authorized_imports` 中，以便执行器安装它们。
+
+```py
+from smolagents import CodeAgent, VisitWebpageTool, HfApiModel
+agent = CodeAgent(
+ tools = [VisitWebpageTool()],
+ model=HfApiModel(),
+ additional_authorized_imports=["requests", "markdownify"],
+ executor_type="e2b"
+)
+
+agent.run("What was Abraham Lincoln's preferred pet?")
+```
+
+目前 E2B 代码执行暂不兼容多 agent——因为把 agent 调用放在应该在远程执行的代码块里，是非常混乱的。但我们正在努力做到这件事！
diff --git a/docs/source/zh/tutorials/tools.mdx b/docs/source/zh/tutorials/tools.mdx
new file mode 100644
index 0000000000000000000000000000000000000000..2d66a22dbe140cd1d54f021de718f383784980e3
--- /dev/null
+++ b/docs/source/zh/tutorials/tools.mdx
@@ -0,0 +1,221 @@
+
+# 工具
+
+[[open-in-colab]]
+
+在这里，我们将学习高级工具的使用。
+
+> [!TIP]
+> 如果你是构建 agent 的新手，请确保先阅读 [agent 介绍](../conceptual_guides/intro_agents) 和 [smolagents 导览](../guided_tour)。
+
+- [工具](#工具)
+ - [什么是工具，如何构建一个工具？](#什么是工具如何构建一个工具)
+ - [将你的工具分享到 Hub](#将你的工具分享到-hub)
+ - [将 Space 导入为工具](#将-space-导入为工具)
+ - [使用 LangChain 工具](#使用-langchain-工具)
+ - [管理你的 agent 工具箱](#管理你的-agent-工具箱)
+ - [使用工具集合](#使用工具集合)
+
+### 什么是工具，如何构建一个工具？
+
+工具主要是 LLM 可以在 agent 系统中使用的函数。
+
+但要使用它，LLM 需要被提供一个 API：名称、工具描述、输入类型和描述、输出类型。
+
+所以它不能仅仅是一个函数。它应该是一个类。
+
+因此，核心上，工具是一个类，它包装了一个函数，并带有帮助 LLM 理解如何使用它的元数据。
+
+以下是它的结构：
+
+```python
+from smolagents import Tool
+
+class HFModelDownloadsTool(Tool):
+ name = "model_download_counter"
+ description = """
+ This is a tool that returns the most downloaded model of a given task on the Hugging Face Hub.
+ It returns the name of the checkpoint."""
+ inputs = {
+ "task": {
+ "type": "string",
+ "description": "the task category (such as text-classification, depth-estimation, etc)",
+ }
+ }
+ output_type = "string"
+
+ def forward(self, task: str):
+ from huggingface_hub import list_models
+
+ model = next(iter(list_models(filter=task, sort="downloads", direction=-1)))
+ return model.id
+
+model_downloads_tool = HFModelDownloadsTool()
+```
+
+自定义工具继承 [`Tool`] 以继承有用的方法。子类还定义了：
+- 一个属性 `name`，对应于工具本身的名称。名称通常描述工具的功能。由于代码返回任务中下载量最多的模型，我们将其命名为 `model_download_counter`。
+- 一个属性 `description`，用于填充 agent 的系统提示。
+- 一个 `inputs` 属性，它是一个带有键 `"type"` 和 `"description"` 的字典。它包含帮助 Python 解释器对输入做出明智选择的信息。
+- 一个 `output_type` 属性，指定输出类型。`inputs` 和 `output_type` 的类型应为 [Pydantic 格式](https://docs.pydantic.dev/latest/concepts/json_schema/#generating-json-schema)，它们可以是以下之一：[`~AUTHORIZED_TYPES`]。
+- 一个 `forward` 方法，包含要执行的推理代码。
+
+这就是它在 agent 中使用所需的全部内容！
+
+还有另一种构建工具的方法。在 [guided_tour](../guided_tour) 中，我们使用 `@tool` 装饰器实现了一个工具。[`tool`] 装饰器是定义简单工具的推荐方式，但有时你需要更多：在类中使用多个方法以获得更清晰的代码，或使用额外的类属性。
+
+在这种情况下，你可以通过如上所述继承 [`Tool`] 来构建你的工具。
+
+### 将你的工具分享到 Hub
+
+你可以通过调用 [`~Tool.push_to_hub`] 将你的自定义工具分享到 Hub。确保你已经在 Hub 上为其创建了一个仓库，并且使用的是具有读取权限的 token。
+
+```python
+model_downloads_tool.push_to_hub("{your_username}/hf-model-downloads", token="
+
+然后你可以像使用任何其他工具一样使用这个工具。例如，让我们改进提示 `A rabbit wearing a space suit` 并生成它的图片。
+
+```python
+from smolagents import CodeAgent, HfApiModel
+
+model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+agent = CodeAgent(tools=[image_generation_tool], model=model)
+
+agent.run(
+ "Improve this prompt, then generate an image of it.", additional_args={'user_prompt': 'A rabbit wearing a space suit'}
+)
+```
+
+```text
+=== Agent thoughts:
+improved_prompt could be "A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background"
+
+Now that I have improved the prompt, I can use the image generator tool to generate an image based on this prompt.
+>>> Agent is executing the code below:
+image = image_generator(prompt="A bright blue space suit wearing rabbit, on the surface of the moon, under a bright orange sunset, with the Earth visible in the background")
+final_answer(image)
+```
+
+
+
+这得有多酷？🤩
+
+### 使用 LangChain 工具
+
+我们喜欢 Langchain，并认为它有一套非常吸引人的工具。
+要从 LangChain 导入工具，请使用 `from_langchain()` 方法。
+
+以下是如何使用它来重现介绍中的搜索结果，使用 LangChain 的 web 搜索工具。
+这个工具需要 `pip install langchain google-search-results -q` 才能正常工作。
+```python
+from langchain.agents import load_tools
+
+search_tool = Tool.from_langchain(load_tools(["serpapi"])[0])
+
+agent = CodeAgent(tools=[search_tool], model=model)
+
+agent.run("How many more blocks (also denoted as layers) are in BERT base encoder compared to the encoder from the architecture proposed in Attention is All You Need?")
+```
+
+### 管理你的 agent 工具箱
+
+你可以通过添加或替换工具来管理 agent 的工具箱。
+
+让我们将 `model_download_tool` 添加到一个仅使用默认工具箱初始化的现有 agent 中。
+
+```python
+from smolagents import HfApiModel
+
+model = HfApiModel("Qwen/Qwen2.5-Coder-32B-Instruct")
+
+agent = CodeAgent(tools=[], model=model, add_base_tools=True)
+agent.tools[model_download_tool.name] = model_download_tool
+```
+现在我们可以利用新工具：
+
+```python
+agent.run(
+ "Can you give me the name of the model that has the most downloads in the 'text-to-video' task on the Hugging Face Hub but reverse the letters?"
+)
+```
+
+
+> [!TIP]
+> 注意不要向 agent 添加太多工具：这可能会让较弱的 LLM 引擎不堪重负。
+
+
+### 使用工具集合
+
+你可以通过使用 ToolCollection 对象来利用工具集合，使用你想要使用的集合的 slug。
+然后将它们作为列表传递给 agent 初始化，并开始使用它们！
+
+```py
+from smolagents import ToolCollection, CodeAgent
+
+image_tool_collection = ToolCollection.from_hub(
+ collection_slug="huggingface-tools/diffusion-tools-6630bb19a942c2306a2cdb6f",
+ token="| \n", + " | question | \n", + "source | \n", + "true_answer | \n", + "true_reasoning | \n", + "
|---|---|---|---|---|
| 0 | \n", + "What year was the municipality of Ramiriquí, B... | \n", + "SimpleQA | \n", + "1541 | \n", + "['https://en.wikipedia.org/wiki/Ramiriqu%C3%AD... | \n", + "
| 1 | \n", + "In what year did Hjalmar Hvam invent a mechani... | \n", + "SimpleQA | \n", + "1937 | \n", + "['https://www.kgw.com/article/features/portlan... | \n", + "
| 2 | \n", + "In which year did Fayaz A. Malik (an Indian ph... | \n", + "SimpleQA | \n", + "2009 | \n", + "['https://en.wikipedia.org/wiki/Fayaz_A._Malik... | \n", + "
| 3 | \n", + "In which year was John B. Goodenough elected a... | \n", + "SimpleQA | \n", + "2010 | \n", + "['https://en.wikipedia.org/wiki/John_B._Gooden... | \n", + "
| 4 | \n", + "In which year did Atul Gawande earn an M.A. in... | \n", + "SimpleQA | \n", + "1989 | \n", + "['https://en.wikipedia.org/wiki/Atul_Gawande',... | \n", + "
| \n", + " | model_id | \n", + "agent_action_type | \n", + "source | \n", + "acc | \n", + "
|---|---|---|---|---|
| 0 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "code | \n", + "GAIA | \n", + "28.12 | \n", + "
| 1 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "code | \n", + "MATH | \n", + "76.00 | \n", + "
| 2 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "code | \n", + "SimpleQA | \n", + "88.00 | \n", + "
| 3 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "vanilla | \n", + "GAIA | \n", + "6.25 | \n", + "
| 4 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "vanilla | \n", + "MATH | \n", + "30.00 | \n", + "
| action_type | \n", + "model_id | \n", + "source | \n", + "code | \n", + "vanilla | \n", + "
|---|---|---|---|---|
| 0 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "GAIA | \n", + "28.1 | \n", + "6.2 | \n", + "
| 1 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "MATH | \n", + "76.0 | \n", + "30.0 | \n", + "
| 2 | \n", + "Qwen/Qwen2.5-72B-Instruct | \n", + "SimpleQA | \n", + "88.0 | \n", + "10.0 | \n", + "
| 3 | \n", + "Qwen/Qwen2.5-Coder-32B-Instruct | \n", + "GAIA | \n", + "25.0 | \n", + "3.1 | \n", + "
| 4 | \n", + "Qwen/Qwen2.5-Coder-32B-Instruct | \n", + "MATH | \n", + "86.0 | \n", + "60.0 | \n", + "
| 5 | \n", + "Qwen/Qwen2.5-Coder-32B-Instruct | \n", + "SimpleQA | \n", + "86.0 | \n", + "8.0 | \n", + "
| 6 | \n", + "anthropic/claude-3-5-sonnet-latest | \n", + "GAIA | \n", + "NaN | \n", + "3.1 | \n", + "
| 7 | \n", + "anthropic/claude-3-5-sonnet-latest | \n", + "MATH | \n", + "NaN | \n", + "50.0 | \n", + "
| 8 | \n", + "anthropic/claude-3-5-sonnet-latest | \n", + "SimpleQA | \n", + "NaN | \n", + "34.0 | \n", + "
| 9 | \n", + "gpt-4o | \n", + "GAIA | \n", + "25.6 | \n", + "3.1 | \n", + "
| 10 | \n", + "gpt-4o | \n", + "MATH | \n", + "58.0 | \n", + "40.0 | \n", + "
| 11 | \n", + "gpt-4o | \n", + "SimpleQA | \n", + "86.0 | \n", + "6.0 | \n", + "
| 12 | \n", + "meta-llama/Llama-3.1-8B-Instruct | \n", + "GAIA | \n", + "3.1 | \n", + "0.0 | \n", + "
| 13 | \n", + "meta-llama/Llama-3.1-8B-Instruct | \n", + "MATH | \n", + "14.0 | \n", + "18.0 | \n", + "
| 14 | \n", + "meta-llama/Llama-3.1-8B-Instruct | \n", + "SimpleQA | \n", + "2.0 | \n", + "6.0 | \n", + "
| 15 | \n", + "meta-llama/Llama-3.2-3B-Instruct | \n", + "GAIA | \n", + "3.1 | \n", + "0.0 | \n", + "
| 16 | \n", + "meta-llama/Llama-3.2-3B-Instruct | \n", + "MATH | \n", + "40.0 | \n", + "12.0 | \n", + "
| 17 | \n", + "meta-llama/Llama-3.2-3B-Instruct | \n", + "SimpleQA | \n", + "20.0 | \n", + "0.0 | \n", + "
| 18 | \n", + "meta-llama/Llama-3.3-70B-Instruct | \n", + "GAIA | \n", + "31.2 | \n", + "3.1 | \n", + "
| 19 | \n", + "meta-llama/Llama-3.3-70B-Instruct | \n", + "MATH | \n", + "72.0 | \n", + "40.0 | \n", + "
| 20 | \n", + "meta-llama/Llama-3.3-70B-Instruct | \n", + "SimpleQA | \n", + "78.0 | \n", + "12.0 | \n", + "
| 21 | \n", + "mistralai/Mistral-Nemo-Instruct-2407 | \n", + "GAIA | \n", + "0.0 | \n", + "3.1 | \n", + "
| 22 | \n", + "mistralai/Mistral-Nemo-Instruct-2407 | \n", + "MATH | \n", + "30.0 | \n", + "22.0 | \n", + "
| 23 | \n", + "mistralai/Mistral-Nemo-Instruct-2407 | \n", + "SimpleQA | \n", + "30.0 | \n", + "6.0 | \n", + "
| \n", + " | is_correct | \n", + "
|---|---|
| agent_name | \n", + "\n", + " |
| code_gpt4o_03_february_goodoldtext-unbroken | \n", + "0.384 | \n", + "
| code_gpt4o_03_february_magenticbrowser | \n", + "0.352 | \n", + "
| code_gpt4o_03_february_magenticbrowser2 | \n", + "0.365 | \n", + "
| code_gpt4o_03_february_text | \n", + "0.376 | \n", + "
| code_llama-3 | \n", + "0.078 | \n", + "
| code_o1_01_february_text | \n", + "0.491 | \n", + "
| code_o1_03_february_ablation-toolcalling-manager | \n", + "0.327 | \n", + "
| code_o1_03_february_fix-print-outputs | \n", + "0.518 | \n", + "
| code_o1_03_february_fix-print-outputs2 | \n", + "0.558 | \n", + "
| code_o1_03_february_goodoldtext-unbroken | \n", + "0.534 | \n", + "
| code_o1_03_february_remove-navigational | \n", + "0.537 | \n", + "
| code_o1_03_february_text_high-reasoning-effort | \n", + "0.485 | \n", + "
| code_o1_04_february_submission | \n", + "0.494 | \n", + "
| code_o1_04_february_submission-medium | \n", + "0.488 | \n", + "
| code_o1_04_february_submission3 | \n", + "0.490 | \n", + "
| code_o1_04_february_submission4 | \n", + "0.500 | \n", + "
| code_o1_04_february_submission5 | \n", + "0.552 | \n", + "
| code_o1_22-01_managedagent-summary_planning | \n", + "0.418 | \n", + "
| code_o1_25-01_visioon | \n", + "0.340 | \n", + "
| code_o1_29-01_text | \n", + "0.390 | \n", + "
| code_o3-mini_03_february_remove-navigational | \n", + "0.291 | \n", + "
| code_qwen-coder-32B_03_february_text | \n", + "0.209 | \n", + "
| \n", + " | \n", + " | is_correct | \n", + "is_near_correct | \n", + "count_steps | \n", + "count | \n", + "
|---|---|---|---|---|---|
| agent_name | \n", + "task | \n", + "\n", + " | \n", + " | \n", + " | \n", + " |
| code_gpt4o_03_february_goodoldtext-unbroken | \n", + "1 | \n", + "0.452830 | \n", + "0.452830 | \n", + "7.000000 | \n", + "53 | \n", + "
| 2 | \n", + "0.380952 | \n", + "0.392857 | \n", + "8.511905 | \n", + "84 | \n", + "|
| 3 | \n", + "0.227273 | \n", + "0.227273 | \n", + "10.409091 | \n", + "22 | \n", + "|
| code_gpt4o_03_february_magenticbrowser | \n", + "1 | \n", + "0.480769 | \n", + "0.480769 | \n", + "7.153846 | \n", + "52 | \n", + "
| 2 | \n", + "0.349398 | \n", + "0.361446 | \n", + "8.168675 | \n", + "83 | \n", + "|
| ... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "... | \n", + "
| code_o3-mini_03_february_remove-navigational | \n", + "2 | \n", + "0.232558 | \n", + "0.244186 | \n", + "4.976744 | \n", + "86 | \n", + "
| 3 | \n", + "0.153846 | \n", + "0.153846 | \n", + "6.615385 | \n", + "26 | \n", + "|
| code_qwen-coder-32B_03_february_text | \n", + "1 | \n", + "0.357143 | \n", + "0.357143 | \n", + "5.428571 | \n", + "14 | \n", + "
| 2 | \n", + "0.136364 | \n", + "0.136364 | \n", + "6.409091 | \n", + "22 | \n", + "|
| 3 | \n", + "0.142857 | \n", + "0.142857 | \n", + "6.571429 | \n", + "7 | \n", + "
65 rows × 4 columns
\n", + "| \n", + " | is_correct | \n", + "count_steps | \n", + "question | \n", + "
|---|---|---|---|
| attachment_type | \n", + "\n", + " | \n", + " | \n", + " |
| None | \n", + "0.423799 | \n", + "4.959725 | \n", + "2185 | \n", + "
| csv | \n", + "0.000000 | \n", + "7.750000 | \n", + "16 | \n", + "
| docx | \n", + "0.571429 | \n", + "4.904762 | \n", + "21 | \n", + "
| jpg | \n", + "0.142857 | \n", + "5.750000 | \n", + "28 | \n", + "
| jsonld | \n", + "0.000000 | \n", + "6.600000 | \n", + "15 | \n", + "
| mp3 | \n", + "0.480000 | \n", + "4.500000 | \n", + "50 | \n", + "
| pdb | \n", + "0.000000 | \n", + "4.444444 | \n", + "18 | \n", + "
| 0.588235 | \n", + "4.137255 | \n", + "51 | \n", + "|
| png | \n", + "0.216783 | \n", + "4.412587 | \n", + "143 | \n", + "
| pptx | \n", + "0.882353 | \n", + "4.058824 | \n", + "17 | \n", + "
| py | \n", + "1.000000 | \n", + "4.266667 | \n", + "15 | \n", + "
| txt | \n", + "0.705882 | \n", + "4.764706 | \n", + "17 | \n", + "
| xlsx | \n", + "0.612745 | \n", + "4.823529 | \n", + "204 | \n", + "
| zip | \n", + "0.448276 | \n", + "5.344828 | \n", + "29 | \n", + "
The idea of building a tool using reasoning large language models +(LLMs) to evaluate the quality of startup AI ideas and help improve them +is a promising innovation in the AI startup ecosystem. This report +evaluates the novelty of this idea across three key dimensions: Problem +Uniqueness, Existing Solutions, and Differentiation. The findings +suggest that the idea addresses an unmet need, has limited direct +competition, and offers significant differentiation through technical +and business model innovations. However, some challenges and limitations +must be addressed to fully realize its potential.
+The proposed idea addresses a significant unmet need in the AI +startup ecosystem. Current methods for evaluating startup AI ideas rely +heavily on financial metrics, traditional idea validation techniques, +and manual processes, which are often time-consuming, biased, and +ill-suited for the complexity of AI-driven ideas (Finro +Financial Consulting, 2023; Traction +Technology, 2023).
+While there are tools and platforms that evaluate startup ideas, none +specifically leverage reasoning LLMs for this purpose. Existing +solutions focus on competitor analysis, financial metrics, and +traditional idea validation techniques.
+The lack of direct competition in the reasoning LLM space for startup +evaluation highlights the novelty of the proposed idea.
+The proposed idea differentiates itself through technical innovation, +business model innovation, market segment targeting, and user experience +improvements.
+The proposed idea of using reasoning LLMs to evaluate startup AI +ideas is highly novel, with a Novelty Score of 85/100. It addresses an +unmet need, has limited direct competition, and offers significant +differentiation through technical and business model innovations. +However, challenges such as data quality, model interpretability, and +ethical considerations must be addressed to ensure its success. With +further development and refinement, this idea has the potential to +revolutionize the way AI startup ideas are evaluated and improved.
+This report provides a comprehensive evaluation of the novelty of the +proposed idea, supported by detailed research and analysis.
+The idea of building a tool using reasoning large language models +(LLMs) to evaluate the quality of startup AI ideas and help improve them +is a promising innovation in the AI startup ecosystem. This report +evaluates the novelty of this idea across three key dimensions: Problem +Uniqueness, Existing Solutions, and Differentiation. The findings +suggest that the idea addresses an unmet need, has limited direct +competition, and offers significant differentiation through technical +and business model innovations. However, some challenges and limitations +must be addressed to fully realize its potential.
+The proposed idea addresses a significant unmet need in the AI +startup ecosystem. Current methods for evaluating startup AI ideas rely +heavily on financial metrics, traditional idea validation techniques, +and manual processes, which are often time-consuming, biased, and +ill-suited for the complexity of AI-driven ideas (Finro +Financial Consulting, 2023; Traction +Technology, 2023).
+While there are tools and platforms that evaluate startup ideas, none +specifically leverage reasoning LLMs for this purpose. Existing +solutions focus on competitor analysis, financial metrics, and +traditional idea validation techniques.
+The lack of direct competition in the reasoning LLM space for startup +evaluation highlights the novelty of the proposed idea.
+The proposed idea differentiates itself through technical innovation, +business model innovation, market segment targeting, and user experience +improvements.
+The proposed idea of using reasoning LLMs to evaluate startup AI +ideas is highly novel, with a Novelty Score of 85/100. It addresses an +unmet need, has limited direct competition, and offers significant +differentiation through technical and business model innovations. +However, challenges such as data quality, model interpretability, and +ethical considerations must be addressed to ensure its success. With +further development and refinement, this idea has the potential to +revolutionize the way AI startup ideas are evaluated and improved.
+This report provides a comprehensive evaluation of the novelty of the +proposed idea, supported by detailed research and analysis.
+| " + html.escape(cell.text) + " | " + else: + html_table += "" + html.escape(cell.text) + " | " + html_table += "
|---|
+
+
+
+
+
+
+ A smol library to build great agents!
+
+
+
+ MoonshotAI
+ 
+ huggingface/smolagents
+