Se você já trabalha com LLMs (Large Language Models) e precisa integrar seus modelos a bancos de dados, APIs ou sistemas internos, o FastMCP pode ser a ponte perfeita. Ele é uma implementação do Model Context Protocol (MCP) em FastAPI, permitindo criar conectores rápidos, escaláveis e prontos para produção.
Neste artigo, vamos explorar o que é o MCP, por que usar o FastMCP e como construir seu primeiro conector com exemplos práticos.
O que é MCP?
O Model Context Protocol (MCP) é um padrão que define como modelos de linguagem podem se comunicar com fontes de dados e ferramentas externas.
Ele organiza essa comunicação em três blocos principais:
Prompts → entradas que o modelo pode pedir ao serviço.
Resources (Recursos) → dados que podem ser consultados pelo modelo (ex.: clientes, ordens, documentos).
Tools (Ferramentas) → ações que o modelo pode executar (ex.: criar um pedido, buscar informações no banco de dados).
Esse protocolo padroniza a comunicação e torna possível criar integrações seguras e escaláveis entre LLMs e sistemas reais.
Por que usar o FastMCP?
O FastMCP traz várias vantagens para quem já utiliza FastAPI:
• Performance e escalabilidade → aproveita toda a robustez do FastAPI.
• Estrutura modular → facilita manter conectores organizados.
• Compatibilidade → pode ser usado com qualquer cliente MCP.
• Flexibilidade → ideal tanto para integrações internas (ERP, CRM, banco de dados) quanto para serviços públicos.
Criando um Conector com FastMCP
Instalação
pip install fastapi uvicorn fastmcp
Exemplo Básico
Um conector mínimo usando FastMCP:
from fastapi import FastAPI
from fastmcp import MCPServer
# Criando app FastAPI
app = FastAPI(title="CRM Connector MCP")
# Iniciando MCP
mcp = MCPServer(app)
# Definindo um recurso (dados que o LLM pode consultar)
@mcp.resource("clientes")
def listar_clientes():
return [
{"id": 1, "nome": "Maria", "email": "maria@email.com"},
{"id": 2, "nome": "João", "email": "joao@email.com"},
]
# Definindo uma ferramenta (ação que o LLM pode executar)
@mcp.tool("criar_cliente")
def criar_cliente(nome: str, email: str):
return {"status": "ok", "mensagem": f"Cliente {nome} criado com sucesso!"}
Rodando o servidor:
uvicorn app:app --reload
Chamando via Cliente MCP
Um cliente MCP (ou LLM) pode interagir com esse conector de duas formas:
• GET /mcp/resources/clientes → lista os clientes.
• POST /mcp/tools/criar_cliente → cria um cliente novo passando { "nome": "Ana", "email": "ana@email" }.
Estrutura Recomendada
Para projetos maiores, organize os conectores em módulos:
app/
├── main.py # inicialização do FastMCP
├── resources/ # dados disponíveis para o modelo
│ └── clientes.py
├── tools/ # ações que podem ser executadas
│ └── criar_cliente.py
└── schemas/ # pydantic models para tipagem
Assim, seu conector cresce sem perder clareza.
Integração com Banco de Dados
Exemplo conectando um banco MySQL via SQLAlchemy:
from fastapi import Depends
from sqlalchemy.orm import Session
from database import get_db
from models import Cliente
from fastmcp import mcp
@mcp.resource("clientes_db")
def listar_clientes(db: Session = Depends(get_db)):
return db.query(Cliente).all()
@mcp.tool("adicionar_cliente")
def adicionar_cliente(nome: str, email: str, db: Session = Depends(get_db)):
cliente = Cliente(nome=nome, email=email)
db.add(cliente)
db.commit()
return {"status": "ok", "id": cliente.id}
Agora, o LLM pode acessar clientes reais no banco de dados e até criar registros por meio do MCP.
O FastMCP une a performance do FastAPI à padronização do MCP, tornando simples criar conectores que expõem dados e ferramentas para modelos de linguagem.
Ele é ideal para casos como:
Conectar LLMs a CRMs e ERPs internos.
Criar extensões customizadas para assistentes inteligentes.
Expor dados corporativos de forma segura para IA.
Experimente criar seu primeiro conector com FastMCP e descubra como ele pode transformar a forma como seus modelos de IA acessam dados e executam ações.