Upload 9 files

examples/agent_from_any_llm.py

@@ -0,0 +1,61 @@
+from smolagents import (
+    CodeAgent,
+    InferenceClientModel,
+    LiteLLMModel,
+    OpenAIServerModel,
+    ToolCallingAgent,
+    TransformersModel,
+    tool,
+)
+
+
+# Choose which inference type to use!
+
+available_inferences = ["inference_client", "transformers", "ollama", "litellm", "openai"]
+chosen_inference = "inference_client"
+
+print(f"Chose model: '{chosen_inference}'")
+
+if chosen_inference == "inference_client":
+    model = InferenceClientModel(model_id="meta-llama/Llama-3.3-70B-Instruct", provider="nebius")
+
+elif chosen_inference == "transformers":
+    model = TransformersModel(model_id="HuggingFaceTB/SmolLM2-1.7B-Instruct", device_map="auto", max_new_tokens=1000)
+
+elif chosen_inference == "ollama":
+    model = LiteLLMModel(
+        model_id="ollama_chat/llama3.2",
+        api_base="http://localhost:11434",  # replace with remote open-ai compatible server if necessary
+        api_key="your-api-key",  # replace with API key if necessary
+        num_ctx=8192,  # ollama default is 2048 which will often fail horribly. 8192 works for easy tasks, more is better. Check https://huggingface.co/spaces/NyxKrage/LLM-Model-VRAM-Calculator to calculate how much VRAM this will need for the selected model.
+    )
+
+elif chosen_inference == "litellm":
+    # For anthropic: change model_id below to 'anthropic/claude-3-5-sonnet-latest'
+    model = LiteLLMModel(model_id="gpt-4o")
+
+elif chosen_inference == "openai":
+    # For anthropic: change model_id below to 'anthropic/claude-3-5-sonnet-latest'
+    model = OpenAIServerModel(model_id="gpt-4o")
+
+
+@tool
+def get_weather(location: str, celsius: bool | None = False) -> str:
+    """
+    Get weather in the next days at given location.
+    Secretly this tool does not care about the location, it hates the weather everywhere.
+
+    Args:
+        location: the location
+        celsius: the temperature
+    """
+    return "The weather is UNGODLY with torrential rains and temperatures below -10°C"
+
+
+agent = ToolCallingAgent(tools=[get_weather], model=model, verbosity_level=2)
+
+print("ToolCallingAgent:", agent.run("What's the weather like in Paris?"))
+
+agent = CodeAgent(tools=[get_weather], model=model, verbosity_level=2, stream_outputs=True)
+
+print("CodeAgent:", agent.run("What's the weather like in Paris?"))

examples/gradio_ui.py

@@ -0,0 +1,16 @@
+from smolagents import CodeAgent, GradioUI, InferenceClientModel, WebSearchTool
+
+
+agent = CodeAgent(
+    tools=[WebSearchTool()],
+    model=InferenceClientModel(model_id="meta-llama/Llama-3.3-70B-Instruct", provider="fireworks-ai"),
+    verbosity_level=1,
+    planning_interval=3,
+    name="example_agent",
+    description="This is an example agent.",
+    step_callbacks=[],
+    stream_outputs=True,
+    # use_structured_outputs_internally=True,
+)
+
+GradioUI(agent, file_upload_folder="./data").launch()

examples/inspect_multiagent_run.py

