FastMCP

The fastmcp CLI is the primary interface for running, testing, installing, and interacting with MCP servers. It is installed automatically with FastMCP.

Core Commands

fastmcp --help

The FastMCP CLI provides several commands to manage the lifecycle of MCP servers.

Moving from the low-level SDK to FastMCP provides several architectural advantages:

• Server Composition: Mount one server inside another to split large, unwieldy dispatch chains into independent, testable modules.
• Middleware: Implement cross-cutting concerns like logging, rate limiting, error handling, and caching across all requests using hooks.
• Proxy Servers: Place a FastMCP server in front of existing MCP servers to bridge transports or add authentication.
• OpenAPI Integration: Automatically generate a server from an existing API specification.
• Unified Authentication: Consolidate token verification and authorization into a single auth= provider (supporting GitHub, Google, Auth0, Keycloak, etc.).
• Simplified Testing: Use the built-in FastMCP client to connect to a server object within the same Python process, eliminating the need for subprocesses or stdio pipes.

FastMCP implements background task support via the io.modelcontextprotocol/tasks extension (SEP-2663). This allows servers to execute long-running operations as tasks rather than standard synchronous tool calls.

Key characteristics of the FastMCP implementation:

• Execution Engine: Uses Docket (a queue, worker, and result store) with memory:// or redis:// backends for durability.
• Task Identification: Task IDs are server-generated.
• Polling Model: Clients retrieve results by polling tasks/get until a terminal status is reached. The result is inlined in the response.
• In-task Input: If a task requires user input during execution, the status changes to input_required. The client provides answers via tasks/update.
• Zero-Code Migration: Servers already using the @mcp.tool(task=True) decorator in FastMCP 3 require no code changes to move to the v4 implementation.

Note: Background task support is provided by the optional fastmcp-tasks package and is gated by the task=True parameter.

# Example of how a tool is marked as a task
@mcp.tool(task=True)
def long_running_operation(param: str):
    ...

The Context object provides a clean interface to interact with the underlying MCP session and access advanced server capabilities during the execution of tools, resources, or prompts.

Capabilities provided by Context:

• Logging: Send debug, info, warning, and error messages to the client.
• Progress Reporting: Update the client on the status of long-running operations.
• Resource & Prompt Access: List and read data from resources or prompts registered with the server.
• LLM Sampling: Request the client's LLM to generate text.
• User Elicitation: Request structured input from users during execution.
• Session Management: Access session state, visibility controls, and request metadata.
• Server Access: Access the underlying FastMCP server instance.

Important Lifecycle Rules:

• Request Scoped: Each MCP request receives a new context object. State set in one request is not available in subsequent requests.
• Async Required: Context methods are asynchronous, so your tool/resource/prompt functions should generally be async.
• Request-Only: Context is only available during an active request; using it outside a request will raise errors.

from fastmcp import FastMCP
from fastmcp.dependencies import CurrentContext
from fastmcp.server.context import Context

mcp = FastMCP(name="Context Demo")

@mcp.tool
async def process_file(file_uri: str, ctx: Context = CurrentContext()) -> str:
    """Processes a file, using context for logging and resource access.""
    await ctx.info(f"Processing {file_uri}")
    return "Processed file"

The Context object in FastMCP provides an interface to access advanced Model Context Protocol (MCP) features within your tools, resources, and prompts. It allows your functions to interact with the underlying MCP session and perform server-side operations.

Key Capabilities:

• Logging: Send debug, info, warning, and error messages to the client.
• Progress Reporting: Update the client on the status of long-running operations.
• Resource & Prompt Access: List and read data from registered resources or prompts.
• User Elicitation: Request structured input from users during execution.
• Request State: Pass non-serializable resources or values between middleware and handlers within a single request using ctx.set_state().
• Session Visibility: Control which components are visible to the current session.
• Request Information: Access metadata about the current request.
• Server Access: Access the underlying FastMCP server instance when required.