Tools API

from agno.tools import tool, Function, Toolkit
from typing import Optional

@tool
def search_web(query: str, num_results: int = 5) -> str:
    """
    Search the web for information.
    
    Args:
        query: The search query
        num_results: Number of results to return
    
    Returns:
        str: Search results
    """
    # Implementation
    return results

# Using Function class directly
function = Function(
    name="get_weather",
    description="Get current weather for a location",
    parameters={
        "type": "object",
        "properties": {
            "location": {"type": "string", "description": "City name"},
            "units": {"type": "string", "enum": ["celsius", "fahrenheit"]}
        },
        "required": ["location"]
    },
    entrypoint=lambda location, units="celsius": f"Weather for {location}"
)

# Creating a Toolkit
class MyTools(Toolkit):
    def __init__(self):
        super().__init__(name="my_tools")
        self.register(self.tool1)
        self.register(self.tool2)
    
    def tool1(self, arg: str) -> str:
        """Tool 1 description"""
        return f"Result: {arg}"
    
    def tool2(self, arg: int) -> int:
        """Tool 2 description"""
        return arg * 2

from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.tavily import TavilyTools
from agno.tools.exa import ExaTools
from agno.tools.firecrawl import FirecrawlTools
from agno.tools.website import WebsiteTools

# DuckDuckGo search
class DuckDuckGoTools(Toolkit):
    def __init__(
        self,
        search: bool = True,
        news: bool = True,
        fixed_max_results: Optional[int] = None,
        **kwargs
    ): ...

# Tavily search
class TavilyTools(Toolkit):
    def __init__(
        self,
        api_key: Optional[str] = None,
        search: bool = True,
        max_results: int = 5,
        **kwargs
    ): ...

from agno.tools.yfinance import YFinanceTools
from agno.tools.duckdb import DuckDbTools
from agno.tools.pandas import PandasTools

# Yahoo Finance
class YFinanceTools(Toolkit):
    def __init__(
        self,
        stock_price: bool = True,
        company_info: bool = True,
        analyst_recommendations: bool = True,
        **kwargs
    ): ...

# DuckDB
class DuckDbTools(Toolkit):
    def __init__(
        self,
        db_path: Optional[str] = None,
        init_commands: Optional[List[str]] = None,
        **kwargs
    ): ...

from agno.tools.dalle import DalleTools
from agno.tools.elevenlabs import ElevenLabsTools
from agno.tools.replicate import ReplicateTools

# DALL-E image generation
class DalleTools(Toolkit):
    def __init__(
        self,
        model: str = "dall-e-3",
        size: str = "1024x1024",
        quality: str = "standard",
        **kwargs
    ): ...

# ElevenLabs text-to-speech
class ElevenLabsTools(Toolkit):
    def __init__(
        self,
        api_key: Optional[str] = None,
        voice_id: Optional[str] = None,
        **kwargs
    ): ...

from agno.tools.github import GithubTools
from agno.tools.shell import ShellTools
from agno.tools.python import PythonTools

# GitHub
class GithubTools(Toolkit):
    def __init__(
        self,
        access_token: Optional[str] = None,
        **kwargs
    ): ...

# Shell commands
class ShellTools(Toolkit):
    def __init__(
        self,
        allowed_commands: Optional[List[str]] = None,
        **kwargs
    ): ...

from agno.tools.slack import SlackTools
from agno.tools.gmail import GmailTools
from agno.tools.notion import NotionTools

# Slack
class SlackTools(Toolkit):
    def __init__(
        self,
        token: Optional[str] = None,
        **kwargs
    ): ...

from agno.tools.mcp import MCPTools, MultiMCPTools

class MCPTools(Toolkit):
    def __init__(
        self,
        transport: str,  # "stdio", "sse", or "streamable-http"
        command: Optional[str] = None,  # For stdio
        args: Optional[List[str]] = None,  # For stdio
        url: Optional[str] = None,  # For sse/http
        env: Optional[Dict[str, str]] = None,
        **kwargs
    ): ...

class MultiMCPTools(Toolkit):
    def __init__(
        self,
        servers: List[Dict[str, Any]],
        **kwargs
    ): ...

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools.duckduckgo import DuckDuckGoTools
from agno.tools.yfinance import YFinanceTools

agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    tools=[
        DuckDuckGoTools(),
        YFinanceTools()
    ],
    instructions=["Use tools to find accurate information"]
)

response = agent.run("What's the current price of Apple stock?")

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools import tool

@tool
def calculate_tip(bill_amount: float, tip_percentage: float = 15.0) -> dict:
    """
    Calculate tip amount and total bill.
    
    Args:
        bill_amount: The bill amount in dollars
        tip_percentage: Tip percentage (default 15%)
    
    Returns:
        dict: Tip amount and total
    """
    tip = bill_amount * (tip_percentage / 100)
    total = bill_amount + tip
    return {"tip": tip, "total": total}

agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    tools=[calculate_tip]
)

response = agent.run("Calculate a 20% tip on a $50 bill")

from agno.agent import Agent
from agno.models.openai import OpenAIChat
from agno.tools import tool

@tool
def send_email(to: str, subject: str, body: str) -> str:
    """Send an email (requires confirmation)"""
    # Send email logic
    return f"Email sent to {to}"

# Mark tool as requiring confirmation
send_email_func = send_email
send_email_func.requires_confirmation = True

agent = Agent(
    model=OpenAIChat(id="gpt-4"),
    tools=[send_email_func]
)

# Run will pause and return requirements
response = agent.run("Send an email to john@example.com saying hello")

if response.is_paused:
    # User reviews and approves
    print(f"Confirm: {response.tools_requiring_confirmation}")
    
    # Continue after approval
    final_response = agent.continue_run(response)

from agno.agent import Agent
from agno.models.anthropic import Claude
from agno.tools.mcp import MCPTools

agent = Agent(
    model=Claude(id="claude-sonnet-4-5"),
    tools=[
        MCPTools(
            transport="streamable-http",
            url="https://docs.agno.com/mcp"
        )
    ]
)

response = agent.run("Search the documentation for agentic RAG")