fastmcp_provider

fastmcp.server.providers.fastmcp_provider

FastMCPProvider for wrapping FastMCP servers as providers.

This module provides the FastMCPProvider class that wraps a FastMCP server and exposes its components through the Provider interface.

It also provides FastMCPProvider* component classes that delegate execution to the wrapped server’s middleware, ensuring middleware runs when components are executed.

Classes

FastMCPProviderTool

Tool that delegates execution to a wrapped server’s middleware.

When run() is called, this tool invokes the wrapped server’s _call_tool_middleware() method, ensuring the server’s middleware chain is executed.

Methods:

wrap

wrap(cls, server: Any, tool: Tool) -> FastMCPProviderTool

Wrap a Tool to delegate execution to the server’s middleware.

run

run(self, arguments: dict[str, Any]) -> ToolResult | mcp.types.CreateTaskResult

Not implemented - use _run() which delegates to child server.

FastMCPProviderTool._run() handles all execution by delegating to the child server’s call_tool() with task_meta.

FastMCPProviderResource

Resource that delegates reading to a wrapped server’s read_resource().

When read() is called, this resource invokes the wrapped server’s read_resource() method, ensuring the server’s middleware chain is executed.

Methods:

wrap

wrap(cls, server: Any, resource: Resource) -> FastMCPProviderResource

Wrap a Resource to delegate reading to the server’s middleware.

FastMCPProviderPrompt

Prompt that delegates rendering to a wrapped server’s render_prompt().

When render() is called, this prompt invokes the wrapped server’s render_prompt() method, ensuring the server’s middleware chain is executed.

Methods:

wrap

wrap(cls, server: Any, prompt: Prompt) -> FastMCPProviderPrompt

Wrap a Prompt to delegate rendering to the server’s middleware.

render

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

Not implemented - use _render() which delegates to child server.

FastMCPProviderPrompt._render() handles all execution by delegating to the child server’s render_prompt() with task_meta.

FastMCPProviderResourceTemplate

Resource template that creates FastMCPProviderResources.

When create_resource() is called, this template creates a FastMCPProviderResource that will invoke the wrapped server’s middleware when read.

Methods:

wrap

wrap(cls, server: Any, template: ResourceTemplate) -> FastMCPProviderResourceTemplate

Wrap a ResourceTemplate to create FastMCPProviderResources.

create_resource

create_resource(self, uri: str, params: dict[str, Any]) -> Resource

Create a FastMCPProviderResource for the given URI.

The uri is the external/transformed URI (e.g., with namespace prefix). We use _original_uri_template with params to construct the internal URI that the nested server understands.

read

read(self, arguments: dict[str, Any]) -> str | bytes | ResourceResult

Read the resource content for background task execution.

Reads the resource via the wrapped server and returns the ResourceResult. This method is called by Docket during background task execution.

register_with_docket

register_with_docket(self, docket: Docket) -> None

No-op: the child’s actual template is registered via get_tasks().

add_to_docket

add_to_docket(self, docket: Docket, params: dict[str, Any], **kwargs: Any) -> Execution

Schedule this template for background execution via docket.

The child’s FunctionResourceTemplate.fn is registered (via get_tasks), and it expects splatted **kwargs, so we splat params here.

FastMCPProvider

Provider that wraps a FastMCP server.

This provider enables mounting one FastMCP server onto another, exposing the mounted server’s tools, resources, and prompts through the parent server.

Components returned by this provider are wrapped in FastMCPProvider* classes that delegate execution to the wrapped server’s middleware chain. This ensures middleware runs when components are executed.

Methods:

list_tools

list_tools(self) -> Sequence[Tool]

List all tools from the mounted server as FastMCPProviderTools.

Calls the nested server’s middleware to list tools, then wraps each tool as a FastMCPProviderTool that delegates execution to the nested server’s middleware.

get_tool

get_tool(self, name: str) -> Tool | None

Get a tool by name as a FastMCPProviderTool.

list_resources

list_resources(self) -> Sequence[Resource]

List all resources from the mounted server as FastMCPProviderResources.

Calls the nested server’s middleware to list resources, then wraps each resource as a FastMCPProviderResource that delegates reading to the nested server’s middleware.

get_resource

get_resource(self, uri: str) -> Resource | None

Get a concrete resource by URI as a FastMCPProviderResource.

list_resource_templates

list_resource_templates(self) -> Sequence[ResourceTemplate]

List all resource templates from the mounted server.

Returns FastMCPProviderResourceTemplate instances that create FastMCPProviderResources when materialized.

get_resource_template

get_resource_template(self, uri: str) -> ResourceTemplate | None

Get a resource template that matches the given URI.

list_prompts

list_prompts(self) -> Sequence[Prompt]

List all prompts from the mounted server as FastMCPProviderPrompts.

Returns FastMCPProviderPrompt instances that delegate rendering to the wrapped server’s middleware.

get_prompt

get_prompt(self, name: str) -> Prompt | None

Get a prompt by name as a FastMCPProviderPrompt.

get_tasks

get_tasks(self) -> Sequence[FastMCPComponent]

Return task-eligible components from the mounted server.

Returns the child’s ACTUAL components (not wrapped) so their actual functions get registered with Docket. TransformingProvider.get_tasks() handles namespace transformation of keys.

Iterates through all providers in the wrapped server (including its LocalProvider) to collect task-eligible components.

lifespan

lifespan(self) -> AsyncIterator[None]

Start the mounted server’s user lifespan.

This starts only the wrapped server’s user-defined lifespan, NOT its full _lifespan_manager() (which includes Docket). The parent server’s Docket handles all background tasks.