fastmcp

FastMCP provides a Python decorator-based interface (@tool, @resource, @prompt) that automatically generates JSON-RPC schemas and MCP protocol compliance without manual schema writing. The framework introspects Python function signatures, type hints, and docstrings to produce valid MCP schemas, eliminating boilerplate and reducing the cognitive load of protocol compliance. This approach leverages Python's type system and decorator pattern to bridge high-level Python code directly to low-level MCP protocol requirements.

FastMCP's Client class abstracts transport layer details, supporting stdio, HTTP, WebSocket, and SSE transports through a unified interface. The client handles connection negotiation, message routing, and protocol state management independently of the underlying transport mechanism. This design allows the same client code to connect to servers via different transports by simply changing configuration, without modifying business logic.

FastMCP provides a command-line interface for running MCP servers, managing configurations, and development workflows. The CLI supports running single servers or multiple servers from configuration files, hot-reloading during development, and integration with environment management tools (uv). The framework includes development tools for testing servers, validating schemas, and debugging protocol interactions without requiring manual MCP client implementation.

FastMCP supports defining and managing multiple MCP servers through a single MCPConfig file (YAML/TOML), enabling coordinated deployment of server ecosystems. The configuration system integrates with environment management tools (uv) for dependency isolation and version management. Each server can have independent configurations, dependencies, and authentication settings, allowing complex multi-service architectures to be managed declaratively.

FastMCP provides built-in telemetry and observability hooks for monitoring server performance, tool execution, and protocol interactions. The framework supports integration with observability platforms through standard instrumentation patterns (logging, metrics, tracing). Developers can instrument servers to track tool execution times, error rates, and protocol events without modifying tool code, enabling production monitoring and debugging.

FastMCP includes testing utilities and patterns for validating MCP servers without requiring a running server or external MCP client. Tests can directly invoke server methods, validate schema generation, and simulate tool execution. The framework provides fixtures and helpers for common testing scenarios (tool invocation, resource retrieval, prompt rendering), reducing boilerplate in test code.

FastMCP uses a Provider pattern where tools, resources, and prompts are organized into pluggable providers that can be composed, mounted, and aggregated. The framework includes built-in providers (FastMCP provider, filesystem provider, OpenAPI provider) and an AggregateProvider that merges multiple providers into a single namespace. This architecture enables modular server construction where capabilities can be added, removed, or swapped without modifying core server logic.

FastMCP provides a Context class that manages request-scoped state, session information, and dependency injection for tool handlers. The context is automatically passed to tool functions and can store per-request data (user identity, session tokens, request metadata) without polluting global state. The framework uses Python's contextvars for thread-safe context propagation and supports custom context providers for application-specific state initialization.

FastMCP supports background task registration and execution within the context of a session, allowing long-running operations to continue after tool execution completes. Tasks are associated with sessions and can access session state through the Context. The framework manages task lifecycle (creation, execution, cleanup) and provides hooks for session initialization and teardown, enabling resource management patterns like connection pooling and cleanup.

FastMCP includes an OpenAPIProvider that parses OpenAPI 3.0+ specifications and automatically transforms API endpoints into MCP tools. The provider introspects the OpenAPI spec to extract operation details (parameters, request bodies, responses) and generates MCP-compatible tool definitions with proper schema validation. This enables exposing REST APIs as MCP tools without manual tool definition, bridging the gap between REST and MCP ecosystems.

FastMCP can host MCP servers over HTTP with built-in support for authentication schemes (API keys, OAuth), middleware for request/response processing, and TLS configuration. The HTTP server implementation handles MCP protocol translation over HTTP, manages connection state, and provides hooks for custom authentication logic. Middleware can be chained to implement caching, rate limiting, logging, and other cross-cutting concerns.

FastMCP provides a Transform system that allows tools to be modified, validated, or wrapped before execution. Transforms can be applied at the server level to affect all tools or at the provider level for specific tool sets. The framework supports transforms for input validation, output formatting, error handling, and cross-cutting concerns like logging or metrics collection. Transforms are composable and can be chained to build complex processing pipelines.

FastMCP includes a proxy server implementation that can aggregate multiple upstream MCP servers and expose them through a single MCP interface. The proxy handles tool routing, resource aggregation, and protocol translation. It supports OAuth proxy patterns where authentication tokens are managed centrally and injected into upstream server requests. This enables building gateway architectures that provide unified access to multiple MCP services with centralized authentication.

FastMCP allows defining resources (files, documents, data) and prompts (reusable instruction templates) as first-class MCP components. Resources can be static files or dynamically generated content, and prompts can include templates with variable substitution. The framework handles resource listing, content retrieval, and prompt rendering without requiring manual MCP protocol handling. This enables building knowledge bases and instruction libraries that LLMs can access.