Tools

from agentor import tool

@tool
def get_weather(city: str) -> str:
    """Get the current weather for a city."""
    return f"The weather in {city} is sunny and 72°F"

@tool
def tool(
    func: Optional[Callable] = None,
    *,
    name: Optional[str] = None,
    description: Optional[str] = None,
) -> BaseTool

@tool(name="weather_lookup", description="Fetches weather data")
def get_weather(city: str) -> str:
    return f"Weather in {city}: Sunny"

from agentor import function_tool

@function_tool
def calculate(expression: str) -> float:
    """Evaluate a mathematical expression."""
    return eval(expression)

from agentor import Agentor, function_tool

@function_tool(name_override="math_calc")
def calculate(x: int, y: int, operation: str) -> int:
    """Perform basic arithmetic operations."""
    if operation == "add":
        return x + y
    elif operation == "multiply":
        return x * y
    return 0

agent = Agentor(
    name="Math Agent",
    tools=[calculate]
)

from agentor.tools import BaseTool, capability

class WeatherTool(BaseTool):
    name = "weather"
    description = "Get weather information"
    
    def __init__(self, api_key: str):
        super().__init__(api_key=api_key)
    
    @capability
    def get_current(self, city: str) -> str:
        """Get current weather for a city."""
        return f"Current weather in {city}: Sunny, 72°F"
    
    @capability
    def get_forecast(self, city: str, days: int = 3) -> str:
        """Get weather forecast for a city."""
        return f"{days}-day forecast for {city}: Mostly sunny"

class BaseTool(ABC):
    name: str = "un-named-tool"
    description: str | None = None
    
    def __init__(self, api_key: Optional[str] = None):
        ...

def list_capabilities() -> List[Tuple[str, FunctionType]]

def to_openai_function() -> List[FunctionTool]

def json_schema() -> List[ToolType]

def serve(
    name: Optional[str] = None,
    port: int = 8000
)

weather = WeatherTool(api_key="...")
weather.serve(port=8000)  # Serves MCP server on port 8000

@staticmethod
def from_function(
    func: Callable,
    name: str | None = None,
    description: str | None = None
) -> BaseTool

from agentor.tools.base import BaseTool

def weather_tool(city: str) -> str:
    """Get weather for a city."""
    return f"Weather in {city} is warm and sunny."

tool = BaseTool.from_function(weather_tool)
result = tool.run("London")
print(result)  # "Weather in London is warm and sunny."

from agentor.tools.base import capability

@capability
def my_capability(self, param: str) -> str:
    """Capability description."""
    return f"Result: {param}"

from agentor import Agentor, function_tool

@function_tool
def get_weather(city: str) -> str:
    """Returns the weather in the given city."""
    return f"The weather in {city} is sunny"

agent = Agentor(
    name="Weather Assistant",
    tools=[get_weather],
    instructions="Use the weather tool to answer questions."
)

result = agent.run("What's the weather in Tokyo?")

from agentor import Agentor
from agentor.tools import GetWeatherTool

weather_tool = GetWeatherTool(api_key="your_api_key")

agent = Agentor(
    name="Weather Agent",
    tools=[weather_tool],
    instructions="Always use the weather tool to answer weather questions."
)

result = agent.run("What is the current weather in London?")

from agentor import Agentor

agent = Agentor(
    name="Multi-Tool Agent",
    tools=["gmail", "get_weather"],  # Reference by name
    instructions="Use the available tools to help the user."
)

import os
from agentor import Agentor
from agentor.mcp import MCPServerStreamableHttp

mcp_server = MCPServerStreamableHttp(
    name="Search Server",
    params={
        "url": "https://api.example.com/mcp",
        "headers": {"Authorization": f"Bearer {os.environ['API_KEY']}"},
        "timeout": 10,
    },
    cache_tools_list=True,
    max_retry_attempts=3
)

agent = Agentor(
    name="Search Agent",
    tools=[mcp_server],
    instructions="Use the search tool to find information."
)

from agentor import Agentor
from agentor.tools import CalculatorTool

agent = Agentor(
    name="Math Assistant",
    tools=[CalculatorTool()],
    instructions="Use the calculator for all arithmetic."
)

result = agent.run("What is (37 * 12) - (144 / 3)?")

import os
from agentor import Agentor
from agentor.tools import GetWeatherTool

weather_api_key = os.environ.get("WEATHER_API_KEY")

agent = Agentor(
    name="Weather Agent",
    tools=[GetWeatherTool(api_key=weather_api_key)],
    instructions="Provide accurate weather information."
)

from agentor import Agentor, function_tool
import datetime

@function_tool
def get_current_time(timezone: str = "UTC") -> str:
    """Get the current time in a specific timezone."""
    return f"Current time in {timezone}: {datetime.datetime.now()}"

agent = Agentor(
    name="Time Assistant",
    tools=[get_current_time]
)

from agentor.tools import BaseTool, capability
import requests

class APItool(BaseTool):
    name = "api_client"
    description = "Make HTTP API requests"
    
    @capability
    def get(self, url: str) -> str:
        """Make a GET request."""
        response = requests.get(url)
        return response.text
    
    @capability
    def post(self, url: str, data: dict) -> str:
        """Make a POST request."""
        response = requests.post(url, json=data)
        return response.text

api_tool = APItool()

from agentor.tools import BaseTool, capability

class CounterTool(BaseTool):
    name = "counter"
    description = "Track and increment a counter"
    
    def __init__(self):
        super().__init__()
        self.count = 0
    
    @capability
    def increment(self, amount: int = 1) -> str:
        """Increment the counter."""
        self.count += amount
        return f"Counter is now: {self.count}"
    
    @capability
    def get_count(self) -> str:
        """Get the current count."""
        return f"Current count: {self.count}"
    
    @capability
    def reset(self) -> str:
        """Reset the counter to zero."""
        self.count = 0
        return "Counter reset to 0"

from agentor.tools.base import BaseTool

def search_database(query: str) -> str:
    """Search the database for records."""
    # Implementation here
    return f"Found 5 results for: {query}"

search_tool = BaseTool.from_function(
    search_database,
    name="db_search",
    description="Search database records"
)

result = search_tool.run("user accounts")

from agentor import function_tool
from typing import Optional

@function_tool
def get_user_profile(user_id: str, include_history: bool = False) -> str:
    """
    Retrieve a user's profile information.
    
    Args:
        user_id: The unique identifier for the user
        include_history: Whether to include purchase history (default: False)
    
    Returns:
        JSON string containing user profile data
    """
    try:
        # Implementation
        return '{"name": "Alice", "email": "alice@example.com"}'
    except Exception as e:
        return f"Error fetching user profile: {str(e)}"