@@ -0,0 +1,39 @@
+from openinference.instrumentation.smolagents import SmolagentsInstrumentor
+from phoenix.otel import register
+
+
+register()
+SmolagentsInstrumentor().instrument(skip_dep_check=True)
+
+
+from smolagents import (
+    CodeAgent,
+    InferenceClientModel,
+    ToolCallingAgent,
+    VisitWebpageTool,
+    WebSearchTool,
+)
+
+
+# Then we run the agentic part!
+model = InferenceClientModel(provider="nebius")
+
+search_agent = ToolCallingAgent(
+    tools=[WebSearchTool(), VisitWebpageTool()],
+    model=model,
+    name="search_agent",
+    description="This is an agent that can do web search.",
+    return_full_result=True,
+)
+
+manager_agent = CodeAgent(
+    tools=[],
+    model=model,
+    managed_agents=[search_agent],
+    return_full_result=True,
+)
+run_result = manager_agent.run(
+    "If the US keeps it 2024 growth rate, how many years would it take for the GDP to double?"
+)
+print("Here is the token usage for the manager agent", run_result.token_usage)
+print("Here are the timing informations for the manager agent:", run_result.timing)

examples/multi_llm_agent.py

@@ -0,0 +1,46 @@
+import os
+
+from smolagents import CodeAgent, LiteLLMRouterModel, WebSearchTool
+
+
+# Make sure to setup the necessary environment variables!
+
+llm_loadbalancer_model_list = [
+    {
+        "model_name": "model-group-1",
+        "litellm_params": {
+            "model": "gpt-4o-mini",
+            "api_key": os.getenv("OPENAI_API_KEY"),
+        },
+    },
+    {
+        "model_name": "model-group-1",
+        "litellm_params": {
+            "model": "bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
+            "aws_access_key_id": os.getenv("AWS_ACCESS_KEY_ID"),
+            "aws_secret_access_key": os.getenv("AWS_SECRET_ACCESS_KEY"),
+            "aws_region_name": os.getenv("AWS_REGION"),
+        },
+    },
+    # {
+    #     "model_name": "model-group-2",
+    #     "litellm_params": {
+    #         "model": "bedrock/anthropic.claude-3-sonnet-20240229-v1:0",
+    #         "aws_access_key_id": os.getenv("AWS_ACCESS_KEY_ID"),
+    #         "aws_secret_access_key": os.getenv("AWS_SECRET_ACCESS_KEY"),
+    #         "aws_region_name": os.getenv("AWS_REGION"),
+    #     },
+    # },
+]
+
+
+model = LiteLLMRouterModel(
+    model_id="model-group-1",
+    model_list=llm_loadbalancer_model_list,
+    client_kwargs={"routing_strategy": "simple-shuffle"},
+)
+agent = CodeAgent(tools=[WebSearchTool()], model=model, stream_outputs=True, return_full_result=True)
+
+full_result = agent.run("How many seconds would it take for a leopard at full speed to run through Pont des Arts?")
+
+print(full_result)

examples/multiple_tools.py

