Como criar um servidor MCP do zero: passos práticos, segurança e arquitetura para expor seus dados a agentes de IA

Você já imaginou um assistente de IA capaz de consultar diretamente o seu banco de dados, responder perguntas sobre os dados e até executar operações controladas — tudo isso com segurança e sem intervenção humana? Com o Model Context Protocol (MCP), isso deixou de ser ficção. Mas entender o que é MCP é uma coisa; subir o seu primeiro servidor e ver o agente usá-lo é outra completamente diferente.

Neste artigo, vamos mergulhar no universo dos servidores MCP. Você vai aprender os conceitos fundamentais, o passo a passo para criar um servidor do zero e, principalmente, como expor bancos de dados relacionais e NoSQL de forma robusta e protegida contra os ataques mais comuns, como SQL injection. Ao final, você estará pronto para dar superpoderes aos seus agentes de IA.

O que é o Model Context Protocol (MCP)?

O MCP é um protocolo aberto que padroniza a comunicação entre modelos de linguagem (LLMs) e ferramentas externas. Ele funciona como uma interface universal: em vez de conectar cada agente a cada sistema de forma proprietária, você cria um servidor MCP que expõe funcionalidades de forma padronizada. Qualquer cliente compatível — Claude Code, Claude Desktop, LangChain, LlamaIndex e outros — pode descobrir e chamar essas funcionalidades.

Um servidor MCP é o que transforma o seu código numa ferramenta que um agente sabe chamar sozinho. Em vez de colar dados manualmente no prompt, o agente faz uma chamada estruturada ao servidor, como quem usa uma API, mas com toda a inteligência contextual do protocolo.

Por que criar seu próprio servidor MCP?

Você pode estar se perguntando: "Por que não usar integrações prontas?" A resposta é simples: controle e personalização. Ao criar seu próprio servidor, você:

Define exatamente quais dados e operações serão expostos aos agentes;
Implementa camadas de segurança sob medida para o seu cenário;
Garante que as ferramentas sigam as regras de negócio da sua organização;
Evita depender de conectores genéricos que podem não atender à sua necessidade;
Prepara um reuso verdadeiro: o mesmo servidor pode atender a diferentes agentes sem mudanças de código.

Componentes essenciais de um servidor MCP

Antes de colocar a mão no código, é crucial entender os três pilares do protocolo:

Tools: funções executáveis que o modelo pode chamar. Cada tool possui uma descrição e um esquema de parâmetros. Por exemplo, uma tool consultar_cliente que recebe um id e retorna os dados do cliente.
Resources: dados ou conteúdos que podem ser lidos pelo modelo, como arquivos, documentos ou resultados de consultas. São úteis para fornecer contexto.
Prompts: templates de mensagens que orientam o modelo a executar tarefas específicas, acelerando o desenvolvimento de fluxos complexos.

Além disso, o servidor precisa definir um transporte. O padrão mais comum é o stdio, usado quando o cliente e o servidor estão no mesmo processo. Para comunicação remota, há o transporte HTTP, que permite que servidores rodem em diferentes máquinas e sejam acessados pela rede.

Passo a passo: criando um servidor MCP do zero

Embora a teoria ajude, a prática é o que realmente faz entender o protocolo. Vamos ao roteiro básico, que pode ser aplicado a qualquer linguagem — embora os exemplos da comunidade, como os dos repositórios fean-developer/mcp-databases e Filipescordeiro2/mcp-mongo, sejam em Python, o ecossistema já possui SDKs para outras linguagens.

1. Configure o projeto

Crie um ambiente virtual e instale o SDK do MCP. Em Python, o pacote oficial é mcp, que oferece classes para criar servidores com facilidade.

mkdir meu-servidor-mcp
cd meu-servidor-mcp
python -m venv .venv
source .venv/bin/activate
pip install mcp

2. Defina as tools

As tools são o coração do servidor. No SDK, você pode criar uma tool usando decorators ou classes. Cada tool deve ter:

Nome único;
Descrição clara (quanto melhor a descrição, melhor o modelo entende quando usá-la);
Esquema dos parâmetros (usando Pydantic ou JSON Schema).

Exemplo:

from mcp.server import Server
from pydantic import BaseModel

class ConsultaParam(BaseModel):
    id_usuario: int

server = Server("meu-servidor")

@server.tool(description="Consulta o nome de um usuário pelo ID", params=ConsultaParam)
def consultar_usuario(params: ConsultaParam):
    # lógica aqui
    return {"id": params.id_usuario, "nome": "Maria Silva"}

3. Adicione resources e prompts

Resources podem ser registrados como caminhos ou URIs. Prompts, por sua vez, são templates úteis para dar instruções iniciais ao modelo. Registrá-los é simples e agrega valor ao servidor.

4. Configure o transporte

Para testes locais, o transporte padrão é o stdio. Basta iniciar o servidor com server.run(). Para uso remoto, você pode usar starlette ou outro framework ASGI para expor o servidor via HTTP.

5. Teste com um agente

