Upload 4 files

docs/source/en/examples/rag.md

@@ -0,0 +1,206 @@
+# Agentic RAG
+
+[[open-in-colab]]
+
+## Introduction to Retrieval-Augmented Generation (RAG)
+
+Retrieval-Augmented Generation (RAG) combines the power of large language models with external knowledge retrieval to produce more accurate, factual, and contextually relevant responses. At its core, RAG is about "using an LLM to answer a user query, but basing the answer on information retrieved from a knowledge base."
+
+### Why Use RAG?
+
+RAG offers several significant advantages over using vanilla or fine-tuned LLMs:
+
+1. **Factual Grounding**: Reduces hallucinations by anchoring responses in retrieved facts
+2. **Domain Specialization**: Provides domain-specific knowledge without model retraining
+3. **Knowledge Recency**: Allows access to information beyond the model's training cutoff
+4. **Transparency**: Enables citation of sources for generated content
+5. **Control**: Offers fine-grained control over what information the model can access
+
+### Limitations of Traditional RAG
+
+Despite its benefits, traditional RAG approaches face several challenges:
+
+- **Single Retrieval Step**: If the initial retrieval results are poor, the final generation will suffer
+- **Query-Document Mismatch**: User queries (often questions) may not match well with documents containing answers (often statements)
+- **Limited Reasoning**: Simple RAG pipelines don't allow for multi-step reasoning or query refinement
+- **Context Window Constraints**: Retrieved documents must fit within the model's context window
+
+## Agentic RAG: A More Powerful Approach
+
+We can overcome these limitations by implementing an **Agentic RAG** system - essentially an agent equipped with retrieval capabilities. This approach transforms RAG from a rigid pipeline into an interactive, reasoning-driven process.
+
+### Key Benefits of Agentic RAG
+
+An agent with retrieval tools can:
+
+1. ✅ **Formulate optimized queries**: The agent can transform user questions into retrieval-friendly queries
+2. ✅ **Perform multiple retrievals**: The agent can retrieve information iteratively as needed
+3. ✅ **Reason over retrieved content**: The agent can analyze, synthesize, and draw conclusions from multiple sources
+4. ✅ **Self-critique and refine**: The agent can evaluate retrieval results and adjust its approach
+
+This approach naturally implements advanced RAG techniques:
+- **Hypothetical Document Embedding (HyDE)**: Instead of using the user query directly, the agent formulates retrieval-optimized queries ([paper reference](https://huggingface.co/papers/2212.10496))
+- **Self-Query Refinement**: The agent can analyze initial results and perform follow-up retrievals with refined queries ([technique reference](https://docs.llamaindex.ai/en/stable/examples/evaluation/RetryQuery/))
+
+## Building an Agentic RAG System
+
+Let's build a complete Agentic RAG system step by step. We'll create an agent that can answer questions about the Hugging Face Transformers library by retrieving information from its documentation.
+
+You can follow along with the code snippets below, or check out the full example in the smolagents GitHub repository: [examples/rag.py](https://github.com/huggingface/smolagents/blob/main/examples/rag.py).
+
+### Step 1: Install Required Dependencies
+
+First, we need to install the necessary packages:
+
+```bash
+pip install smolagents pandas langchain langchain-community sentence-transformers datasets python-dotenv rank_bm25 --upgrade
+```
+
+If you plan to use Hugging Face's Inference API, you'll need to set up your API token:
+
+```python
+# Load environment variables (including HF_TOKEN)
+from dotenv import load_dotenv
+load_dotenv()
+```
+
+### Step 2: Prepare the Knowledge Base
+
+We'll use a dataset containing Hugging Face documentation and prepare it for retrieval:
+
+```python
+import datasets
+from langchain.docstore.document import Document
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain_community.retrievers import BM25Retriever
+
+# Load the Hugging Face documentation dataset
+knowledge_base = datasets.load_dataset("m-ric/huggingface_doc", split="train")
+
+# Filter to include only Transformers documentation
+knowledge_base = knowledge_base.filter(lambda row: row["source"].startswith("huggingface/transformers"))
+
+# Convert dataset entries to Document objects with metadata
+source_docs = [
+    Document(page_content=doc["text"], metadata={"source": doc["source"].split("/")[1]})
+    for doc in knowledge_base
+]
+
+# Split documents into smaller chunks for better retrieval
+text_splitter = RecursiveCharacterTextSplitter(
+    chunk_size=500,  # Characters per chunk
+    chunk_overlap=50,  # Overlap between chunks to maintain context
+    add_start_index=True,
+    strip_whitespace=True,
+    separators=["\n\n", "\n", ".", " ", ""],  # Priority order for splitting
+)
+docs_processed = text_splitter.split_documents(source_docs)
+
+print(f"Knowledge base prepared with {len(docs_processed)} document chunks")
+```
+
+### Step 3: Create a Retriever Tool
+
+Now we'll create a custom tool that our agent can use to retrieve information from the knowledge base:
+
+```python
+from smolagents import Tool
+
+class RetrieverTool(Tool):
+    name = "retriever"
+    description = "Uses semantic 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 semantically close to your target documents. Use the affirmative form rather than a question.",
+        }
+    }
+    output_type = "string"
+
+    def __init__(self, docs, **kwargs):
+        super().__init__(**kwargs)
+        # Initialize the retriever with our processed documents
+        self.retriever = BM25Retriever.from_documents(
+            docs, k=10  # Return top 10 most relevant documents
+        )
+
+    def forward(self, query: str) -> str:
+        """Execute the retrieval based on the provided query."""
+        assert isinstance(query, str), "Your search query must be a string"
+
+        # Retrieve relevant documents
+        docs = self.retriever.invoke(query)
+
+        # Format the retrieved documents for readability
+        return "\nRetrieved documents:\n" + "".join(
+            [
+                f"\n\n===== Document {str(i)} =====\n" + doc.page_content
+                for i, doc in enumerate(docs)
+            ]
+        )
+
+# Initialize our retriever tool with the processed documents
+retriever_tool = RetrieverTool(docs_processed)
+```
+
+> [!TIP]
+> We're using BM25, a lexical retrieval method, for simplicity and speed. For production systems, you might want to use semantic search with embeddings for better retrieval quality. Check the [MTEB Leaderboard](https://huggingface.co/spaces/mteb/leaderboard) for high-quality embedding models.
+
+### Step 4: Create an Advanced Retrieval Agent
+
+Now we'll create an agent that can use our retriever tool to answer questions:
+
+```python
+from smolagents import InferenceClientModel, CodeAgent
+
+# Initialize the agent with our retriever tool
+agent = CodeAgent(
+    tools=[retriever_tool],  # List of tools available to the agent
+    model=InferenceClientModel(),  # Default model "Qwen/Qwen2.5-Coder-32B-Instruct"
+    max_steps=4,  # Limit the number of reasoning steps
+    verbosity_level=2,  # Show detailed agent reasoning
+)
+
+# To use a specific model, you can specify it like this:
+# model=InferenceClientModel(model_id="meta-llama/Llama-3.3-70B-Instruct")
+```
+
+> [!TIP]
+> Inference Providers give access to hundreds of models, powered by serverless inference partners. A list of supported providers can be found [here](https://huggingface.co/docs/inference-providers/index).
+
+### Step 5: Run the Agent to Answer Questions
+
+Let's use our agent to answer a question about Transformers:
+
+```python
+# Ask a question that requires retrieving information
+question = "For a transformers model training, which is slower, the forward or the backward pass?"
+
+# Run the agent to get an answer
+agent_output = agent.run(question)
+
+# Display the final answer
+print("\nFinal answer:")
+print(agent_output)
+```
+
+## Practical Applications of Agentic RAG
+
+Agentic RAG systems can be applied to various use cases:
+
+1. **Technical Documentation Assistance**: Help users navigate complex technical documentation
+2. **Research Paper Analysis**: Extract and synthesize information from scientific papers
+3. **Legal Document Review**: Find relevant precedents and clauses in legal documents
+4. **Customer Support**: Answer questions based on product documentation and knowledge bases
+5. **Educational Tutoring**: Provide explanations based on textbooks and learning materials
+
+## Conclusion
+
+Agentic RAG represents a significant advancement over traditional RAG pipelines. By combining the reasoning capabilities of LLM agents with the factual grounding of retrieval systems, we can build more powerful, flexible, and accurate information systems.
+
+The approach we've demonstrated:
+- Overcomes the limitations of single-step retrieval
+- Enables more natural interactions with knowledge bases
+- Provides a framework for continuous improvement through self-critique and query refinement
+
+As you build your own Agentic RAG systems, consider experimenting with different retrieval methods, agent architectures, and knowledge sources to find the optimal configuration for your specific use case.

docs/source/en/examples/text_to_sql.md

@@ -0,0 +1,197 @@
+# Text-to-SQL
+
+[[open-in-colab]]
+
+In this tutorial, we’ll see how to implement an agent that leverages SQL using `smolagents`.
+
+> Let's start with the golden question: why not keep it simple and use a standard text-to-SQL pipeline?
+
+A standard text-to-sql pipeline is brittle, since the generated SQL query can be incorrect. Even worse, the query could be incorrect, but not raise an error, instead giving some incorrect/useless outputs without raising an alarm.
+
+👉 Instead, an agent system is able to critically inspect outputs and decide if the query needs to be changed or not, thus giving it a huge performance boost.
+
+Let’s build this agent! 💪
+
+Run the line below to install required dependencies:
+```bash
+!pip install smolagents python-dotenv sqlalchemy --upgrade -q
+```
+To call Inference Providers, you will need a valid token as your environment variable `HF_TOKEN`.
+We use python-dotenv to load it.
+```py
+from dotenv import load_dotenv
+load_dotenv()
+```
+
+Then, we setup the SQL environment:
+```py
+from sqlalchemy import (
+    create_engine,
+    MetaData,
+    Table,
+    Column,
+    String,
+    Integer,
+    Float,
+    insert,
+    inspect,
+    text,
+)
+
+engine = create_engine("sqlite:///:memory:")
+metadata_obj = MetaData()
+
+def insert_rows_into_table(rows, table, engine=engine):
+    for row in rows:
+        stmt = insert(table).values(**row)
+        with engine.begin() as connection:
+            connection.execute(stmt)
+
+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},
+]
+insert_rows_into_table(rows, receipts)
+```
+
+### Build our agent
+
+Now let’s make our SQL table retrievable by a tool.
+
+The tool’s description attribute will be embedded in the LLM’s prompt by the agent system: it gives the LLM information about how to use the tool. This is where we want to describe the SQL table.
+
+```py
+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)
+```
+
+```text
+Columns:
+  - receipt_id: INTEGER
+  - customer_name: VARCHAR(16)
+  - price: FLOAT
+  - tip: FLOAT
+```
+
+Now let’s build our tool. It needs the following: (read [the tool doc](../tutorials/tools) for more detail)
+- A docstring with an `Args:` part listing arguments.
+- Type hints on both inputs and output.
+
+```py
+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
+```
+
+Now let us create an agent that leverages this tool.
+
+We use the `CodeAgent`, which is smolagents’ main agent class: an agent that writes actions in code and can iterate on previous output according to the ReAct framework.
+
+The model is the LLM that powers the agent system. `InferenceClientModel` allows you to call LLMs using HF’s Inference API, either via Serverless or Dedicated endpoint, but you could also use any proprietary API.
+
+```py
+from smolagents import CodeAgent, InferenceClientModel
+
+agent = CodeAgent(
+    tools=[sql_engine],
+    model=InferenceClientModel(model_id="meta-llama/Llama-3.1-8B-Instruct"),
+)
+agent.run("Can you give me the name of the client who got the most expensive receipt?")
+```
+
+### Level 2: Table joins
+
+Now let’s make it more challenging! We want our agent to handle joins across multiple tables.
+
+So let’s make a second table recording the names of waiters for each receipt_id!
+
+```py
+table_name = "waiters"
+waiters = Table(
+    table_name,
+    metadata_obj,
+    Column("receipt_id", Integer, primary_key=True),
+    Column("waiter_name", String(16), primary_key=True),
+)
+metadata_obj.create_all(engine)
+
+rows = [
+    {"receipt_id": 1, "waiter_name": "Corey Johnson"},
+    {"receipt_id": 2, "waiter_name": "Michael Watts"},
+    {"receipt_id": 3, "waiter_name": "Michael Watts"},
+    {"receipt_id": 4, "waiter_name": "Margaret James"},
+]
+insert_rows_into_table(rows, waiters)
+```
+Since we changed the table, we update the `SQLExecutorTool` with this table’s description to let the LLM properly leverage information from this table.
+
+```py
+updated_description = """Allows you to perform SQL queries on the table. Beware that this tool's output is a string representation of the execution output.
+It can use the following tables:"""
+
+inspector = inspect(engine)
+for table in ["receipts", "waiters"]:
+    columns_info = [(col["name"], col["type"]) for col in inspector.get_columns(table)]
+
+    table_description = f"Table '{table}':\n"
+
+    table_description += "Columns:\n" + "\n".join([f"  - {name}: {col_type}" for name, col_type in columns_info])
+    updated_description += "\n\n" + table_description
+
+print(updated_description)
+```
+Since this request is a bit harder than the previous one, we’ll switch the LLM engine to use the more powerful [Qwen/Qwen2.5-Coder-32B-Instruct](https://huggingface.co/Qwen/Qwen2.5-Coder-32B-Instruct)!
+
+```py
+sql_engine.description = updated_description
+
+agent = CodeAgent(
+    tools=[sql_engine],
+    model=InferenceClientModel(model_id="Qwen/Qwen2.5-Coder-32B-Instruct"),
+)
+
+agent.run("Which waiter got more total money from tips?")
+```
+It directly works! The setup was surprisingly simple, wasn’t it?
+
+This example is done! We've touched upon these concepts:
+- Building new tools.
+- Updating a tool's description.
+- Switching to a stronger LLM helps agent reasoning.
+
+✅ Now you can go build this text-to-SQL system you’ve always dreamt of! ✨

docs/source/en/examples/using_different_models.md

@@ -0,0 +1,76 @@
+# Using different models
+
+[[open-in-colab]]
+
+`smolagents` provides a flexible framework that allows you to use various language models from different providers.
+This guide will show you how to use different model types with your agents.
+
+## Available model types
+
+`smolagents` supports several model types out of the box:
+1. [`InferenceClientModel`]: Uses Hugging Face's Inference API to access models
+2. [`TransformersModel`]: Runs models locally using the Transformers library
+3. [`VLLMModel`]: Uses vLLM for fast inference with optimized serving
+4. [`MLXModel`]: Optimized for Apple Silicon devices using MLX
+5. [`LiteLLMModel`]: Provides access to hundreds of LLMs through LiteLLM
+6. [`LiteLLMRouterModel`]: Distributes requests among multiple models
+7. [`OpenAIServerModel`]: Provides access to any provider that implements an OpenAI-compatible API
+8. [`AzureOpenAIServerModel`]: Uses Azure's OpenAI service
+9. [`AmazonBedrockServerModel`]: Connects to AWS Bedrock's API
+
+## Using Google Gemini Models
+
+As explained in the Google Gemini API documentation (https://ai.google.dev/gemini-api/docs/openai),
+Google provides an OpenAI-compatible API for Gemini models, allowing you to use the [`OpenAIServerModel`]
+with Gemini models by setting the appropriate base URL.
+
+First, install the required dependencies:
+```bash
+pip install smolagents[openai]
+```
+
+Then, [get a Gemini API key](https://ai.google.dev/gemini-api/docs/api-key) and set it in your code:
+```python
+GEMINI_API_KEY = <YOUR-GEMINI-API-KEY>
+```
+
+Now, you can initialize the Gemini model using the `OpenAIServerModel` class
+and setting the `api_base` parameter to the Gemini API base URL:
+```python
+from smolagents import OpenAIServerModel
+
+model = OpenAIServerModel(
+    model_id="gemini-2.0-flash",
+    # Google Gemini OpenAI-compatible API base URL
+    api_base="https://generativelanguage.googleapis.com/v1beta/openai/",
+    api_key=GEMINI_API_KEY,
+)
+```
+
+## Using OpenRouter Models
+
+OpenRouter provides access to a wide variety of language models through a unified OpenAI-compatible API.
+You can use the [`OpenAIServerModel`] to connect to OpenRouter by setting the appropriate base URL.
+
+First, install the required dependencies:
+```bash
+pip install smolagents[openai]
+```
+
+Then, [get an OpenRouter API key](https://openrouter.ai/keys) and set it in your code:
+```python
+OPENROUTER_API_KEY = <YOUR-OPENROUTER-API-KEY>
+```
+
+Now, you can initialize any model available on OpenRouter using the `OpenAIServerModel` class:
+```python
+from smolagents import OpenAIServerModel
+
+model = OpenAIServerModel(
+    # You can use any model ID available on OpenRouter
+    model_id="openai/gpt-4o",
+    # OpenRouter API base URL
+    api_base="https://openrouter.ai/api/v1",
+    api_key=OPENROUTER_API_KEY,
+)
+```

docs/source/en/examples/web_browser.md

@@ -0,0 +1,213 @@
+# Web Browser Automation with Agents 🤖🌐
+
+[[open-in-colab]]
+
+In this notebook, we'll create an **agent-powered web browser automation system**! This system can navigate websites, interact with elements, and extract information automatically.
+
+The agent will be able to:
+
+- [x] Navigate to web pages
+- [x] Click on elements
+- [x] Search within pages
+- [x] Handle popups and modals
+- [x] Extract information
+
+Let's set up this system step by step!
+
+First, run these lines to install the required dependencies:
+
+```bash
+pip install smolagents selenium helium pillow -q
+```
+
+Let's import our required libraries and set up environment variables:
+
+```python
+from io import BytesIO
+from time import sleep
+
+import helium
+from dotenv import load_dotenv
+from PIL import Image
+from selenium import webdriver
+from selenium.webdriver.common.by import By
+from selenium.webdriver.common.keys import Keys
+
+from smolagents import CodeAgent, tool
+from smolagents.agents import ActionStep
+
+# Load environment variables
+load_dotenv()
+```
+
+Now let's create our core browser interaction tools that will allow our agent to navigate and interact with web pages:
+
+```python
+@tool
+def search_item_ctrl_f(text: str, nth_result: int = 1) -> str:
+    """
+    Searches for text on the current page via Ctrl + F and jumps to the nth occurrence.
+    Args:
+        text: The text to search for
+        nth_result: Which occurrence to jump to (default: 1)
+    """
+    elements = driver.find_elements(By.XPATH, f"//*[contains(text(), '{text}')]")
+    if nth_result > len(elements):
+        raise Exception(f"Match n°{nth_result} not found (only {len(elements)} matches found)")
+    result = f"Found {len(elements)} matches for '{text}'."
+    elem = elements[nth_result - 1]
+    driver.execute_script("arguments[0].scrollIntoView(true);", elem)
+    result += f"Focused on element {nth_result} of {len(elements)}"
+    return result
+
+@tool
+def go_back() -> None:
+    """Goes back to previous page."""
+    driver.back()
+
+@tool
+def close_popups() -> str:
+    """
+    Closes any visible modal or pop-up on the page. Use this to dismiss pop-up windows!
+    This does not work on cookie consent banners.
+    """
+    webdriver.ActionChains(driver).send_keys(Keys.ESCAPE).perform()
+```
+
+Let's set up our browser with Chrome and configure screenshot capabilities:
+
+```python
+# Configure Chrome options
+chrome_options = webdriver.ChromeOptions()
+chrome_options.add_argument("--force-device-scale-factor=1")
+chrome_options.add_argument("--window-size=1000,1350")
+chrome_options.add_argument("--disable-pdf-viewer")
+chrome_options.add_argument("--window-position=0,0")
+
+# Initialize the browser
+driver = helium.start_chrome(headless=False, options=chrome_options)
+
+# Set up screenshot callback
+def save_screenshot(memory_step: ActionStep, agent: CodeAgent) -> None:
+    sleep(1.0)  # Let JavaScript animations happen before taking the screenshot
+    driver = helium.get_driver()
+    current_step = memory_step.step_number
+    if driver is not None:
+        for previous_memory_step in agent.memory.steps:  # Remove previous screenshots for lean processing
+            if isinstance(previous_memory_step, ActionStep) and previous_memory_step.step_number <= current_step - 2:
+                previous_memory_step.observations_images = None
+        png_bytes = driver.get_screenshot_as_png()
+        image = Image.open(BytesIO(png_bytes))
+        print(f"Captured a browser screenshot: {image.size} pixels")
+        memory_step.observations_images = [image.copy()]  # Create a copy to ensure it persists
+
+    # Update observations with current URL
+    url_info = f"Current url: {driver.current_url}"
+    memory_step.observations = (
+        url_info if memory_step.observations is None else memory_step.observations + "\n" + url_info
+    )
+```
+
+Now let's create our web automation agent:
+
+```python
+from smolagents import InferenceClientModel
+
+# Initialize the model
+model_id = "Qwen/Qwen2-VL-72B-Instruct"  # You can change this to your preferred VLM model
+model = InferenceClientModel(model_id=model_id)
+
+# Create the agent
+agent = CodeAgent(
+    tools=[go_back, close_popups, search_item_ctrl_f],
+    model=model,
+    additional_authorized_imports=["helium"],
+    step_callbacks=[save_screenshot],
+    max_steps=20,
+    verbosity_level=2,
+)
+
+# Import helium for the agent
+agent.python_executor("from helium import *", agent.state)
+```
+
+The agent needs instructions on how to use Helium for web automation. Here are the instructions we'll provide:
+
+```python
+helium_instructions = """
+You can use helium to access websites. Don't bother about the helium driver, it's already managed.
+We've already ran "from helium import *"
+Then you can go to pages!
+Code:
+```py
+go_to('github.com/trending')
+```<end_code>
+
+You can directly click clickable elements by inputting the text that appears on them.
+Code:
+```py
+click("Top products")
+```<end_code>
+
+If it's a link:
+Code:
+```py
+click(Link("Top products"))
+```<end_code>
+
+If you try to interact with an element and it's not found, you'll get a LookupError.
+In general stop your action after each button click to see what happens on your screenshot.
+Never try to login in a page.
+
+To scroll up or down, use scroll_down or scroll_up with as an argument the number of pixels to scroll from.
+Code:
+```py
+scroll_down(num_pixels=1200) # This will scroll one viewport down
+```<end_code>
+
+When you have pop-ups with a cross icon to close, don't try to click the close icon by finding its element or targeting an 'X' element (this most often fails).
+Just use your built-in tool `close_popups` to close them:
+Code:
+```py
+close_popups()
+```<end_code>
+
+You can use .exists() to check for the existence of an element. For example:
+Code:
+```py
+if Text('Accept cookies?').exists():
+    click('I accept')
+```<end_code>
+"""
+```
+
+Now we can run our agent with a task! Let's try finding information on Wikipedia:
+
+```python
+search_request = """
+Please navigate to https://en.wikipedia.org/wiki/Chicago and give me a sentence containing the word "1992" that mentions a construction accident.
+"""
+
+agent_output = agent.run(search_request + helium_instructions)
+print("Final output:")
+print(agent_output)
+```
+
+You can run different tasks by modifying the request. For example, here's for me to know if I should work harder:
+
+```python
+github_request = """
+I'm trying to find how hard I have to work to get a repo in github.com/trending.
+Can you navigate to the profile for the top author of the top trending repo, and give me their total number of commits over the last year?
+"""
+
+agent_output = agent.run(github_request + helium_instructions)
+print("Final output:")
+print(agent_output)
+```
+
+The system is particularly effective for tasks like:
+- Data extraction from websites
+- Web research automation
+- UI testing and verification
+- Content monitoring