@@ -0,0 +1,256 @@
+import requests
+
+# from smolagents.agents import ToolCallingAgent
+from smolagents import CodeAgent, InferenceClientModel, tool
+
+
+# Choose which LLM engine to use!
+model = InferenceClientModel()
+# model = TransformersModel(model_id="meta-llama/Llama-3.2-2B-Instruct")
+
+# For anthropic: change model_id below to 'anthropic/claude-3-5-sonnet-20240620'
+# model = LiteLLMModel(model_id="gpt-4o")
+
+
+@tool
+def get_weather(location: str, celsius: bool | None = False) -> str:
+    """
+    Get the current weather at the given location using the WeatherStack API.
+
+    Args:
+        location: The location (city name).
+        celsius: Whether to return the temperature in Celsius (default is False, which returns Fahrenheit).
+
+    Returns:
+        A string describing the current weather at the location.
+    """
+    api_key = "your_api_key"  # Replace with your API key from https://weatherstack.com/
+    units = "m" if celsius else "f"  # 'm' for Celsius, 'f' for Fahrenheit
+
+    url = f"http://api.weatherstack.com/current?access_key={api_key}&query={location}&units={units}"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()  # Raise an exception for HTTP errors
+
+        data = response.json()
+
+        if data.get("error"):  # Check if there's an error in the response
+            return f"Error: {data['error'].get('info', 'Unable to fetch weather data.')}"
+
+        weather = data["current"]["weather_descriptions"][0]
+        temp = data["current"]["temperature"]
+        temp_unit = "°C" if celsius else "°F"
+
+        return f"The current weather in {location} is {weather} with a temperature of {temp} {temp_unit}."
+
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching weather data: {str(e)}"
+
+
+@tool
+def convert_currency(amount: float, from_currency: str, to_currency: str) -> str:
+    """
+    Converts a specified amount from one currency to another using the ExchangeRate-API.
+
+    Args:
+        amount: The amount of money to convert.
+        from_currency: The currency code of the currency to convert from (e.g., 'USD').
+        to_currency: The currency code of the currency to convert to (e.g., 'EUR').
+
+    Returns:
+        str: A string describing the converted amount in the target currency, or an error message if the conversion fails.
+
+    Raises:
+        requests.exceptions.RequestException: If there is an issue with the HTTP request to the ExchangeRate-API.
+    """
+    api_key = "your_api_key"  # Replace with your actual API key from https://www.exchangerate-api.com/
+    url = f"https://v6.exchangerate-api.com/v6/{api_key}/latest/{from_currency}"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+        exchange_rate = data["conversion_rates"].get(to_currency)
+
+        if not exchange_rate:
+            return f"Error: Unable to find exchange rate for {from_currency} to {to_currency}."
+
+        converted_amount = amount * exchange_rate
+        return f"{amount} {from_currency} is equal to {converted_amount} {to_currency}."
+
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching conversion data: {str(e)}"
+
+
+@tool
+def get_news_headlines() -> str:
+    """
+    Fetches the top news headlines from the News API for the United States.
+    This function makes a GET request to the News API to retrieve the top news headlines
+    for the United States. It returns the titles and sources of the top 5 articles as a
+    formatted string. If no articles are available, it returns a message indicating that
+    no news is available. In case of a request error, it returns an error message.
+    Returns:
+        str: A string containing the top 5 news headlines and their sources, or an error message.
+    """
+    api_key = "your_api_key"  # Replace with your actual API key from https://newsapi.org/
+    url = f"https://newsapi.org/v2/top-headlines?country=us&apiKey={api_key}"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+        articles = data["articles"]
+
+        if not articles:
+            return "No news available at the moment."
+
+        headlines = [f"{article['title']} - {article['source']['name']}" for article in articles[:5]]
+        return "\n".join(headlines)
+
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching news data: {str(e)}"
+
+
+@tool
+def get_joke() -> str:
+    """
+    Fetches a random joke from the JokeAPI.
+    This function sends a GET request to the JokeAPI to retrieve a random joke.
+    It handles both single jokes and two-part jokes (setup and delivery).
+    If the request fails or the response does not contain a joke, an error message is returned.
+    Returns:
+        str: The joke as a string, or an error message if the joke could not be fetched.
+    """
+    url = "https://v2.jokeapi.dev/joke/Any?type=single"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+
+        if "joke" in data:
+            return data["joke"]
+        elif "setup" in data and "delivery" in data:
+            return f"{data['setup']} - {data['delivery']}"
+        else:
+            return "Error: Unable to fetch joke."
+
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching joke: {str(e)}"
+
+
+@tool
+def get_time_in_timezone(location: str) -> str:
+    """
+    Fetches the current time for a given location using the World Time API.
+    Args:
+        location: The location for which to fetch the current time, formatted as 'Region/City'.
+    Returns:
+        str: A string indicating the current time in the specified location, or an error message if the request fails.
+    Raises:
+        requests.exceptions.RequestException: If there is an issue with the HTTP request.
+    """
+    url = f"http://worldtimeapi.org/api/timezone/{location}.json"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+        current_time = data["datetime"]
+
+        return f"The current time in {location} is {current_time}."
+
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching time data: {str(e)}"
+
+
+@tool
+def get_random_fact() -> str:
+    """
+    Fetches a random fact from the "uselessfacts.jsph.pl" API.
+    Returns:
+        str: A string containing the random fact or an error message if the request fails.
+    """
+    url = "https://uselessfacts.jsph.pl/random.json?language=en"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+
+        return f"Random Fact: {data['text']}"
+
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching random fact: {str(e)}"
+
+
+@tool
+def search_wikipedia(query: str) -> str:
+    """
+    Fetches a summary of a Wikipedia page for a given query.
+    Args:
+        query: The search term to look up on Wikipedia.
+    Returns:
+        str: A summary of the Wikipedia page if successful, or an error message if the request fails.
+    Raises:
+        requests.exceptions.RequestException: If there is an issue with the HTTP request.
+    """
+    url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{query}"
+
+    try:
+        response = requests.get(url)
+        response.raise_for_status()
+
+        data = response.json()
+        title = data["title"]
+        extract = data["extract"]
+
+        return f"Summary for {title}: {extract}"
+
+    except requests.exceptions.RequestException as e:
+        return f"Error fetching Wikipedia data: {str(e)}"
+
+
+# If you want to use the ToolCallingAgent instead, uncomment the following lines as they both will work
+
+# agent = ToolCallingAgent(
+#     tools=[
+#         convert_currency,
+#         get_weather,
+#         get_news_headlines,
+#         get_joke,
+#         get_random_fact,
+#         search_wikipedia,
+#     ],
+#     model=model,
+# )
+
+
+agent = CodeAgent(
+    tools=[
+        convert_currency,
+        get_weather,
+        get_news_headlines,
+        get_joke,
+        get_random_fact,
+        search_wikipedia,
+    ],
+    model=model,
+    stream_outputs=True,
+)
+
+# Uncomment the line below to run the agent with a specific query
+
+agent.run("Convert 5000 dollars to Euros")
+# agent.run("What is the weather in New York?")
+# agent.run("Give me the top news headlines")
+# agent.run("Tell me a joke")
+# agent.run("Tell me a Random Fact")
+# agent.run("who is Elon Musk?")

