Tools Overview

from lyzr import Studio

studio = Studio(api_key="your-api-key")

# Define a function with type hints and docstring
def get_weather(city: str) -> str:
    """Get current weather for a city"""
    # Your implementation
    return f"Weather in {city}: Sunny, 72°F"

def search_products(query: str, limit: int = 10) -> list:
    """Search products by query"""
    # Your implementation
    return [{"name": "Product A", "price": 29.99}]

# Create agent
agent = studio.create_agent(
    name="Assistant",
    provider="gpt-4o",
    role="Helpful assistant",
    goal="Help users with various tasks"
)

# Add functions as tools - SDK auto-infers parameters from type hints
agent.add_tool(get_weather)
agent.add_tool(search_products)

# Run - agent will call the functions when needed
response = agent.run("What's the weather in Tokyo?")
print(response.response)  # Uses get_weather("Tokyo") internally

def calculate_tip(bill: float, percentage: int = 18) -> float:
    """Calculate tip amount for a bill"""
    return bill * percentage / 100

agent.add_tool(calculate_tip)

from lyzr.tools import Tool

def get_weather(city: str) -> str:
    """Get weather for a city"""
    return f"Weather in {city}: Sunny, 72°F"

weather_tool = Tool(
    name="get_weather",
    description="Get current weather for a city. Returns temperature and conditions.",
    parameters={
        "type": "object",
        "properties": {
            "city": {"type": "string", "description": "City name (e.g., Tokyo, New York)"}
        },
        "required": ["city"]
    },
    function=get_weather
)

agent.add_tool(weather_tool)

User Query → Agent → Decides to use tool → Executes function → Returns result → Agent continues

from lyzr.tools import Tool

tool = Tool(
    name="unique_name",           # Unique identifier
    description="What it does",   # For LLM understanding
    parameters={...},             # JSON schema for inputs
    function=my_function          # Python function to call
)

from lyzr.tools import ToolRegistry

registry = ToolRegistry()
registry.add(tool1)
registry.add(tool2)

# List all tools
for tool in registry.list():
    print(tool.name)

from lyzr.tools import LocalToolExecutor

executor = LocalToolExecutor(registry)
result = await executor.execute("tool_name", {"arg": "value"})

parameters = {
    "type": "object",
    "properties": {
        "city": {
            "type": "string",
            "description": "City name"
        },
        "units": {
            "type": "string",
            "description": "Temperature units",
            "enum": ["celsius", "fahrenheit"]
        }
    },
    "required": ["city"]
}

from lyzr.tools.local import infer_parameters_from_function

def search_products(query: str, max_results: int = 10) -> list:
    """Search products by query"""
    pass

params = infer_parameters_from_function(search_products)
# {
#     "type": "object",
#     "properties": {
#         "query": {"type": "string", "description": "Parameter query"},
#         "max_results": {"type": "integer", "description": "Parameter max_results"}
#     },
#     "required": ["query"]
# }

def query_database(sql: str) -> dict:
    """Execute SQL query"""
    # Your database logic
    return {"results": [...]}

db_tool = Tool(
    name="query_database",
    description="Query the product database",
    parameters={
        "type": "object",
        "properties": {
            "sql": {"type": "string", "description": "SQL query to execute"}
        },
        "required": ["sql"]
    },
    function=query_database
)

def send_email(to: str, subject: str, body: str) -> str:
    """Send an email"""
    # Your email logic
    return "Email sent successfully"

email_tool = Tool(
    name="send_email",
    description="Send an email to a recipient",
    parameters={
        "type": "object",
        "properties": {
            "to": {"type": "string", "description": "Recipient email"},
            "subject": {"type": "string", "description": "Email subject"},
            "body": {"type": "string", "description": "Email body"}
        },
        "required": ["to", "subject", "body"]
    },
    function=send_email
)

def calculate_mortgage(principal: float, rate: float, years: int) -> dict:
    """Calculate mortgage payment"""
    monthly_rate = rate / 100 / 12
    payments = years * 12
    payment = principal * (monthly_rate * (1 + monthly_rate)**payments) / ((1 + monthly_rate)**payments - 1)
    return {"monthly_payment": round(payment, 2)}

mortgage_tool = Tool(
    name="calculate_mortgage",
    description="Calculate monthly mortgage payment",
    parameters={
        "type": "object",
        "properties": {
            "principal": {"type": "number", "description": "Loan amount"},
            "rate": {"type": "number", "description": "Annual interest rate (%)"},
            "years": {"type": "integer", "description": "Loan term in years"}
        },
        "required": ["principal", "rate", "years"]
    },
    function=calculate_mortgage
)