Protocolo de Contexto do Modelo (MCP): Conectando IA às Suas Ferramentas

Última atualização: June 28, 2026

MCP — o Model Context Protocol — é um padrão aberto lançado pela Anthropic no final de 2024 para conectar assistentes e agentes de IA a fontes de dados e ferramentas externas. Em vez de escrever uma integração personalizada para cada modelo e cada ferramenta, você expõe um servidor MCP e qualquer cliente compatível com MCP pode usá-lo. Conectei um servidor de sistema de arquivos e um servidor GitHub ao Claude Code na semana passada e a diferença no que o agente podia fazer foi imediata. Este post cobre o que é MCP, como funciona o modelo cliente-servidor, os tipos principais de capacidade e como executar servidores em sua própria configuração.

Resposta rápida: o que é MCP?

MCP é um protocolo baseado em JSON-RPC 2.0 que padroniza a conexão entre uma aplicação host de IA (o cliente MCP, como Claude Desktop ou Claude Code) e servidores externos que expõem dados e ações. Um único servidor MCP pode anunciar três tipos de capacidade para os clientes:

• Tools — funções que o modelo pode chamar (consultar um banco de dados, enviar uma mensagem, pesquisar um repositório).
• Resources — dados estruturados que o modelo pode ler (conteúdo de arquivos, respostas de API, registros).
• Prompts — modelos de prompt reutilizáveis e parametrizados que o usuário pode invocar.

O objetivo é um "USB-C para integrações de IA": um servidor, muitos clientes, sem cola por modelo. A especificação e os SDKs são de código aberto e mantidos em modelcontextprotocol no GitHub, com a documentação canônica em modelcontextprotocol.io.

Por que o MCP existe?

Antes do MCP, cada integração de ferramenta era um evento isolado. Se você quisesse que um assistente lesse seus issues do GitHub e também consultasse Postgres, você escrevia dois conectores personalizados e depois os reescrevia quando mudava de modelo ou host. A motivação declarada da Anthropic é acabar com essa duplicação com um protocolo compartilhado — o documento oficial descreve-o como dando aos modelos "acesso padronizado" a arquivos locais, bancos de dados e APIs.

Essa moldura importa para fluxos de trabalho agenticos especificamente. Um agente que só pode conversar é um chatbot; um agente que pode ler seu repositório, executar uma consulta e chamar uma ferramenta em um loop é um trabalhador real. MCP é a tubulação que torna o segundo portátil. Se você quiser ter uma visão mais ampla de onde isso se encaixa no design de agentes, veja nosso post sobre automação de agentes de IA.

Como funciona o modelo cliente-servidor?

MCP segue uma topologia host-cliente-servidor:

• Host — a aplicação que o usuário executa (Claude Desktop, Claude Code, uma extensão IDE).
• Client — vive dentro do host, mantendo uma sessão 1:1 com um servidor.
• Server — um processo que expõe capacidades através de um transporte.

Um host pode executar vários clientes, cada um falando com um servidor. O protocolo é JSON-RPC 2.0, com três fases de ciclo de vida que eu testo sempre que adiciono um novo servidor:

1. Initialize — o cliente envia a versão do protocolo, capacidades e informações do cliente; o servidor responde com as suas próprias.
2. Capability negotiation — ambos os lados declaram o que suportam (ferramentas, recursos, prompts, amostragem, raízes).
3. Operation — o cliente solicita listas de ferramentas, invoca ferramentas, lê recursos e o servidor transmite os resultados de volta.

Opções de transporte

stdio é o padrão para configuração local e é o que claude mcp add usa a menos que você passe um URL HTTP. Para um guia de exploração mais profundo sobre claude mcp add e a decisão stdio-vs-HTTP, veja nosso guia de integração MCP do Claude Code.

Quais são os três tipos de capacidade, na prática?

A maior parte do valor do MCP está nos três tipos de capacidade. Veja como cada um se comporta na verdade quando um modelo o usa.

Tools (invocadas pelo modelo)

As ferramentas são o motor principal. O modelo decide chamá-las com base na conversa. Executei um servidor expondo uma ferramenta search_logs e o modelo a chamou sem ser solicitado no momento em que perguntei "por que o deploy falhou às 2h da manhã?". As definições de ferramentas incluem um JSON Schema para argumentos, então o modelo recebe entradas tipadas e validadas.

Resources (controlados pelo aplicativo)

Os recursos são endereçados por URI e geralmente são selecionados pelo usuário, não pelo modelo — o usuário anexa um recurso como um arquivo ou registro, e o host o injeta no contexto. Isso importa para o controle de escopo: o modelo só pode ver o que você explicitamente lhe entrega.