A parte mais gratificante é conectar o servidor a um cliente MCP. Por exemplo, no Claude Desktop, você pode adicionar seu servidor no arquivo de configuração. A partir daí, o agente passa a usar suas tools naturalmente.

Caso real: servidor MCP para bancos de dados relacionais

O repositório fean-developer/mcp-databases mostra exatamente como implementar um servidor MCP em Python para expor operações de SQL Server, MySQL e PostgreSQL como ferramentas MCP. O grande destaque desse projeto é o foco em segurança e robustez: ele foi desenhado para que aplicações baseadas em LLM consultem e manipulem dados sem abrir brechas para SQL injection.

A abordagem utiliza queries parametrizadas e validação rígida de entradas. Em vez de concatenar strings para montar o SQL, cada tool recebe parâmetros tipados e os converte em comandos seguros. Isso é fundamental, pois um modelo de linguagem pode, por exemplo, receber uma entrada maliciosa do usuário e tentar executá-la — cabe ao servidor garantir que isso não se torne um vetor de ataque.

Exemplo conceitual:

@server.tool(description="Busca um usuário pelo email", params=BuscaEmailParam)
def buscar_por_email(params: BuscaEmailParam):
    cursor.execute("SELECT * FROM usuarios WHERE email = %s", (params.email,))
    return cursor.fetchall()

Além disso, o projeto estrutura as ferramentas de modo que operações perigosas (como DELETE ou UPDATE) exijam confirmação explícita ou privilegios específicos, reduzindo o risco de ações destrutivas acidentais.

Caso real: MongoDB com Clean Architecture

Já o repositório Filipescordeiro2/mcp-mongo apresenta uma implementação moderna para MongoDB, usando Clean Architecture, Repository Pattern e Motor (o driver assíncrono do MongoDB). Esse projeto é um ótimo exemplo de como o MCP não está restrito a bancos relacionais: ele também funciona muito bem com bancos orientados a documentos.

A escolha por Clean Architecture traz vantagens claras:

Separação de responsabilidades: regras de negócio ficam isoladas da infraestrutura;
Testabilidade: cada camada pode ser testada de forma independente;
Manutenibilidade: novas funcionalidades são adicionadas sem reescrever o código existente.

O padrão Repository centraliza o acesso aos dados, o que facilita a implementação de futuras mudanças no banco sem impactar as tools MCP. E por ser compatível com qualquer agente via HTTP, esse servidor é um excelente ponto de partida para quem quer expor dados de uma aplicação moderna e escalável.

Segurança em servidores MCP: o que você não pode ignorar

O MCP abre uma porta de entrada para os seus sistemas. Portanto, segurança deve ser a prioridade número um. Veja as práticas que separam um servidor amador de um profissional:

Use queries parametrizadas: nunca monte SQL por concatenação de strings. Isso vale para qualquer banco de dados.
Valide todos os parâmetros: utilize esquemas (Pydantic, Zod, etc.) para garantir que os tipos e formatos estejam corretos antes de executar qualquer operação.
Aplique o princípio do menor privilégio: o usuário do banco de dados usado pelo servidor MCP deve ter apenas as permissões necessárias para as operações expostas.
Defina limites de escopo: evite expor tools como executar_sql_qualquer. Prefira ferramentas específicas para operações de negócio.
Monitore e registre tudo: logs de acesso e de execução ajudam a detectar comportamentos anômalos.
Implemente autenticação e autorização: se o transporte for HTTP, exija tokens ou outros mecanismos de segurança.

Boas práticas para manter seu servidor MCP saudável

Além da segurança, um servidor MCP de produção precisa de cuidados contínuos. A comunidade que desenvolve projetos como mcp-databases e mcp-mongo reforça alguns princípios:

Documentação clara: descreva cada tool, seus parâmetros e possíveis erros. O modelo de IA usa essas descrições para decidir quando chamar a ferramenta.
Testes automatizados: cubra as tools com testes unitários e de integração, incluindo cenários de falha.
Versionamento semântico: mantenha uma política clara de mudanças para não quebrar clientes existentes.
Observabilidade: meça latência, taxa de erros e uso de cada tool para otimizar o desempenho.
Documente exemplos práticos: mostre como usar o servidor com diferentes agentes, pois isso reduz a barreira de adoção.

Conclusão

Criar um servidor MCP do zero é uma jornada reveladora. Você sai da posição de quem apenas consome integrações prontas para se tornar um arquiteto de soluções de IA. Os projetos da comunidade mostram que, com boas práticas de engenharia — segurança, arquitetura limpa e documentação —, é possível construir servidores poderosos para praticamente qualquer fonte de dados.

Seja expondo um banco relacional com proteção contra SQL injection, seja conectando um MongoDB com Clean Architecture, o MCP veio para ficar e vai padronizar a forma como agentes e sistemas trocam informações nos próximos anos. O primeiro passo é pequeno: configure um servidor, crie uma tool e veja seu agente executá-la sozinho. A partir daí, as possibilidades são ilimitadas.

E você, já criou seu primeiro servidor MCP? Compartilhe nos comentários a sua experiência — inclusive os desafios. A troca de conhecimento é o que torna o ecossistema cada vez mais forte.

README.md