examples/rag.py

@@ -0,0 +1,70 @@
+# from huggingface_hub import login
+
+# login()
+import datasets
+from langchain.docstore.document import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.retrievers import BM25Retriever
+
+
+knowledge_base = datasets.load_dataset("m-ric/huggingface_doc", split="train")
+knowledge_base = knowledge_base.filter(lambda row: row["source"].startswith("huggingface/transformers"))
+
+source_docs = [
+    Document(page_content=doc["text"], metadata={"source": doc["source"].split("/")[1]}) for doc in knowledge_base
+]
+
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=500,
+    chunk_overlap=50,
+    add_start_index=True,
+    strip_whitespace=True,
+    separators=["\n\n", "\n", ".", " ", ""],
+)
+docs_processed = text_splitter.split_documents(source_docs)
+
+from smolagents import Tool
+
+
+class RetrieverTool(Tool):
+    name = "retriever"
+    description = "Uses lexical search to retrieve the parts of transformers documentation that could be most relevant to answer your query."
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The query to perform. This should be lexically close to your target documents. Use the affirmative form rather than a question.",
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, docs, **kwargs):
+        super().__init__(**kwargs)
+        self.retriever = BM25Retriever.from_documents(docs, k=10)
+
+    def forward(self, query: str) -> str:
+        assert isinstance(query, str), "Your search query must be a string"
+
+        docs = self.retriever.invoke(
+            query,
+        )
+        return "\nRetrieved documents:\n" + "".join(
+            [f"\n\n===== Document {str(i)} =====\n" + doc.page_content for i, doc in enumerate(docs)]
+        )
+
+
+from smolagents import CodeAgent, InferenceClientModel
+
+
+retriever_tool = RetrieverTool(docs_processed)
+agent = CodeAgent(
+    tools=[retriever_tool],
+    model=InferenceClientModel(model_id="Qwen/Qwen2.5-Coder-32B-Instruct"),
+    max_steps=4,
+    verbosity_level=2,
+    stream_outputs=True,
+)
+
+agent_output = agent.run("For a transformers model training, which is slower, the forward or the backward pass?")
+
+print("Final output:")
+print(agent_output)

