FastMCP: a forma mais rápida de criar servidores MCP em Python

No post anterior, entendemos o que é o Model Context Protocol e por que ele está se tornando o padrão da indústria para conectar LLMs ao mundo real. Se você ainda não leu, recomendo começar por lá.

Agora vamos dar um passo à frente: conhecer o FastMCP, a biblioteca Python que torna a criação de servidores MCP algo surpreendentemente simples — e entender por que ela existe.

O SDK oficial do MCP

A Anthropic disponibilizou um SDK oficial em Python para criar servidores MCP. Ele funciona, é completo e segue o protocolo à risca. Mas tem um problema: é verboso.

Para criar um servidor com uma única tool usando o SDK oficial, você escreve algo assim:

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types
import asyncio

server = Server("meu-servidor")

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="somar",
            description="Soma dois números",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number"},
                    "b": {"type": "number"}
                },
                "required": ["a", "b"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "somar":
        return [types.TextContent(
            type="text",
            text=str(arguments["a"] + arguments["b"])
        )]

async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write, server.create_initialization_options())

asyncio.run(main())

from mcp.server import Server
from mcp.server.stdio import stdio_server
from mcp import types
import asyncio

server = Server("meu-servidor")

@server.list_tools()
async def list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="somar",
            description="Soma dois números",
            inputSchema={
                "type": "object",
                "properties": {
                    "a": {"type": "number"},
                    "b": {"type": "number"}
                },
                "required": ["a", "b"]
            }
        )
    ]

@server.call_tool()
async def call_tool(name: str, arguments: dict):
    if name == "somar":
        return [types.TextContent(
            type="text",
            text=str(arguments["a"] + arguments["b"])
        )]

async def main():
    async with stdio_server() as (read, write):
        await server.run(read, write, server.create_initialization_options())

asyncio.run(main())

Funciona. Mas são mais de 30 linhas para uma operação trivial. Imagine isso escalando para 10, 20 tools.

O que é o FastMCP?

O FastMCP é uma biblioteca Python de alto nível construída sobre o SDK oficial do MCP. A inspiração é clara no nome: assim como o FastAPI simplificou a criação de APIs REST em Python, o FastMCP simplifica a criação de servidores MCP.

O mesmo servidor acima, com FastMCP:

from fastmcp import FastMCP

mcp = FastMCP("meu-servidor")

@mcp.tool()
def somar(a: float, b: float) -> float:
    """Soma dois números"""
    return a + b

from fastmcp import FastMCP

mcp = FastMCP("meu-servidor")

@mcp.tool()
def somar(a: float, b: float) -> float:
    """Soma dois números"""
    return a + b

4 linhas. Mesmo resultado. Mesmo protocolo. Mesma compatibilidade.

O FastMCP cuida de toda a camada de serialização, validação de schema, registro de tools e comunicação via JSON-RPC — você foca apenas na lógica.

Por que FastMCP e não o SDK puro?

A escolha não é binária — para casos que exigem controle fino do protocolo, o SDK oficial ainda faz sentido. Mas para a grande maioria dos projetos, o FastMCP é a escolha certa.

Arquitetura de um servidor FastMCP

Um servidor FastMCP é composto pelos mesmos três conceitos do protocolo MCP:

🔧 Tools

Funções Python decoradas com @mcp.tool(). O FastMCP lê os type hints e a docstring automaticamente para gerar o schema JSON da tool.

@mcp.tool()
def buscar_usuario(user_id: int) -> str:
    """Busca um usuário pelo ID"""
    # sua lógica aqui
    return f"Usuário {user_id}"

@mcp.tool()
def buscar_usuario(user_id: int) -> str:
    """Busca um usuário pelo ID"""
    # sua lógica aqui
    return f"Usuário {user_id}"

📦 Resources

Fontes de dados expostas via URI, decoradas com @mcp.resource().

@mcp.resource("dados://config")
def get_config() -> str:
    """Retorna a configuração atual"""
    return "versão: 1.0"

@mcp.resource("dados://config")
def get_config() -> str:
    """Retorna a configuração atual"""
    return "versão: 1.0"

💬 Prompts

Templates reutilizáveis decorados com @mcp.prompt().

@mcp.prompt()
def resumir(texto: str) -> str:
    """Prompt para resumir um texto"""
    return f"Resuma o seguinte texto em 3 bullets:\n\n{texto}"

@mcp.prompt()
def resumir(texto: str) -> str:
    """Prompt para resumir um texto"""
    return f"Resuma o seguinte texto em 3 bullets:\n\n{texto}"

Instalação e configuração do ambiente

O FastMCP requer Python 3.10+. A instalação é simples:

# Com pip
pip install fastmcp

# Com uv (recomendado)
uv add fastmcp

# Com pip
pip install fastmcp

# Com uv (recomendado)
uv add fastmcp

💡 Por que uv? O uv é um gerenciador de pacotes e ambientes Python extremamente rápido, escrito em Rust. É a ferramenta recomendada pelo ecossistema MCP para gerenciar dependências. Se ainda não usa, vale a pena conhecer.

Para verificar a instalação:

python -c "import fastmcp; print(fastmcp.__version__)"

python -c "import fastmcp; print(fastmcp.__version__)"

A estrutura mínima de um servidor FastMCP

Todo servidor FastMCP segue esta estrutura base:

from fastmcp import FastMCP

# 1. Instancia o servidor com um nome
mcp = FastMCP("nome-do-servidor")

# 2. Define tools, resources e prompts
@mcp.tool()
def minha_tool(parametro: str) -> str:
    """Descrição da tool — o LLM vai ler isso"""
    return f"Resultado: {parametro}"

# 3. Ponto de entrada
if __name__ == "__main__":
    mcp.run()

from fastmcp import FastMCP

# 1. Instancia o servidor com um nome
mcp = FastMCP("nome-do-servidor")

# 2. Define tools, resources e prompts
@mcp.tool()
def minha_tool(parametro: str) -> str:
    """Descrição da tool — o LLM vai ler isso"""
    return f"Resultado: {parametro}"

# 3. Ponto de entrada
if __name__ == "__main__":
    mcp.run()

Três partes: instância, definição e execução. Simples assim.

No próximo post, vamos pegar exatamente essa estrutura e transformar em um servidor funcional, rodando localmente e conectado a um cliente MCP real.

O FastMCP remove a fricção entre a ideia e a implementação. Com ele, você não precisa conhecer os detalhes do protocolo JSON-RPC, nem gerenciar manualmente schemas e serialização — tudo isso é abstraído de forma elegante.

Se o MCP é a “tomada universal” dos agentes de IA, o FastMCP é o cabo que torna tudo mais fácil de conectar.

No próximo post, vamos colocar a mão na massa: criar um servidor FastMCP do zero, definir tools reais, rodar localmente e conectar ao Claude Desktop para ver tudo funcionando.

Está acompanhando a série? Deixa um comentário ou compartilha com alguém que trabalha com IA!