`fastmcp.server.server`

FastMCP - A more ergonomic interface for MCP servers.

Functions

`default_lifespan`

default_lifespan(server: FastMCP[LifespanResultT]) -> AsyncIterator[Any]

Default lifespan context manager that does nothing. Args:

server: The server instance this lifespan is managing

Returns:

An empty dictionary as the lifespan result.

`create_proxy`

create_proxy(target: Client[ClientTransportT] | ClientTransport | FastMCP[Any] | FastMCP1Server | AnyUrl | Path | MCPConfig | dict[str, Any] | str, **settings: Any) -> FastMCPProxy

Create a FastMCP proxy server for the given target. This is the recommended way to create a proxy server. For lower-level control, use FastMCPProxy or ProxyProvider directly from fastmcp.server.providers.proxy. Args:

target: The backend to proxy to. Can be:
A Client instance (connected or disconnected)
A ClientTransport
A FastMCP server instance
A URL string or AnyUrl
A Path to a server script
An MCPConfig or dict
**settings: Additional settings passed to FastMCPProxy (name, etc.)

Returns:

A FastMCPProxy server that proxies to the target.

Classes

`FastMCP`

Methods:

`settings`

settings(self) -> Settings

`name`

name(self) -> str

`instructions`

instructions(self) -> str | None

`instructions`

instructions(self, value: str | None) -> None

`version`

version(self) -> str | None

`website_url`

website_url(self) -> str | None

`icons`

icons(self) -> list[mcp.types.Icon]

`docket`

docket(self) -> Docket | None

Get the Docket instance if Docket support is enabled. Returns None if Docket is not enabled or server hasn’t been started yet.

`run_async`

run_async(self, transport: Transport | None = None, show_banner: bool | None = None, **transport_kwargs: Any) -> None

Run the FastMCP server asynchronously. Args:

transport: Transport protocol to use (“stdio”, “sse”, or “streamable-http”)
show_banner: Whether to display the server banner. If None, uses the FASTMCP_SHOW_SERVER_BANNER setting (default: True).

`run`

run(self, transport: Transport | None = None, show_banner: bool | None = None, **transport_kwargs: Any) -> None

Run the FastMCP server. Note this is a synchronous function. Args:

transport: Transport protocol to use (“http”, “stdio”, “sse”, or “streamable-http”)
show_banner: Whether to display the server banner. If None, uses the FASTMCP_SHOW_SERVER_BANNER setting (default: True).

`add_middleware`

add_middleware(self, middleware: Middleware) -> None

`add_provider`

add_provider(self, provider: Provider) -> None

Add a provider for dynamic tools, resources, and prompts. Providers are queried in registration order. The first provider to return a non-None result wins. Static components (registered via decorators) always take precedence over providers. Args:

provider: A Provider instance that will provide components dynamically.

`enable`

enable(self) -> None

Enable components by removing from blocklist, or set allowlist with only=True. Args:

keys: Keys to enable (e.g., "tool\:my_tool").
tags: Tags to enable - components with these tags will be enabled.
only: If True, switches to allowlist mode - ONLY show these keys/tags. This clears existing allowlists and sets default visibility to False.

`disable`

disable(self) -> None

Disable components by adding to the blocklist. Args:

keys: Keys to disable (e.g., "tool\:my_tool").
tags: Tags to disable - components with these tags will be disabled.

`get_tools`

get_tools(self) -> list[Tool]

Get all enabled tools from providers. Queries all providers in parallel and collects tools. First provider wins for duplicate keys. Filters by server blocklist. Args:

run_middleware: If True, apply the middleware chain before returning results. Used by MCP handlers and mounted servers.

`get_tool`

get_tool(self, name: str) -> Tool

Get an enabled tool by name. Queries all providers in parallel to find the tool. First provider wins. Returns only if enabled.

`get_resources`

get_resources(self) -> list[Resource]

Get all enabled resources from providers. Queries all providers in parallel and collects resources. First provider wins for duplicate keys. Filters by server blocklist. Args:

run_middleware: If True, apply the middleware chain before returning results. Used by MCP handlers and mounted servers.

`get_resource`

get_resource(self, uri: str) -> Resource

Get an enabled resource by URI. Queries all providers in parallel to find the resource. First provider wins. Returns only if enabled.

`get_resource_templates`

get_resource_templates(self) -> list[ResourceTemplate]

