fastmcp

FastMCP abstracts the low-level JSON-RPC protocol details by providing a decorator-based interface (@tool, @resource, @prompt) that automatically generates MCP-compliant schemas, validates inputs against Pydantic models, and handles serialization. The framework introspects Python function signatures and type hints to produce OpenAPI-compatible schemas without manual schema definition, reducing boilerplate from hundreds of lines to single decorators.

FastMCP's Client class abstracts transport mechanisms (stdio, HTTP, WebSocket, SSE) behind a unified interface, allowing developers to connect to MCP servers regardless of underlying transport without changing application code. The client handles protocol negotiation, message routing, and connection lifecycle management transparently, supporting both synchronous and asynchronous operations through async/await patterns.

FastMCP provides CLI tools for running, testing, and managing MCP servers. The CLI supports server startup with configuration, environment variable management via uv, and development utilities for testing server capabilities. The framework integrates with Python's logging and provides telemetry/observability hooks for monitoring server behavior in production.

FastMCP provides configuration management through MCPServerConfig (single-server configuration) and MCPConfig (multi-server configuration). Configurations are defined via Python dataclasses or YAML/JSON files and support environment variable interpolation, transport settings, authentication credentials, and middleware options. The framework automatically loads and validates configurations at startup, enabling flexible deployment across development, staging, and production environments.

FastMCP includes an OpenAPI provider that automatically converts OpenAPI 3.0+ specifications into MCP tools. The provider parses OpenAPI specs, generates MCP tool schemas from endpoint definitions, and creates tool handlers that invoke the underlying REST APIs. This enables teams to expose existing REST APIs as MCP tools without manual tool definition, with automatic parameter validation and response serialization.

FastMCP provides event handlers and lifecycle hooks that allow developers to customize server behavior at key points (startup, shutdown, tool execution, error handling). Handlers are registered via decorators (@on_startup, @on_shutdown, @on_tool_call) and receive context about the event. This enables cross-cutting concerns like initialization, cleanup, logging, and error recovery without modifying core server logic.

FastMCP implements a Provider/Transform architecture where Providers generate tools, resources, and prompts dynamically (e.g., from OpenAPI specs, filesystem, or custom logic), and Transforms modify capabilities before exposure to clients. This pattern enables composable, reusable capability definitions without duplicating code; for example, an OpenAPI provider automatically converts REST endpoints to MCP tools, while a caching transform adds result memoization transparently.

FastMCP provides a context system (via src/fastmcp/server/context.py) that manages request-scoped state, session information, and dependency injection for tool handlers. Tools can access context via function parameters (e.g., `context: Context`) to retrieve session data, authentication info, or injected dependencies without global state; the framework automatically populates context based on the current request, enabling clean, testable tool implementations.

FastMCP includes built-in HTTP server support that exposes MCP servers over HTTP/HTTPS transports, with an OAuth proxy architecture for authentication. The framework handles HTTP request routing, TLS termination, and OAuth token validation automatically; servers can be deployed as HTTP services without additional reverse proxy configuration. The OAuth proxy pattern enables secure, token-based access control where client credentials are validated before tool execution.

FastMCP provides middleware-style tool transformations that intercept and modify tool execution before reaching handlers. The caching middleware automatically memoizes tool results based on input parameters, reducing redundant executions; custom transforms can add logging, rate limiting, or input sanitization. Transforms are applied as a pipeline, allowing composition of multiple middleware layers without modifying tool code.

FastMCP allows servers to expose Resources (static or dynamically generated content) and Templates (parameterized content) to clients. Resources are registered via @resource decorator and can return file contents, database records, or computed data; Templates are parameterized resources that accept arguments. The framework handles resource discovery, content serialization, and template parameter validation automatically, enabling LLMs to access and manipulate server-side data without tool execution.

FastMCP allows servers to expose Prompts (reusable instruction templates) that LLMs can discover and use. Prompts are registered via @prompt decorator and can include dynamic content, arguments, and metadata. The framework handles prompt discovery, argument validation, and content generation automatically, enabling servers to provide LLM-optimized instructions without requiring clients to hardcode prompts.

FastMCP supports background task execution for long-running operations, with session state management to track task progress and results. Tasks are registered via @task decorator and can run asynchronously without blocking tool execution; the framework provides session storage for persisting task state across requests. Tasks can update progress, store intermediate results, and notify clients of completion via callbacks.

FastMCP supports server composition where multiple FastMCP servers can be mounted as sub-servers within a parent server, enabling modular capability organization. Each sub-server maintains its own tools, resources, and prompts; the parent server aggregates and exposes them as a unified interface. This pattern enables teams to develop capabilities independently and compose them into larger systems without coupling.