代码拉取完成，页面将自动刷新
[!NOTE]
FastMCP 2.0 & The Official MCP SDK
FastMCP is the standard framework for building MCP servers and clients. FastMCP 1.0 was incorporated into the official MCP Python SDK.
This is FastMCP 2.0, the actively maintained version that significantly expands on 1.0's basic server-building capabilities by introducing full client support, server composition, OpenAPI/FastAPI integration, remote server proxying, built-in testing tools, and more.
FastMCP 2.0 is the complete toolkit for modern AI applications. Ready to upgrade or get started? Follow the installation instructions, which include specific steps for upgrading from the official MCP SDK.
The Model Context Protocol (MCP) is a new, standardized way to provide context and tools to your LLMs, and FastMCP makes building MCP servers and clients simple and intuitive. Create tools, expose resources, define prompts, and connect components with clean, Pythonic code.
# server.py
from fastmcp import FastMCP
mcp = FastMCP("Demo 🚀")
@mcp.tool()
def add(a: int, b: int) -> int:
"""Add two numbers"""
return a + b
if __name__ == "__main__":
mcp.run()
Run the server locally:
fastmcp run server.py
FastMCP's complete documentation is available at gofastmcp.com, including detailed guides, API references, and advanced patterns. This readme provides only a high-level overview.
Documentation is also available in llms.txt format, which is a simple markdown standard that LLMs can consume easily.
There are two ways to access the LLM-friendly documentation:
llms.txt is essentially a sitemap, listing all the pages in the documentation.llms-full.txt contains the entire documentation. Note this may exceed the context window of your LLM.The Model Context Protocol (MCP) lets you build servers that expose data and functionality to LLM applications in a secure, standardized way. Think of it like a web API, but specifically designed for LLM interactions. MCP servers can:
GET requests; load info into context)POST/PUT requests; execute actions)FastMCP provides a high-level, Pythonic interface for building and interacting with these servers.
The MCP protocol is powerful but implementing it involves a lot of boilerplate - server setup, protocol handlers, content types, error management. FastMCP handles all the complex protocol details and server management, so you can focus on building great tools. It's designed to be high-level and Pythonic; in most cases, decorating a function is all you need.
While the core server concepts of FastMCP 1.0 laid the groundwork and were contributed to the official MCP SDK, FastMCP 2.0 (this project) is the actively developed successor, adding significant enhancements and entirely new capabilities like a powerful client library, server proxying, composition patterns, OpenAPI/FastAPI integration, and much more.
FastMCP aims to be:
🚀 Fast: High-level interface means less code and faster development
🍀 Simple: Build MCP servers with minimal boilerplate
🐍 Pythonic: Feels natural to Python developers
🔍 Complete: FastMCP aims to provide a full implementation of the core MCP specification for both servers and clients
We recommend installing FastMCP with uv:
uv pip install fastmcp
For full installation instructions, including verification, upgrading from the official MCPSDK, and developer setup, see the Installation Guide.
These are the building blocks for creating MCP servers and clients with FastMCP.
FastMCP ServerThe central object representing your MCP application. It holds your tools, resources, and prompts, manages connections, and can be configured with settings like authentication providers.
from fastmcp import FastMCP
# Create a server instance
mcp = FastMCP(name="MyAssistantServer")
Learn more in the FastMCP Server Documentation.
Tools allow LLMs to perform actions by executing your Python functions (sync or async). Ideal for computations, API calls, or side effects (like POST/PUT). FastMCP handles schema generation from type hints and docstrings. Tools can return various types, including text, JSON-serializable objects, and even images using the fastmcp.Image helper.
@mcp.tool()
def multiply(a: float, b: float) -> float:
"""Multiplies two numbers."""
return a * b
Learn more in the Tools Documentation.
Resources expose read-only data sources (like GET requests). Use @mcp.resource("your://uri"). Use {placeholders} in the URI to create dynamic templates that accept parameters, allowing clients to request specific data subsets.
# Static resource
@mcp.resource("config://version")
def get_version():
return "2.0.1"
# Dynamic resource template
@mcp.resource("users://{user_id}/profile")
def get_profile(user_id: int):
# Fetch profile for user_id...
return {"name": f"User {user_id}", "status": "active"}
Learn more in the Resources & Templates Documentation.
Prompts define reusable message templates to guide LLM interactions. Decorate functions with @mcp.prompt(). Return strings or Message objects.
@mcp.prompt()
def summarize_request(text: str) -> str:
"""Generate a prompt asking for a summary."""
return f"Please summarize the following text:\n\n{text}"
Learn more in the Prompts Documentation.
Access MCP session capabilities within your tools, resources, or prompts by adding a ctx: Context parameter. Context provides methods for:
ctx.info(), ctx.error(), etc.ctx.sample() to request completions from the client's LLM.ctx.http_request() to make HTTP requests to other servers.ctx.read_resource() to access resources on the serverctx.report_progress() to report progress to the client.To access the context, add a parameter annotated as Context to any mcp-decorated function. FastMCP will automatically inject the correct context object when the function is called.
from fastmcp import FastMCP, Context
mcp = FastMCP("My MCP Server")
@mcp.tool()
async def process_data(uri: str, ctx: Context):
# Log a message to the client
await ctx.info(f"Processing {uri}...")
# Read a resource from the server
data = await ctx.read_resource(uri)
# Ask client LLM to summarize the data
summary = await ctx.sample(f"Summarize: {data.content[:500]}")
# Return the summary
return summary.text
Learn more in the Context Documentation.
Interact with any MCP server programmatically using the fastmcp.Client. It supports various transports (Stdio, SSE, In-Memory) and often auto-detects the correct one. The client can also handle advanced patterns like server-initiated LLM sampling requests if you provide an appropriate handler.
Critically, the client allows for efficient in-memory testing of your servers by connecting directly to a FastMCP server instance via the FastMCPTransport, eliminating the need for process management or network calls during tests.
from fastmcp import Client
async def main():
# Connect via stdio to a local script
async with Client("my_server.py") as client:
tools = await client.list_tools()
print(f"Available tools: {tools}")
result = await client.call_tool("add", {"a": 5, "b": 3})
print(f"Result: {result.text}")
# Connect via SSE
async with Client("http://localhost:8000/sse") as client:
# ... use the client
pass
To use clients to test servers, use the following pattern:
from fastmcp import FastMCP, Client
mcp = FastMCP("My MCP Server")
async def main():
# Connect via in-memory transport
async with Client(mcp) as client:
# ... use the client
FastMCP also supports connecting to multiple servers through a single unified client using the standard MCP configuration format:
from fastmcp import Client
# Standard MCP configuration with multiple servers
config = {
"mcpServers": {
"weather": {"url": "https://weather-api.example.com/mcp"},
"assistant": {"command": "python", "args": ["./assistant_server.py"]}
}
}
# Create a client that connects to all servers
client = Client(config)
async def main():
async with client:
# Access tools and resources with server prefixes
forecast = await client.call_tool("weather_get_forecast", {"city": "London"})
answer = await client.call_tool("assistant_answer_question", {"query": "What is MCP?"})
Learn more in the Client Documentation and Transports Documentation.
FastMCP introduces powerful ways to structure and deploy your MCP applications.
Create a FastMCP server that acts as an intermediary for another local or remote MCP server using FastMCP.as_proxy(). This is especially useful for bridging transports (e.g., remote SSE to local Stdio) or adding a layer of logic to a server you don't control.
Learn more in the Proxying Documentation.
Build modular applications by mounting multiple FastMCP instances onto a parent server using mcp.mount() (live link) or mcp.import_server() (static copy).
Learn more in the Composition Documentation.
Automatically generate FastMCP servers from existing OpenAPI specifications (FastMCP.from_openapi()) or FastAPI applications (FastMCP.from_fastapi()), instantly bringing your web APIs to the MCP ecosystem.
Learn more: OpenAPI Integration | FastAPI Integration.
The main way to run a FastMCP server is by calling the run() method on your server instance:
# server.py
from fastmcp import FastMCP
mcp = FastMCP("Demo 🚀")
@mcp.tool()
def hello(name: str) -> str:
return f"Hello, {name}!"
if __name__ == "__main__":
mcp.run() # Default: uses STDIO transport
FastMCP supports three transport protocols:
STDIO (Default): Best for local tools and command-line scripts.
mcp.run(transport="stdio") # Default, so transport argument is optional
Streamable HTTP: Recommended for web deployments.
mcp.run(transport="streamable-http", host="127.0.0.1", port=8000, path="/mcp")
SSE: For compatibility with existing SSE clients.
mcp.run(transport="sse", host="127.0.0.1", port=8000)
See the Running Server Documentation for more details.
Contributions are the core of open source! We welcome improvements and features.
Clone the repository:
git clone https://github.com/jlowin/fastmcp.git
cd fastmcp
Create and sync the environment:
uv sync
This installs all dependencies, including dev tools.
Activate the virtual environment (e.g., source .venv/bin/activate or via your IDE).
FastMCP has a comprehensive unit test suite. All PRs must introduce or update tests as appropriate and pass the full suite.
Run tests using pytest:
pytest
or if you want an overview of the code coverage
uv run pytest --cov=src --cov=examples --cov-report=html
FastMCP uses pre-commit for code formatting, linting, and type-checking. All PRs must pass these checks (they run automatically in CI).
Install the hooks locally:
uv run pre-commit install
The hooks will now run automatically on git commit. You can also run them manually at any time:
pre-commit run --all-files
# or via uv
uv run pre-commit run --all-files
main.main branch of jlowin/fastmcp.Please open an issue or discussion for questions or suggestions before starting significant work!
此处可能存在不合适展示的内容，页面不予展示。您可通过相关编辑功能自查并修改。
如您确认内容无涉及 不当用语 / 纯广告导流 / 暴力 / 低俗色情 / 侵权 / 盗版 / 虚假 / 无价值内容或违法国家有关法律法规的内容，可点击提交进行申诉，我们将尽快为您处理。
马建仓 AI 助手