Get all enabled resource templates from providers. Queries all providers in parallel and collects templates. First provider wins for duplicate keys. Filters by server blocklist. Args:

run_middleware: If True, apply the middleware chain before returning results. Used by MCP handlers and mounted servers.

`get_resource_template`

get_resource_template(self, uri: str) -> ResourceTemplate

Get an enabled resource template that matches the given URI. Queries all providers in parallel to find the template. First provider wins. Returns only if enabled.

`get_prompts`

get_prompts(self) -> list[Prompt]

Get all enabled prompts from providers. Queries all providers in parallel and collects prompts. First provider wins for duplicate keys. Filters by server blocklist. Args:

run_middleware: If True, apply the middleware chain before returning results. Used by MCP handlers and mounted servers.

`get_prompt`

get_prompt(self, name: str) -> Prompt

Get an enabled prompt by name. Queries all providers in parallel to find the prompt. First provider wins. Returns only if enabled.

`get_component`

get_component(self, key: str) -> Tool | Resource | ResourceTemplate | Prompt

Get a component by its prefixed key. Queries all providers in parallel to find the component. First provider wins. Args:

key: The prefixed key (e.g., “tool:name”, “resource:uri”, “template:uri”).

Returns:

The component if found.

Raises:

NotFoundError: If no component is found with the given key.

`call_tool`

call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> ToolResult

`call_tool`

call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> mcp.types.CreateTaskResult

`call_tool`

call_tool(self, name: str, arguments: dict[str, Any] | None = None) -> ToolResult | mcp.types.CreateTaskResult

Call a tool by name. This is the public API for executing tools. By default, middleware is applied. Args:

name: The tool name
arguments: Tool arguments (optional)
run_middleware: If True (default), apply the middleware chain. Set to False when called from middleware to avoid re-applying.
task_meta: If provided, execute as a background task and return CreateTaskResult. If None (default), execute synchronously and return ToolResult.

Returns:

ToolResult when task_meta is None.
CreateTaskResult when task_meta is provided.

Raises:

NotFoundError: If tool not found or disabled
ToolError: If tool execution fails
ValidationError: If arguments fail validation

`read_resource`

read_resource(self, uri: str) -> ResourceResult

`read_resource`

read_resource(self, uri: str) -> mcp.types.CreateTaskResult

`read_resource`

read_resource(self, uri: str) -> ResourceResult | mcp.types.CreateTaskResult

Read a resource by URI. This is the public API for reading resources. By default, middleware is applied. Checks concrete resources first, then templates. Args:

uri: The resource URI
run_middleware: If True (default), apply the middleware chain. Set to False when called from middleware to avoid re-applying.
task_meta: If provided, execute as a background task and return CreateTaskResult. If None (default), execute synchronously and return ResourceResult.

Returns:

ResourceResult when task_meta is None.
CreateTaskResult when task_meta is provided.

Raises:

NotFoundError: If resource not found or disabled
ResourceError: If resource read fails

`render_prompt`

render_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> PromptResult

`render_prompt`

render_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> mcp.types.CreateTaskResult

`render_prompt`

render_prompt(self, name: str, arguments: dict[str, Any] | None = None) -> PromptResult | mcp.types.CreateTaskResult

Render a prompt by name. This is the public API for rendering prompts. By default, middleware is applied. Use get_prompt() to retrieve the prompt definition without rendering. Args:

name: The prompt name
arguments: Prompt arguments (optional)
run_middleware: If True (default), apply the middleware chain. Set to False when called from middleware to avoid re-applying.
task_meta: If provided, execute as a background task and return CreateTaskResult. If None (default), execute synchronously and return PromptResult.

Returns:

PromptResult when task_meta is None.
CreateTaskResult when task_meta is provided.

Raises:

NotFoundError: If prompt not found or disabled
PromptError: If prompt rendering fails

`custom_route`

custom_route(self, path: str, methods: list[str], name: str | None = None, include_in_schema: bool = True) -> Callable[[Callable[[Request], Awaitable[Response]]], Callable[[Request], Awaitable[Response]]]

Decorator to register a custom HTTP route on the FastMCP server. Allows adding arbitrary HTTP endpoints outside the standard MCP protocol, which can be useful for OAuth callbacks, health checks, or admin APIs. The handler function must be an async function that accepts a Starlette Request and returns a Response. Args:

path: URL path for the route (e.g., “/auth/callback”)
methods: List of HTTP methods to support (e.g., [“GET”, “POST”])
name: Optional name for the route (to reference this route with Starlette’s reverse URL lookup feature)
include_in_schema: Whether to include in OpenAPI schema, defaults to True

`add_tool`

add_tool(self, tool: Tool) -> Tool

Add a tool to the server. The tool function can optionally request a Context object by adding a parameter with the Context type annotation. See the @tool decorator for examples. Args:

tool: The Tool instance to register

Returns:

The tool instance that was added to the server.

`remove_tool`

remove_tool(self, name: str) -> None

Remove a tool from the server. Args:

name: The name of the tool to remove

Raises:

NotFoundError: If the tool is not found

`add_tool_transformation`

add_tool_transformation(self, tool_name: str, transformation: ToolTransformConfig) -> None

Add a tool transformation.

`remove_tool_transformation`

remove_tool_transformation(self, tool_name: str) -> None

Remove a tool transformation.

`tool`

tool(self, name_or_fn: AnyFunction) -> FunctionTool

`tool`

tool(self, name_or_fn: str | None = None) -> Callable[[AnyFunction], FunctionTool]

`tool`

tool(self, name_or_fn: str | AnyFunction | None = None) -> Callable[[AnyFunction], FunctionTool] | FunctionTool | partial[Callable[[AnyFunction], FunctionTool] | FunctionTool]

Decorator to register a tool. Tools can optionally request a Context object by adding a parameter with the Context type annotation. The context provides access to MCP capabilities like logging, progress reporting, and resource access. This decorator supports multiple calling patterns:

@server.tool (without parentheses)
@server.tool (with empty parentheses)
@server.tool(“custom_name”) (with name as first argument)
@server.tool(name=“custom_name”) (with name as keyword argument)
server.tool(function, name=“custom_name”) (direct function call)

Args:

name_or_fn: Either a function (when used as @tool), a string name, or None
name: Optional name for the tool (keyword-only, alternative to name_or_fn)
description: Optional description of what the tool does
tags: Optional set of tags for categorizing the tool
output_schema: Optional JSON schema for the tool’s output
annotations: Optional annotations about the tool’s behavior
exclude_args: Optional list of argument names to exclude from the tool schema. Deprecated: Use Depends() for dependency injection instead.
meta: Optional meta information about the tool

Examples: Register a tool with a custom name:

@server.tool
def my_tool(x: int) -> str:
    return str(x)

# Register a tool with a custom name
@server.tool
def my_tool(x: int) -> str:
    return str(x)

@server.tool("custom_name")
def my_tool(x: int) -> str:
    return str(x)

@server.tool(name="custom_name")
def my_tool(x: int) -> str:
    return str(x)

# Direct function call
server.tool(my_function, name="custom_name")

`add_resource`

add_resource(self, resource: Resource) -> Resource

Add a resource to the server. Args:

resource: A Resource instance to add

Returns:

The resource instance that was added to the server.

`add_template`

add_template(self, template: ResourceTemplate) -> ResourceTemplate

Add a resource template to the server. Args:

template: A ResourceTemplate instance to add

Returns:

The template instance that was added to the server.

`resource`

resource(self, uri: str) -> Callable[[AnyFunction], Resource | ResourceTemplate]

Decorator to register a function as a resource. The function will be called when the resource is read to generate its content. The function can return:

str for text content
bytes for binary content
other types will be converted to JSON

