FastMCP é um framework Python de alto nível para construir servidores e clientes Model Context Protocol (MCP), projetado para permitir que desenvolvedores criem ferramentas, exponham recursos, definam prompts e conectem componentes de forma rápida e concisa. Este projeto, desenvolvido e mantido pelo usuário do GitHub jlowin, tornou-se uma parte importante do ecossistema MCP.
Embora o protocolo MCP seja poderoso, implementá-lo requer uma grande quantidade de código boilerplate - configuração do servidor, manipuladores de protocolo, tipos de conteúdo, gerenciamento de erros, etc. O FastMCP lida com todos os detalhes complexos do protocolo e gerenciamento do servidor, permitindo que você se concentre na construção de excelentes ferramentas.
Os objetivos de design do FastMCP:
O FastMCP 1.0 tornou a construção de servidores MCP tão simples que agora faz parte do SDK Python oficial do Model Context Protocol!
O FastMCP 2.0 introduz várias novas funcionalidades:
Recomenda-se usar uv para instalar o FastMCP:
uv pip install fastmcp
Instalação para desenvolvimento:
git clone https://github.com/jlowin/fastmcp.git
cd fastmcp
uv sync
# server.py
from fastmcp import FastMCP
mcp = FastMCP("Demo")
@mcp.tool()
def add(a: int, b: int) -> int:
"""Add two numbers"""
return a + b
@mcp.resource("greeting://{name}")
def get_greeting(name: str) -> str:
"""Get a personalized greeting"""
return f"Hello, {name}!"
if __name__ == "__main__":
mcp.run()
Instale no Claude Desktop:
fastmcp install server.py
Representa o objeto central da aplicação MCP, lidando com conexões, detalhes do protocolo e roteamento:
from fastmcp import FastMCP
mcp = FastMCP("My App")
mcp = FastMCP("My App", dependencies=["pandas", "numpy"])
Permitem que LLMs executem operações executando funções Python, adequadas para cálculos, chamadas de API externas ou efeitos colaterais:
import httpx
from pydantic import BaseModel
class UserInfo(BaseModel):
user_id: int
notify: bool = False
@mcp.tool()
async def send_notification(user: UserInfo, message: str) -> dict:
"""Sends a notification to a user if requested."""
if user.notify:
print(f"Notifying user {user.user_id}: {message}")
return {"status": "sent", "user_id": user.user_id}
return {"status": "skipped", "user_id": user.user_id}
@mcp.tool()
def get_stock_price(ticker: str) -> float:
"""Gets the current price for a stock ticker."""
prices = {"AAPL": 180.50, "GOOG": 140.20}
return prices.get(ticker.upper(), 0.0)
Expõem dados para LLMs, fornecendo principalmente informações sem realizar cálculos significativos ou efeitos colaterais:
@mcp.resource("config://app-version")
def get_app_version() -> str:
"""Returns the application version."""
return "v2.1.0"
@mcp.resource("db://users/{user_id}/email")
async def get_user_email(user_id: str) -> str:
"""Retrieves the email address for a given user ID."""
emails = {"123": "alice@example.com", "456": "bob@example.com"}
return emails.get(user_id, "not_found@example.com")
Definem templates reutilizáveis ou padrões de interação:
from fastmcp.prompts.base import UserMessage, AssistantMessage
@mcp.prompt()
def ask_review(code_snippet: str) -> str:
"""Generates a standard code review request."""
return f"Please review the following code snippet for potential bugs and style issues:\n```python\n{code_snippet}\n```"
@mcp.prompt()
def debug_session_start(error_message: str) -> list[Message]:
"""Initiates a debugging help session."""
return [
UserMessage(f"I encountered an error:\n{error_message}"),
AssistantMessage("Okay, I can help with that. Can you provide the full traceback and tell me what you were trying to do?")
]
Crie servidores FastMCP que atuam como intermediários, fazendo proxy de solicitações para outro endpoint MCP:
import asyncio
from fastmcp import FastMCP, Client
from fastmcp.client.transports import PythonStdioTransport
proxy_client = Client(
transport=PythonStdioTransport('path/to/original_stdio_server.py'),
)
proxy = FastMCP.from_client(proxy_client, name="Stdio-to-SSE Proxy")
if __name__ == "__main__":
proxy.run(transport='sse')
Construa grandes aplicações MCP criando servidores FastMCP modulares e "montando-os" em um servidor pai:
from fastmcp import FastMCP
weather_mcp = FastMCP("Weather Service")
@weather_mcp.tool()
def get_forecast(city: str):
return f"Sunny in {city}"
news_mcp = FastMCP("News Service")
@news_mcp.tool()
def fetch_headlines():
return ["Big news!", "Other news"]
mcp = FastMCP("Composite")
mcp.mount("weather", weather_mcp)
mcp.mount("news", news_mcp)
Gere automaticamente servidores FastMCP a partir de APIs Web existentes:
from fastapi import FastAPI
from fastmcp import FastMCP
fastapi_app = FastAPI(title="My Existing API")
@fastapi_app.get("/status")
def get_status():
return {"status": "running"}
mcp_server = FastMCP.from_fastapi(fastapi_app)
Interaja com qualquer servidor MCP:
from fastmcp import Client
async with Client("path/to/server") as client:
result = await client.call_tool("weather", {"location": "San Francisco"})
print(result)
res = await client.read_resource("db://users/123/profile")
print(res)
fastmcp dev your_server_file.py
fastmcp install your_server_file.py
if __name__ == "__main__":
mcp.run()
O projeto contém vários arquivos de exemplo:
simple_echo.py: Ferramentas, recursos e prompts básicoscomplex_inputs.py: Usando modelos Pydantic como entrada de ferramentasmount_example.py: Montando vários servidores FastMCPsampling.py: Usando conclusão LLM em um servidor MCPscreenshot.py: Ferramenta que retorna um objeto Imagetext_me.py: Ferramenta que interage com uma API externamemory.py: Exemplo complexo com interação com banco de dadosFastMCP recebe contribuições da comunidade:
git clone https://github.com/jlowin/fastmcp.git && cd fastmcp
uv venv && uv sync
uv run pytest -vv
Use ruff e pre-commit:
pre-commit install
pre-commit run --all-files
FastMCP preenche a lacuna entre a implementação do protocolo MCP e o desenvolvimento de aplicações reais, permitindo que os desenvolvedores: