O quê

MCP (Model Context Protocol) é o protocolo aberto publicado pela Anthropic em novembro de 2024 que padroniza como modelos de IA se conectam a fontes de dados externas e ferramentas. É o “USB-C dos LLMs” — antes do MCP, cada integração entre um LLM e uma ferramenta (Slack, GitHub, banco SQL, sistema de arquivos) era custom. Depois do MCP, qualquer cliente MCP fala com qualquer servidor MCP.

Em 2025, MCP se tornou de facto o padrão para AI agents. Claude Desktop, Cursor, Zed, Continue, e dezenas de outros clientes implementaram. Centenas de servidores MCP foram open-sourced cobrindo desde Postgres até Linear, Notion, Drive, Slack, e SDKs próprios.

Em Magik LLM Gathering, MCP é tratada como Technique · Inference · Uncommon — o protocolo que unifica a interação modelo↔ferramentas.

Como funciona

A arquitetura

MCP define três tipos de entidades:

1. MCP Server: expõe recursos (resources), ferramentas (tools), prompts e sampling para um cliente. Roda como processo separado (stdio, HTTP+SSE). Exemplos: filesystem-server, github-server, postgres-server.

2. MCP Client: aplicação que hospeda LLMs e quer dar acesso a recursos externos. Conecta a um ou múltiplos servers. Exemplos: Claude Desktop, Cursor, Zed.

3. MCP Host: o app que roda o cliente (e indiretamente o LLM). Para Claude Desktop, host é o próprio app desktop.

A separação importa: o servidor não sabe nada sobre LLMs; o cliente não sabe nada sobre ferramentas específicas. O protocolo é a interface.

As primitivas

MCP define quatro primitivas:

• Resources: dados acessíveis (arquivos, conteúdo de DB, screenshots). Servidor lista resources disponíveis, cliente pode ler. Identificados por URIs (file:///path, postgres://db/table).
• Tools: ações executáveis (read_file, send_email, query_db). Servidor declara schema JSON; cliente passa schema ao LLM; LLM decide chamar; cliente executa via servidor; resultado volta ao LLM. Igual a function-calling, mas padronizado entre vendors.
• Prompts: templates reutilizáveis de prompt que o servidor expõe. Cliente pode listar e injetar como sugestões pro usuário.
• Sampling: servidor pode pedir ao cliente para gerar texto (LLM completion). Útil para servers que precisam de raciocínio do LLM como subroutine.

O wire protocol

JSON-RPC 2.0 sobre transport configurável:

• stdio: servidor é processo filho, conversa via stdin/stdout. Simples, local-only.
• HTTP + SSE: servidor é HTTP service, eventos via Server-Sent Events. Remote, multi-tenant.
• WebSocket (em discussão).

Cada mensagem JSON-RPC tem method (initialize, list_resources, call_tool, etc.) e params. Capability negotiation na fase initialize define quais primitivas o par cliente-servidor suporta.

Por que importa

MCP resolve o que era o gargalo número um de AI agents em produção:

1. Antes do MCP, cada integração era N×M problem: N modelos × M ferramentas = N×M conectores. Custo combinatório.

2. Depois do MCP, é N+M: cada modelo implementa MCP client uma vez, cada ferramenta implementa MCP server uma vez. Combinatorial → linear.

3. Ecossistema explosivo: lista oficial de servers MCP cresceu de ~10 (lançamento) para 500+ em 6 meses. Comunidade open-source criou servers para tudo — Spotify, Discord, Steam, Home Assistant, Linear, Notion.

4. Reduz vendor lock-in: se você construir seu agent assumindo MCP, trocar de OpenAI → Anthropic → Llama é trivial (mesma interface). Antes, cada modelo tinha sua API de function-calling distinta.

5. Habilita “headless” agent ecosystems: agents podem orquestrar dezenas de servers MCP sem que cada um saiba dos outros. Compostabilidade real.

Por isso a comparação USB-C: o cabo padronizado destravou todo um ecossistema de periféricos. MCP fez análogo para ferramentas de AI.

Pegadinhas

• Não é trivialmente compatível com OpenAI function-calling: ambos servem propósito similar (LLM chama ferramenta), mas têm shapes diferentes. Cliente MCP precisa traduzir tools MCP → schema function-calling do modelo específico.
• Stateful servers são tricky: alguns servers MCP precisam manter estado entre chamadas (transações DB, autenticação). MCP é fundamentalmente stateless; estado vai via parameters/headers, com complexidade.
• Segurança: dar a um LLM acesso a tools poderosos (filesystem write, db delete, send email) é perigoso. MCP não resolve autorização — cabe ao cliente filtrar quais tools expor e ao usuário aprovar invocações.
• Latência: cada round-trip cliente↔servidor↔LLM custa centenas de ms. Agents com muitas chamadas ficam lentos. Otimizações: parallel tool calls, caching, prompt caching.
• Versionamento de schemas: tools mudam, mas LLMs treinados em schemas antigos podem chamar errado. MCP define capability negotiation mas tooling de migração ainda é imaturo.
• Não é internet-grade ainda: MCP foi desenhado para single-user, single-machine. Multi-tenant (vários usuários compartilhando server) e autenticação enterprise são extensões opcionais ainda em discussão.

Estado em 2026

Em 2026, MCP venceu a guerra de padrões de tool-use. O ponto de virada foi a adoção pela OpenAI (março de 2025, no Agents SDK) e pelo Google DeepMind — com os dois maiores rivais da Anthropic endossando o protocolo, MCP deixou de ser “coisa da Anthropic” e virou padrão de indústria, comparável ao LSP para editores de código. Milhares de servidores foram publicados, e plataformas inteiras (IDEs, Slack, GitHub, sistemas enterprise) passaram a expor MCP nativamente.

A maturação trouxe a especificação para perto de produção: a revisão de 2025 adicionou autorização baseada em OAuth 2.1, transporte HTTP streamable (substituindo o HTTP+SSE original) e melhor suporte a servidores remotos multi-tenant — exatamente os buracos apontados em 2024. Surgiram também registries e servidores gerenciados/hospedados, profissionalizando a descoberta e a distribuição.

Os trade-offs amadureceram mas não sumiram: segurança virou a maior preocupação — prompt injection via conteúdo de tools, servidores maliciosos e o problema de confiança de um agente que invoca dezenas de servidores. O tooling de permissão, sandboxing e auditoria ainda está se firmando. O consenso de 2026: MCP é a camada-padrão de conexão modelo↔ferramenta, e a competição migrou de “qual protocolo” para “como tornar MCP seguro e operável em escala”.

Tratamento de carta — proposta

Em Magik LLM Gathering, MCP aparece como Technique · Inference · Uncommon: escolha um Model em jogo — até o fim do turno ele ganha acesso a qualquer Construct que você controle (suas habilidades passivas se aplicam ao Model escolhido). Mecânica espelha a essência: um protocolo que conecta um Model a múltiplos Constructs (tools).

É a carta que destrava decks construct-heavy — sem MCP, seus Constructs ficam isolados; com ele, viram extensão do seu melhor Model.

Veja também

• Function Calling / Tool Use — primitivo que MCP padroniza
• LLM Agents — paradigma que MCP habilita em escala
• RAG — Retrieval-Augmented Generation — pode usar MCP para retrieval externo
• Claude — modelo principal que pushou MCP
• Claude — laboratório/modelo que publicou o protocolo