Tools

from mcp_use.server import MCPServer

server = MCPServer(name="My Server")

@server.tool()
def greet(name: str) -> str:
    """Greet someone by name."""
    return f"Hello, {name}!"

from mcp.types import ToolAnnotations

@server.tool(
    name="custom_name",           # Override the function name
    title="Custom Title",         # Human-readable title
    description="Custom desc",    # Override the docstring
    annotations=ToolAnnotations(  # MCP tool annotations
        destructiveHint=True,     # Tool may modify data
        readOnlyHint=False,       # Tool is not read-only
    ),
)
def my_tool(param: str) -> str:
    return param

import httpx

@server.tool()
async def fetch_url(url: str) -> str:
    """Fetch content from a URL."""
    async with httpx.AsyncClient() as client:
        response = await client.get(url)
        return response.text

from mcp.server.fastmcp import Context

@server.tool()
async def long_task(items: list[str], context: Context) -> str:
    """Process items with progress reporting."""
    results = []
    for i, item in enumerate(items):
        # Report progress
        await context.report_progress(i, len(items))
        results.append(f"Processed: {item}")
    return "\n".join(results)

from pydantic import BaseModel

class SearchQuery(BaseModel):
    query: str
    max_results: int = 10
    include_metadata: bool = False

@server.tool()
def search(params: SearchQuery) -> list[str]:
    """Search with complex parameters."""
    # params.query, params.max_results, etc.
    return ["result1", "result2"]

# String
@server.tool()
def text_tool() -> str:
    return "Hello"

# Dict (serialized to JSON)
@server.tool()
def json_tool() -> dict:
    return {"key": "value", "count": 42}

# List
@server.tool()
def list_tool() -> list[str]:
    return ["a", "b", "c"]

@server.tool()
def divide(a: float, b: float) -> float:
    """Divide two numbers."""
    if b == 0:
        raise ValueError("Cannot divide by zero")
    return a / b

from datetime import datetime
from mcp.server.fastmcp import Context
from mcp.types import ToolAnnotations
from mcp_use.server import MCPServer

server = MCPServer(name="Calculator Server", version="1.0.0")

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

@server.tool(
    name="divide",
    annotations=ToolAnnotations(readOnlyHint=True)
)
def safe_divide(a: float, b: float) -> float:
    """Safely divide two numbers."""
    if b == 0:
        raise ValueError("Division by zero")
    return a / b

@server.tool()
async def batch_calculate(
    operations: list[dict],
    context: Context
) -> list[float]:
    """Perform multiple calculations with progress."""
    results = []
    for i, op in enumerate(operations):
        await context.report_progress(i, len(operations))
        if op["type"] == "add":
            results.append(op["a"] + op["b"])
        elif op["type"] == "multiply":
            results.append(op["a"] * op["b"])
    return results

if __name__ == "__main__":
    server.run(transport="streamable-http", debug=True)