Tools & Utilities

from swarms.tools import BaseTool

tool_manager = BaseTool(
    verbose=True,
    tools=[my_function],
    base_models=[MyModel]
)

schema = tool.func_to_dict(my_function)

schema = tool.base_model_to_dict(MyModel, output_str=False)

result = tool.execute_tool('{"name": "my_function", "parameters": {...}}')

tool.convert_funcs_into_tools()

result = tool.execute_tool_by_name("add", '{"a": 1, "b": 2}')

from swarms.tools import tool

@tool(name="calculator", description="Perform arithmetic operations")
def calculate(a: int, b: int, operation: str) -> int:
    """Calculate result of operation on two numbers."""
    if operation == "add":
        return a + b
    elif operation == "multiply":
        return a * b

from swarms.tools import get_openai_function_schema_from_func

def add(a: int, b: int) -> int:
    """Add two numbers together."""
    return a + b

schema = get_openai_function_schema_from_func(
    add,
    name="add_numbers",
    description="Add two integers"
)

from swarms.tools import base_model_to_openai_function
from pydantic import BaseModel

class UserInput(BaseModel):
    name: str
    age: int

schema = base_model_to_openai_function(UserInput)

from swarms.tools import scrape_tool_func_docs

docs = scrape_tool_func_docs(my_function)

from swarms.tools import tool_find_by_name

tool = tool_find_by_name("calculator", tools_list)

from swarms.tools import get_mcp_tools_sync

tools = get_mcp_tools_sync(server_config)

from swarms.tools import aget_mcp_tools

tools = await aget_mcp_tools(server_config)

from swarms.tools import execute_tool_call_simple

result = execute_tool_call_simple(
    tool_name="my_tool",
    parameters={"arg1": "value1"}
)

from swarms.tools import get_tools_for_multiple_mcp_servers

all_tools = get_tools_for_multiple_mcp_servers(
    servers=[server1_config, server2_config]
)

from swarms.tools import BaseTool, tool
from pydantic import BaseModel

# Define a Pydantic model
class MathInput(BaseModel):
    a: int
    b: int
    operation: str

# Define a function with type hints and docstring
def calculate(a: int, b: int, operation: str) -> int:
    """Perform arithmetic operations on two numbers.
    
    Args:
        a: First number
        b: Second number
        operation: Operation to perform (add, subtract, multiply, divide)
    
    Returns:
        Result of the operation
    """
    if operation == "add":
        return a + b
    elif operation == "subtract":
        return a - b
    elif operation == "multiply":
        return a * b
    elif operation == "divide":
        return a // b
    else:
        raise ValueError(f"Unknown operation: {operation}")

# Create tool manager
tool_manager = BaseTool(
    verbose=True,
    tools=[calculate],
    base_models=[MathInput]
)

# Convert tools to OpenAI schema
tool_manager.convert_funcs_into_tools()

# Execute a tool
result = tool_manager.execute_tool_by_name(
    "calculate",
    '{"a": 10, "b": 5, "operation": "multiply"}'
)
print(result)  # 50