Arquivo MN-004-03 · Nota de campoHora local · UTC−3 · Status: Ativo
Matheus Nugas

Nota de campo 03 · IA aplicada

MCP em 60 segundos, e as partes que levam mais tempo

O Model Context Protocol transforma M × N integrações sob medida em M + N. Como funciona, o que um servidor expõe e o que ele não resolve por você.

Arquivada Leitura 4 min

Anexo 01 · Vídeo

MCP em 60 segundos

A versão curta desta nota, em inglês: o problema M × N, o que um servidor expõe e uma requisição da pergunta até a resposta.

Seu assistente escreve código, mas de fábrica não enxerga seu banco de dados, seus tickets nem sua documentação. Conectar costumava exigir uma integração sob medida para cada par de app de IA e ferramenta. O Model Context Protocol, MCP, é um padrão aberto para essa conexão. A Anthropic criou o protocolo no fim de 2024, e hoje ele é suportado por várias ferramentas de IA e IDEs. O vídeo acima é a versão de um minuto. Esta nota é o resto.

O problema M × N

Cinco apps de IA e dez ferramentas são cinquenta integrações. Cada uma com sua autenticação, seu jeito de descrever o que faz e seu jeito de quebrar. Ninguém constrói as cinquenta, então a maioria dos pares nunca é conectada.

O MCP troca a multiplicação por uma soma. Cada app implementa o lado cliente do protocolo uma vez. Cada ferramenta publica um servidor MCP. Cinco mais dez são quinze peças, e qualquer cliente conversa com qualquer servidor.

App de IACliente MCPJSON-RPCServidor MCPSeu sistema
Fig. 01 · O app mantém um cliente por servidor. O servidor embrulha seu sistema.

O formato das mensagens é JSON-RPC 2.0. Uma escolha propositalmente sem graça: requisições, respostas e notificações, nada que você não consiga ler num log.

O que um servidor expõe

Um servidor oferece três tipos de coisa. A diferença entre eles não está nos dados. Está em quem decide quando usar.

  1. Tools: o modelo decide. Ações com nome, descrição e um JSON Schema para a entrada, como create_ticket. O modelo lê as descrições e escolhe quando chamar.
  2. Resources: o app decide. Dados endereçados por uma URI, como tickets://open. O app escolhe o que anexar à conversa, muitas vezes porque o usuário selecionou.
  3. Prompts: o usuário decide. Templates reutilizáveis que o servidor sugere, normalmente como comandos de barra ou itens de menu.

Essa divisão é a parte que a maioria das explicações pula, e é a útil. Se o modelo deve agir sozinho, é uma tool. Se uma pessoa deve escolher o contexto, é um resource ou um prompt.

Uma requisição, do começo ao fim

Você pergunta “quais tickets estão abertos?”. O que acontece:

  1. Handshake. Quando o app abre a conexão, cliente e servidor trocam versões e capacidades.
  2. Descoberta. O cliente pede as tools do servidor com tools/list e entrega nomes, descrições e schemas ao modelo como parte do contexto.
  3. Escolha. O modelo lê sua pergunta e as descrições, e decide chamar list_open_tickets.
  4. Chamada. O cliente envia tools/call ao servidor com os argumentos que o modelo produziu.
  5. Resposta. O servidor executa a consulta e devolve o resultado. O cliente coloca de volta no contexto, e o modelo escreve a resposta a partir dele.

O passo 4, na rede:

{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "list_open_tickets",
    "arguments": { "limit": 5 }
  }
}

Repare no que o modelo nunca faz: ele nunca fala com o servidor. Só produz o nome de uma tool e os argumentos. Quem faz a chamada é o cliente. É nessa fronteira que entram confirmações, logs e limites.

Um servidor pequeno

Com o SDK oficial de TypeScript, um servidor com uma tool é curto:

import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { z } from 'zod';

const server = new McpServer({ name: 'tickets', version: '1.0.0' });

server.registerTool(
  'list_open_tickets',
  {
    description: 'Lists open support tickets, newest first.',
    inputSchema: { limit: z.number().int().min(1).max(50).default(10) },
  },
  async ({ limit }) => {
    const tickets = await db.openTickets(limit);
    return { content: [{ type: 'text', text: JSON.stringify(tickets) }] };
  },
);

await server.connect(new StdioServerTransport());

A descrição não é documentação para humanos. É o prompt que o modelo usa para decidir se chama a tool. Escreva como um: o que ela faz, quando usar, o que devolve.

Local ou remoto

Existem dois transportes padrão, e a escolha muda mais o modelo de segurança do que o código.

  1. stdio. O app inicia o servidor como um processo local e conversa com ele pela entrada e saída padrão. Simples e rápido, e o servidor roda com as permissões do seu usuário, na sua máquina.
  2. Streamable HTTP. O servidor roda em outro lugar e o cliente conecta por HTTP. É assim que um time compartilha um servidor, e isso traz autorização de verdade para o jogo: a especificação se apoia em OAuth para isso.

Um servidor local que você instalou de um repositório qualquer é código rodando como você. Trate como qualquer outra dependência que você revisaria antes de executar.

O que o MCP não resolve

O MCP padroniza a conexão. Ele não decide o que o modelo pode fazer com ela.

  1. Permissões são suas. Um servidor com um token que apaga registros dá ao modelo um jeito de apagar registros. Restrinja as credenciais ao que as tools realmente precisam, e prefira tools só de leitura até uma escrita valer o risco.
  2. Resultado de tool é entrada não confiável. O corpo de um ticket, uma página web ou um documento pode conter texto escrito para parecer instrução. O modelo lê isso no mesmo contexto de todo o resto. A mistura perigosa é dado privado, conteúdo não confiável e uma tool capaz de mandar dados para fora, tudo na mesma sessão.
  3. Escrita merece um humano. A maioria dos clientes pode pedir confirmação antes de executar uma tool. Mantenha isso ligado para qualquer coisa que muda estado.

Quando eu não usaria

O MCP compensa quando uma integração é usada por mais de um cliente: sua IDE, seu app de chat e seu agente reaproveitam o mesmo servidor. Se você tem um app chamando uma API interna, function calling direto no seu código é menos maquinário para o mesmo resultado.

Tools também custam contexto. Cada servidor conectado coloca nomes, descrições e schemas das tools na frente do modelo em toda requisição. Conecte uma dúzia de servidores e o modelo precisa escolher entre muitas tools, a maioria irrelevante para a pergunta. É o mesmo trade-off de RAG vs CAG: mais coisa no contexto não sai de graça. Conecte os servidores que a tarefa precisa, não todos que você tem.

Comece com um servidor para o sistema que você mais abre, só leitura, e observe o que o modelo faz com ele. Depois responda a pergunta do fim do vídeo: o que você conectaria primeiro?

Arquivada emIA aplicadaMCPLLMAI Agents

Matheus Nugas

Engenheiro fullstack sênior construindo sistemas orientados a eventos na AWS. Mais sobre mim.