examples/rag_using_chromadb.py

@@ -0,0 +1,130 @@
+import os
+
+import datasets
+from langchain.docstore.document import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_chroma import Chroma
+
+# from langchain_community.document_loaders import PyPDFLoader
+from langchain_huggingface import HuggingFaceEmbeddings
+from tqdm import tqdm
+from transformers import AutoTokenizer
+
+# from langchain_openai import OpenAIEmbeddings
+from smolagents import LiteLLMModel, Tool
+from smolagents.agents import CodeAgent
+
+
+# from smolagents.agents import ToolCallingAgent
+
+
+knowledge_base = datasets.load_dataset("m-ric/huggingface_doc", split="train")
+
+source_docs = [
+    Document(page_content=doc["text"], metadata={"source": doc["source"].split("/")[1]}) for doc in knowledge_base
+]
+
+## For your own PDFs, you can use the following code to load them into source_docs
+# pdf_directory = "pdfs"
+# pdf_files = [
+#     os.path.join(pdf_directory, f)
+#     for f in os.listdir(pdf_directory)
+#     if f.endswith(".pdf")
+# ]
+# source_docs = []
+
+# for file_path in pdf_files:
+#     loader = PyPDFLoader(file_path)
+#     docs.extend(loader.load())
+
+text_splitter = RecursiveCharacterTextSplitter.from_huggingface_tokenizer(
+    AutoTokenizer.from_pretrained("thenlper/gte-small"),
+    chunk_size=200,
+    chunk_overlap=20,
+    add_start_index=True,
+    strip_whitespace=True,
+    separators=["\n\n", "\n", ".", " ", ""],
+)
+
+# Split docs and keep only unique ones
+print("Splitting documents...")
+docs_processed = []
+unique_texts = {}
+for doc in tqdm(source_docs):
+    new_docs = text_splitter.split_documents([doc])
+    for new_doc in new_docs:
+        if new_doc.page_content not in unique_texts:
+            unique_texts[new_doc.page_content] = True
+            docs_processed.append(new_doc)
+
+
+print("Embedding documents... This should take a few minutes (5 minutes on MacBook with M1 Pro)")
+# Initialize embeddings and ChromaDB vector store
+embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+
+
+# embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
+
+vector_store = Chroma.from_documents(docs_processed, embeddings, persist_directory="./chroma_db")
+
+
+class RetrieverTool(Tool):
+    name = "retriever"
+    description = (
+        "Uses semantic search to retrieve the parts of documentation that could be most relevant to answer your query."
+    )
+    inputs = {
+        "query": {
+            "type": "string",
+            "description": "The query to perform. This should be semantically close to your target documents. Use the affirmative form rather than a question.",
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, vector_store, **kwargs):
+        super().__init__(**kwargs)
+        self.vector_store = vector_store
+
+    def forward(self, query: str) -> str:
+        assert isinstance(query, str), "Your search query must be a string"
+        docs = self.vector_store.similarity_search(query, k=3)
+        return "\nRetrieved documents:\n" + "".join(
+            [f"\n\n===== Document {str(i)} =====\n" + doc.page_content for i, doc in enumerate(docs)]
+        )
+
+
+retriever_tool = RetrieverTool(vector_store)
+
+# Choose which LLM engine to use!
+
+# from smolagents import InferenceClientModel
+# model = InferenceClientModel(model_id="meta-llama/Llama-3.3-70B-Instruct")
+
+# from smolagents import TransformersModel
+# model = TransformersModel(model_id="meta-llama/Llama-3.2-2B-Instruct")
+
+# For anthropic: change model_id below to 'anthropic/claude-3-5-sonnet-20240620' and also change 'os.environ.get("ANTHROPIC_API_KEY")'
+model = LiteLLMModel(
+    model_id="groq/llama-3.3-70b-versatile",
+    api_key=os.environ.get("GROQ_API_KEY"),
+)
+
+# # You can also use the ToolCallingAgent class
+# agent = ToolCallingAgent(
+#     tools=[retriever_tool],
+#     model=model,
+#     verbose=True,
+# )
+
+agent = CodeAgent(
+    tools=[retriever_tool],
+    model=model,
+    max_steps=4,
+    verbosity_level=2,
+)
+
+agent_output = agent.run("How can I push a model to the Hub?")
+
+
+print("Final output:")
+print(agent_output)

examples/sandboxed_execution.py

@@ -0,0 +1,12 @@
+from smolagents import CodeAgent, InferenceClientModel, WebSearchTool
+
+
+model = InferenceClientModel()
+
+agent = CodeAgent(tools=[WebSearchTool()], model=model, executor_type="docker")
+output = agent.run("How many seconds would it take for a leopard at full speed to run through Pont des Arts?")
+print("Docker executor result:", output)
+
+agent = CodeAgent(tools=[WebSearchTool()], model=model, executor_type="e2b")
+output = agent.run("How many seconds would it take for a leopard at full speed to run through Pont des Arts?")
+print("E2B executor result:", output)

examples/text_to_sql.py

@@ -0,0 +1,79 @@
+from sqlalchemy import (
+    Column,
+    Float,
+    Integer,
+    MetaData,
+    String,
+    Table,
+    create_engine,
+    insert,
+    inspect,
+    text,
+)
+
+
+engine = create_engine("sqlite:///:memory:")
+metadata_obj = MetaData()
+
+# create city SQL table
+table_name = "receipts"
+receipts = Table(
+    table_name,
+    metadata_obj,
+    Column("receipt_id", Integer, primary_key=True),
+    Column("customer_name", String(16), primary_key=True),
+    Column("price", Float),
+    Column("tip", Float),
+)
+metadata_obj.create_all(engine)
+
+rows = [
+    {"receipt_id": 1, "customer_name": "Alan Payne", "price": 12.06, "tip": 1.20},
+    {"receipt_id": 2, "customer_name": "Alex Mason", "price": 23.86, "tip": 0.24},
+    {"receipt_id": 3, "customer_name": "Woodrow Wilson", "price": 53.43, "tip": 5.43},
+    {"receipt_id": 4, "customer_name": "Margaret James", "price": 21.11, "tip": 1.00},
+]
+for row in rows:
+    stmt = insert(receipts).values(**row)
+    with engine.begin() as connection:
+        cursor = connection.execute(stmt)
+
+inspector = inspect(engine)
+columns_info = [(col["name"], col["type"]) for col in inspector.get_columns("receipts")]
+
+table_description = "Columns:\n" + "\n".join([f"  - {name}: {col_type}" for name, col_type in columns_info])
+print(table_description)
+
+from smolagents import tool
+
+
+@tool
+def sql_engine(query: str) -> str:
+    """
+    Allows you to perform SQL queries on the table. Returns a string representation of the result.
+    The table is named 'receipts'. Its description is as follows:
+        Columns:
+        - receipt_id: INTEGER
+        - customer_name: VARCHAR(16)
+        - price: FLOAT
+        - tip: FLOAT
+
+    Args:
+        query: The query to perform. This should be correct SQL.
+    """
+    output = ""
+    with engine.connect() as con:
+        rows = con.execute(text(query))
+        for row in rows:
+            output += "\n" + str(row)
+    return output
+
+
+from smolagents import CodeAgent, InferenceClientModel
+
+
+agent = CodeAgent(
+    tools=[sql_engine],
+    model=InferenceClientModel(model_id="meta-llama/Meta-Llama-3.1-8B-Instruct"),
+)
+agent.run("Can you give me the name of the client who got the most expensive receipt?")