Prompts (invocados pelo usuário)

Prompts são modelos com argumentos que aparecem na interface do host como comandos de barra (/) ou itens de menu. São a capacidade mais subutilizada — eu os uso para codificar "revise este PR contra nosso guia de estilo" para que não tenha que colar as mesmas instruções todas as vezes.

Como configurar um servidor MCP?

Configuração concreta, usando Claude Code como host. A mesma configuração do servidor funciona no arquivo JSON do Claude Desktop.

1. Instale Node.js 20+ (ou Python 3.10+ com uv).
2. Adicione um servidor de referência, por exemplo, o servidor de sistema de arquivos: npx -y @modelcontextprotocol/server-filesystem /Users/you/projects
3. Registre-o no Claude Code: claude mcp add filesystem -- npx -y @modelcontextprotocol/server-filesystem /Users/you/projects
4. Verifique a conexão: claude mcp list e depois claude mcp get filesystem
5. Reinicie o host e procure as ferramentas do servidor na sessão.

Esse é o ciclo completo. Os servidores de referência no org GitHub cobrem sistema de arquivos, Git, GitHub, Postgres, SQLite, Slack, Google Drive, Puppeteer e muito mais.

Um servidor personalizado mínimo (Python)

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("status")

@mcp.tool()
def healthcheck(service: str) -> str:
    """Return the current status of a service."""
    return f"{service}: ok"

if __name__ == "__main__":
    mcp.run(transport="stdio")

Testei isso contra um endpoint de staging em cerca de dez minutos, incluindo o acoplamento no Claude Code. Para padrões mais amplos sobre exposição de serviços internos como APIs chamáveis por agentes, nosso guia de desenvolvimento de API de IA aprofunda-se em autenticação e limitação de taxa (rate-limiting).

Como é o ecossistema em 2026?

O ecossistema se consolidou em torno do registro oficial e de um punhado de servidores de referência bem mantidos. Eu mantenho uma lista curta daqueles que realmente confio em produção:

• filesystem — leitura/escrita local de arquivos com restrições de root.
• github — issues, PRs, pesquisa, operações de arquivo.
• postgres / sqlite — somente leitura por padrão, introspecção de esquema.
• puppeteer / playwright — automação de navegador para agentes.
• slack — leituras de canal e envio de mensagens.

Para orquestrar múltiplos servidores por trás de subagentes — um subagente possui o banco de dados, outro possui o navegador — nosso post sobre subagentes do Claude Code detalha o padrão de equipe.

O que você deve ficar atento?

Esta é a parte que a maioria ignora. Os servidores MCP rodam com suas credenciais e seu acesso ao sistema de arquivos, então o escopo importa.

• Trate cada servidor como uma dependência. Fixe versões, audite a fonte antes de executar npx em um repositório estranho. Uma ferramenta maliciosa pode exfiltrar qualquer coisa que o modelo veja.
• Restrinja roots. O servidor de sistema de arquivos é tão seguro quanto o diretório para o qual você aponta — nunca passe /.
• Prefira configurações de banco de dados somente leitura até ter um motivo concreto para habilitar escritas.
• Cuidado com a injeção de prompts. Se uma ferramenta retornar conteúdo que o modelo então usa, entradas não confiáveis podem se tornar instruções. Assuma que qualquer recurso é hostil.
• Escopo os tokens OAuth. Os tokens do Slack e do GitHub devem ter o escopo mínimo necessário para o servidor, não seu token pessoal.

Eu começo todo novo servidor em uma conta sandboxed e observo as primeiras chamadas de ferramentas antes de confiar nele em uma sessão real.

Principal conclusão

MCP é um pequeno protocolo que resolve um problema real: ele permite que um servidor exponha ferramentas, recursos e prompts para qualquer host de IA compatível, eliminando o imposto de integração N-por-M. A mecânica é simples — inicializar, negociar, operar sobre stdio ou HTTP — mas a postura de segurança é o que determina se ele pertence ao seu fluxo de trabalho. Execute servidores que você possa auditar, escopo suas credenciais rigorosamente e assuma que entradas não confiáveis são hostis. Faça isso e MCP será a maneira mais limpa de transformar um assistente em um agente que pode realmente tocar nos seus sistemas.

Créditos das imagens

• Código fonte exibido em uma tela de monitor — foto por Markus Spiske em Pexels
• Um desenvolvedor digitando em um laptop enquanto configura um servidor em um terminal — foto por Vlada Karpovich em Pexels
• Composição abstrata de circuito-placa simbolizando arquitetura em camadas — foto por Christina Morillo em Pexels