Resources can optionally request a Context object by adding a parameter with the Context type annotation. The context provides access to MCP capabilities like logging, progress reporting, and session information. If the URI contains parameters (e.g. “resource://”) or the function has parameters, it will be registered as a template resource. Args:

uri: URI for the resource (e.g. “resource://my-resource” or “resource://”)
name: Optional name for the resource
description: Optional description of the resource
mime_type: Optional MIME type for the resource
tags: Optional set of tags for categorizing the resource
annotations: Optional annotations about the resource’s behavior
meta: Optional meta information about the resource

Examples: Register a resource with a custom name:

@server.resource("resource://my-resource")
def get_data() -> str:
    return "Hello, world!"

@server.resource("resource://my-resource")
async get_data() -> str:
    data = await fetch_data()
    return f"Hello, world! {data}"

@server.resource("resource://{city}/weather")
def get_weather(city: str) -> str:
    return f"Weather for {city}"

@server.resource("resource://{city}/weather")
async def get_weather_with_context(city: str, ctx: Context) -> str:
    await ctx.info(f"Fetching weather for {city}")
    return f"Weather for {city}"

@server.resource("resource://{city}/weather")
async def get_weather(city: str) -> str:
    data = await fetch_weather(city)
    return f"Weather for {city}: {data}"

`add_prompt`

add_prompt(self, prompt: Prompt) -> Prompt

Add a prompt to the server. Args:

prompt: A Prompt instance to add

Returns:

The prompt instance that was added to the server.

`prompt`

prompt(self, name_or_fn: AnyFunction) -> FunctionPrompt

`prompt`

prompt(self, name_or_fn: str | None = None) -> Callable[[AnyFunction], FunctionPrompt]

`prompt`

prompt(self, name_or_fn: str | AnyFunction | None = None) -> Callable[[AnyFunction], FunctionPrompt] | FunctionPrompt | partial[Callable[[AnyFunction], FunctionPrompt] | FunctionPrompt]

Decorator to register a prompt. Prompts can optionally request a Context object by adding a parameter with the Context type annotation. The context provides access to MCP capabilities like logging, progress reporting, and session information. This decorator supports multiple calling patterns:

@server.prompt (without parentheses)
@server.prompt() (with empty parentheses)
@server.prompt(“custom_name”) (with name as first argument)
@server.prompt(name=“custom_name”) (with name as keyword argument)
server.prompt(function, name=“custom_name”) (direct function call)

Args: name_or_fn: Either a function (when used as @prompt), a string name, or None name: Optional name for the prompt (keyword-only, alternative to name_or_fn) description: Optional description of what the prompt does tags: Optional set of tags for categorizing the prompt meta: Optional meta information about the prompt Examples:

@server.prompt
def analyze_table(table_name: str) -> list[Message]:
    schema = read_table_schema(table_name)
    return [
        {
            "role": "user",
            "content": f"Analyze this schema:
{schema}"
        }
    ]

@server.prompt()
async def analyze_with_context(table_name: str, ctx: Context) -> list[Message]:
    await ctx.info(f"Analyzing table {table_name}")
    schema = read_table_schema(table_name)
    return [
        {
            "role": "user",
            "content": f"Analyze this schema:
{schema}"
        }
    ]

@server.prompt("custom_name")
async def analyze_file(path: str) -> list[Message]:
    content = await read_file(path)
    return [
        {
            "role": "user",
            "content": {
                "type": "resource",
                "resource": {
                    "uri": f"file://{path}",
                    "text": content
                }
            }
        }
    ]

@server.prompt(name="custom_name")
def another_prompt(data: str) -> list[Message]:
    return [{"role": "user", "content": data}]

# Direct function call
server.prompt(my_function, name="custom_name")

`run_stdio_async`

run_stdio_async(self, show_banner: bool = True, log_level: str | None = None, stateless: bool = False) -> None

Run the server using stdio transport. Args:

show_banner: Whether to display the server banner
log_level: Log level for the server
stateless: Whether to run in stateless mode (no session initialization)

`run_http_async`

run_http_async(self, show_banner: bool = True, transport: Literal['http', 'streamable-http', 'sse'] = 'http', host: str | None = None, port: int | None = None, log_level: str | None = None, path: str | None = None, uvicorn_config: dict[str, Any] | None = None, middleware: list[ASGIMiddleware] | None = None, json_response: bool | None = None, stateless_http: bool | None = None, stateless: bool | None = None) -> None

Run the server using HTTP transport. Args:

transport: Transport protocol to use - either “streamable-http” (default) or “sse”
host: Host address to bind to (defaults to settings.host)
port: Port to bind to (defaults to settings.port)
log_level: Log level for the server (defaults to settings.log_level)
path: Path for the endpoint (defaults to settings.streamable_http_path or settings.sse_path)
uvicorn_config: Additional configuration for the Uvicorn server
middleware: A list of middleware to apply to the app
json_response: Whether to use JSON response format (defaults to settings.json_response)
stateless_http: Whether to use stateless HTTP (defaults to settings.stateless_http)
stateless: Alias for stateless_http for CLI consistency

`http_app`

http_app(self, path: str | None = None, middleware: list[ASGIMiddleware] | None = None, json_response: bool | None = None, stateless_http: bool | None = None, transport: Literal['http', 'streamable-http', 'sse'] = 'http', event_store: EventStore | None = None, retry_interval: int | None = None) -> StarletteWithLifespan

Create a Starlette app using the specified HTTP transport. Args:

path: The path for the HTTP endpoint
middleware: A list of middleware to apply to the app
json_response: Whether to use JSON response format
stateless_http: Whether to use stateless mode (new transport per request)
transport: Transport protocol to use - “http”, “streamable-http”, or “sse”
event_store: Optional event store for SSE polling/resumability. When set, enables clients to reconnect and resume receiving events after server-initiated disconnections. Only used with streamable-http transport.
retry_interval: Optional retry interval in milliseconds for SSE polling. Controls how quickly clients should reconnect after server-initiated disconnections. Requires event_store to be set. Only used with streamable-http transport.

Returns:

A Starlette application configured with the specified transport

`mount`

mount(self, server: FastMCP[LifespanResultT], namespace: str | None = None, as_proxy: bool | None = None, tool_names: dict[str, str] | None = None, prefix: str | None = None) -> None

Mount another FastMCP server on this server with an optional namespace. Unlike importing (with import_server), mounting establishes a dynamic connection between servers. When a client interacts with a mounted server’s objects through the parent server, requests are forwarded to the mounted server in real-time. This means changes to the mounted server are immediately reflected when accessed through the parent. When a server is mounted with a namespace:

Tools from the mounted server are accessible with namespaced names. Example: If server has a tool named “get_weather”, it will be available as “namespace_get_weather”.
Resources are accessible with namespaced URIs. Example: If server has a resource with URI “weather://forecast”, it will be available as “weather://namespace/forecast”.
Templates are accessible with namespaced URI templates. Example: If server has a template with URI “weather://location/”, it will be available as “weather://namespace/location/”.
Prompts are accessible with namespaced names. Example: If server has a prompt named “weather_prompt”, it will be available as “namespace_weather_prompt”.

When a server is mounted without a namespace (namespace=None), its tools, resources, templates, and prompts are accessible with their original names. Multiple servers can be mounted without namespaces, and they will be tried in order until a match is found. The mounted server’s lifespan is executed when the parent server starts, and its middleware chain is invoked for all operations (tool calls, resource reads, prompts). Args:

server: The FastMCP server to mount.
namespace: Optional namespace to use for the mounted server’s objects. If None, the server’s objects are accessible with their original names.
as_proxy: Deprecated. Mounted servers now always have their lifespan and middleware invoked. To create a proxy server, use create_proxy() explicitly before mounting.
tool_names: Optional mapping of original tool names to custom names. Use this to override namespaced names. Keys are the original tool names from the mounted server.
prefix: Deprecated. Use namespace instead.

`import_server`

import_server(self, server: FastMCP[LifespanResultT], prefix: str | None = None) -> None

Import the MCP objects from another FastMCP server into this one, optionally with a given prefix. .. deprecated:: Use :meth:mount instead. import_server will be removed in a future version. Note that when a server is imported, its objects are immediately registered to the importing server. This is a one-time operation and future changes to the imported server will not be reflected in the importing server. Server-level configurations and lifespans are not imported. When a server is imported with a prefix:

The tools are imported with prefixed names Example: If server has a tool named “get_weather”, it will be available as “prefix_get_weather”
The resources are imported with prefixed URIs using the new format Example: If server has a resource with URI “weather://forecast”, it will be available as “weather://prefix/forecast”
The templates are imported with prefixed URI templates using the new format Example: If server has a template with URI “weather://location/”, it will be available as “weather://prefix/location/”
The prompts are imported with prefixed names Example: If server has a prompt named “weather_prompt”, it will be available as “prefix_weather_prompt”

When a server is imported without a prefix (prefix=None), its tools, resources, templates, and prompts are imported with their original names. Args:

server: The FastMCP server to import
prefix: Optional prefix to use for the imported server’s objects. If None, objects are imported with their original names.

`from_openapi`

from_openapi(cls, openapi_spec: dict[str, Any], client: httpx.AsyncClient, name: str = 'OpenAPI Server', route_maps: list[RouteMap] | None = None, route_map_fn: OpenAPIRouteMapFn | None = None, mcp_component_fn: OpenAPIComponentFn | None = None, mcp_names: dict[str, str] | None = None, tags: set[str] | None = None, timeout: float | None = None, **settings: Any) -> Self

Create a FastMCP server from an OpenAPI specification. Args:

openapi_spec: OpenAPI schema as a dictionary
client: httpx AsyncClient for making HTTP requests
name: Name for the MCP server
route_maps: Optional list of RouteMap objects defining route mappings
route_map_fn: Optional callable for advanced route type mapping
mcp_component_fn: Optional callable for component customization
mcp_names: Optional dictionary mapping operationId to component names
tags: Optional set of tags to add to all components
timeout: Optional timeout (in seconds) for all requests
**settings: Additional settings passed to FastMCP

Returns:

A FastMCP server with an OpenAPIProvider attached.

`from_fastapi`

from_fastapi(cls, app: Any, name: str | None = None, route_maps: list[RouteMap] | None = None, route_map_fn: OpenAPIRouteMapFn | None = None, mcp_component_fn: OpenAPIComponentFn | None = None, mcp_names: dict[str, str] | None = None, httpx_client_kwargs: dict[str, Any] | None = None, tags: set[str] | None = None, timeout: float | None = None, **settings: Any) -> Self

Create a FastMCP server from a FastAPI application. Args:

app: FastAPI application instance
name: Name for the MCP server (defaults to app.title)
route_maps: Optional list of RouteMap objects defining route mappings
route_map_fn: Optional callable for advanced route type mapping
mcp_component_fn: Optional callable for component customization
mcp_names: Optional dictionary mapping operationId to component names
httpx_client_kwargs: Optional kwargs passed to httpx.AsyncClient
tags: Optional set of tags to add to all components
timeout: Optional timeout (in seconds) for all requests
**settings: Additional settings passed to FastMCP

Returns:

A FastMCP server with an OpenAPIProvider attached.

`as_proxy`

as_proxy(cls, backend: Client[ClientTransportT] | ClientTransport | FastMCP[Any] | FastMCP1Server | AnyUrl | Path | MCPConfig | dict[str, Any] | str, **settings: Any) -> FastMCPProxy

Create a FastMCP proxy server for the given backend. .. deprecated:: Use :func:fastmcp.server.create_proxy instead. This method will be removed in a future version. The backend argument can be either an existing fastmcp.client.Client instance or any value accepted as the transport argument of fastmcp.client.Client. This mirrors the convenience of the fastmcp.client.Client constructor.

`generate_name`

generate_name(cls, name: str | None = None) -> str

fastmcp.cli

fastmcp.client

fastmcp.prompts

fastmcp.resources

fastmcp.server

fastmcp.tools

fastmcp.utilities

​fastmcp.server.server

​Functions

​default_lifespan

​create_proxy

​Classes

​FastMCP

​settings

​name

​instructions

​instructions

​version

​website_url

​icons

​docket

​run_async

​run

​add_middleware

​add_provider

​enable

​disable

​get_tools

​get_tool

​get_resources

​get_resource

​get_resource_templates

​get_resource_template

​get_prompts

​get_prompt

​get_component

​call_tool

​call_tool

​call_tool

​read_resource

​read_resource

​read_resource

​render_prompt

​render_prompt

​render_prompt

​custom_route

​add_tool

​remove_tool

​add_tool_transformation

​remove_tool_transformation

​tool

​tool

​tool

​add_resource

​add_template

​resource

​add_prompt

​prompt

​prompt

​prompt

​run_stdio_async

​run_http_async

​http_app

​mount

​import_server

​from_openapi

​from_fastapi

​as_proxy

​generate_name

`fastmcp.server.server`

Functions

`default_lifespan`

`create_proxy`

Classes

`FastMCP`

`settings`

`name`

`instructions`

`instructions`

`version`

`website_url`

`icons`

`docket`

`run_async`

`run`

`add_middleware`

`add_provider`

`enable`

`disable`

`get_tools`

`get_tool`

`get_resources`

`get_resource`

`get_resource_templates`

`get_resource_template`

`get_prompts`

`get_prompt`

`get_component`

`call_tool`

`call_tool`

`call_tool`

`read_resource`

`read_resource`

`read_resource`

`render_prompt`

`render_prompt`

`render_prompt`

`custom_route`

`add_tool`

`remove_tool`

`add_tool_transformation`

`remove_tool_transformation`

`tool`

`tool`

`tool`

`add_resource`

`add_template`

`resource`

`add_prompt`

`prompt`

`prompt`

`prompt`

`run_stdio_async`

`run_http_async`

`http_app`

`mount`

`import_server`

`from_openapi`

`from_fastapi`

`as_proxy`

`generate_name`