fastmcp

FastMCP provides a Python decorator-based interface (@mcp.tool, @mcp.resource, @mcp.prompt) that automatically generates JSON-RPC schemas and MCP protocol compliance from function signatures and docstrings. The framework introspects Python type hints and Pydantic models to produce OpenAPI-compatible schemas without manual schema definition, eliminating boilerplate while maintaining full protocol compliance.

FastMCP's Client class abstracts the underlying transport layer through a provider pattern, supporting stdio, HTTP, SSE, and WebSocket transports without changing client code. The transport layer is decoupled from client logic via the Transport interface, allowing runtime selection of communication mechanism based on deployment context (local subprocess, remote server, cloud function).

FastMCP provides an authentication framework that supports multiple auth backends (API keys, OAuth2, JWT, custom) and integrates with the context system for request-scoped auth state. Authentication is decoupled from authorization through a pluggable auth provider interface, allowing teams to implement custom auth logic (LDAP, SAML, custom databases) without modifying the server. Auth state is accessible to tools via the context system.

FastMCP provides a transformation system that allows tools to be modified or wrapped with custom logic before execution. Transforms can validate inputs, sanitize outputs, add logging, implement retry logic, or modify tool behavior. Transforms are composable and can be applied at the server level (affecting all tools) or per-tool, enabling uniform behavior modification without changing tool definitions.

FastMCP provides a caching middleware that caches tool execution results based on input parameters. The cache supports configurable time-to-live (TTL), manual invalidation, and cache key customization. Caching is transparent to tools and can be applied selectively to expensive operations, reducing redundant computation and improving response latency for repeated requests.

FastMCP supports composing multiple MCP servers into a single logical server through mounting. Mounted servers are exposed as namespaced tool groups, allowing hierarchical organization of tools (e.g., /database/*, /api/*, /files/*). This enables modular server architecture where different teams can develop and deploy independent tool providers that are composed at runtime.

FastMCP provides a proxy server pattern (src/fastmcp/server/proxy.py) that acts as an intermediary between clients and backend MCP servers. The proxy can implement OAuth2 flows, request routing, authentication delegation, and multi-server orchestration. This enables centralized auth management, load balancing, and protocol translation without modifying backend servers.

FastMCP provides a command-line interface for developing, testing, and deploying MCP servers. The CLI supports running servers locally, testing tool definitions, inspecting server capabilities, and generating configuration files. The CLI integrates with the FastMCP framework to provide development-time feedback and validation without requiring manual server startup or client setup.

FastMCP provides a configuration system (MCPServerConfig, MCPConfig) that supports environment-based settings, multi-server configurations, and deployment-specific overrides. Configuration can be loaded from environment variables, YAML files, or Python code, enabling flexible deployment across development, staging, and production environments. The configuration system integrates with the uv package manager for reproducible dependency management.

FastMCP provides a context system (via src/fastmcp/server/context.py) that manages request-scoped state and dependency injection for tool handlers. The framework uses Python's contextvars for thread-safe, async-safe state propagation, allowing tools to access session data, authentication context, and injected dependencies without explicit parameter passing through the call chain.

FastMCP implements a provider pattern (src/fastmcp/server/providers/) where tools, resources, and prompts can be sourced from multiple providers (FastMCP decorators, OpenAPI specs, filesystem, custom implementations) and aggregated into a single server. Providers implement a common interface and are composed via an AggregateProvider, enabling modular tool definition and dynamic capability composition without monolithic server code.

FastMCP includes an OpenAPI provider that parses OpenAPI 3.0 specifications and automatically transforms REST endpoints into MCP tools. The provider maps OpenAPI parameters, request bodies, and response schemas to MCP tool definitions, handling content negotiation, authentication headers, and response parsing transparently. This enables exposing existing REST APIs as MCP-compatible tools without manual tool definition.

FastMCP provides a resource system (@mcp.resource decorator) that exposes structured data and templates to LLMs. Resources can be static files, dynamic content generated from templates, or computed values. The framework supports URI-based resource addressing with template variables, allowing LLMs to request specific resource instances (e.g., /file/{path}) and receive content with automatic MIME type detection and encoding.

FastMCP provides a prompt system (@mcp.prompt decorator) that exposes reusable instruction templates to LLMs. Prompts are parameterized text templates that can be instantiated with arguments, allowing servers to provide domain-specific guidance, system prompts, or few-shot examples. Prompts are discoverable by LLMs and can be dynamically selected based on task context.

FastMCP provides a background task system that allows tools to spawn long-running operations without blocking the MCP response. Tasks are executed asynchronously using Python's asyncio, with support for progress updates, cancellation, and result persistence. The framework manages task lifecycle and provides session state storage for maintaining state across task execution and client reconnections.

FastMCP provides a middleware system that allows interception of tool calls, resource requests, and prompt queries before and after execution. Middleware can implement cross-cutting concerns like authentication, authorization, logging, caching, rate limiting, and request/response transformation. Middleware is composed in a chain and executes in order, with each middleware able to modify requests, responses, or short-circuit execution.

FastMCP can expose MCP servers via HTTP using FastAPI or similar frameworks, automatically generating OpenAPI documentation from tool definitions. The HTTP integration maps MCP tool calls to REST endpoints, handles request/response serialization, and exposes OpenAPI 3.0 specs that describe all available tools. This enables non-MCP clients (web browsers, REST tools, traditional APIs) to access MCP capabilities.