Em novembro de 2024, a Anthropic publicou uma especificação aberta chamada Model Context Protocol. A proposta era simples: padronizar como modelos de linguagem se conectam a ferramentas externas. Um ano depois, o protocolo acumula 97 milhões de downloads mensais dos SDKs, roda em mais de 10.000 servidores públicos e foi adotado pelo ChatGPT, Gemini, Microsoft Copilot e VS Code. Em dezembro de 2025, a Anthropic doou o MCP para a Linux Foundation.

O que aconteceu entre esses dois pontos merece atenção.

O que é o MCP e por que ele existe

Antes do MCP, cada plataforma de IA tinha sua própria forma de chamar ferramentas externas. O ChatGPT usava function calling com um schema JSON proprietário. O Claude tinha tool use com outro formato. O Gemini, outro. Se você queria que uma mesma ferramenta funcionasse em três assistentes diferentes, precisava implementar três integrações separadas.

O Model Context Protocol resolve isso com uma camada de abstração. Um servidor MCP expõe capacidades padronizadas, e qualquer cliente compatível consome essas capacidades sem adaptação. A analogia mais direta é o Language Server Protocol (LSP) da Microsoft, que fez o mesmo para editores de código: antes do LSP, cada editor precisava de um plugin dedicado por linguagem. Depois do LSP, um único servidor de linguagem funciona no VS Code, Neovim, Emacs e qualquer outro editor compatível.

O MCP faz o mesmo para LLMs. Um servidor MCP que acessa o PostgreSQL funciona igualmente no Claude, no ChatGPT e no Copilot.

Como o protocolo funciona por dentro

O MCP usa JSON-RPC 2.0 como formato de mensagem e define uma arquitetura cliente-servidor bidirecional. O modelo de IA (ou a aplicação que o hospeda) roda um cliente MCP, e cada integração externa roda como um servidor MCP.

O protocolo organiza as capacidades em três primitivas:

  • Tools representam ações executáveis. O LLM decide quando chamá-las durante uma conversa. Um tool pode ser "buscar o clima", "inserir um registro no banco" ou "executar um deploy"
  • Resources representam dados estruturados. São identificados por URIs e podem conter texto ou binário. O cliente lê resources para dar contexto ao modelo antes de responder
  • Prompts são templates reutilizáveis de interação. Servem para padronizar workflows comuns que o usuário pode acionar

Na prática, um prompt estrutura a intenção, um tool executa a operação e um resource fornece ou captura os dados. O ciclo se repete conforme necessário.

A comunicação entre cliente e servidor acontece por transporte stdio (para processos locais) ou Streamable HTTP (para servidores remotos). As mensagens seguem o formato JSON-RPC padrão:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": { "city": "São Paulo" }
  }
}

De experimento interno a padrão da indústria

O MCP nasceu da experiência da Anthropic construindo agentes para o Claude. A equipe percebeu que cada nova integração exigia código repetitivo: autenticação, serialização, tratamento de erros, discovery de capacidades. O protocolo surgiu para eliminar essa duplicação.

O lançamento em novembro de 2024 veio com uma decisão que acelerou a adoção: a Anthropic publicou não apenas a especificação, mas 19 servidores de referência, SDKs em TypeScript e Python, ferramentas de debug e um cliente oficial no Claude Desktop. Quem quisesse testar podia rodar um servidor MCP em minutos, não em dias.

Em março de 2025, Sam Altman anunciou que a OpenAI adotaria o MCP. A declaração foi direta: "People love MCP and we are excited to add support across our products." O suporte apareceu no Agents SDK e depois no ChatGPT Desktop. Nas semanas seguintes, Google integrou o protocolo ao Gemini, e a Microsoft adicionou suporte ao Copilot e ao VS Code.

Um artigo do Latent.Space identificou sete fatores que explicam por que o MCP venceu onde outras tentativas falharam:

  1. O protocolo foi projetado para LLMs desde o início, ao contrário de OpenAPI e GraphQL que são genéricos
  2. A credibilidade institucional da Anthropic funcionou como selo de qualidade
  3. A base no LSP trouxe decisões arquiteturais já testadas em produção
  4. O dogfooding foi real: a Anthropic usava o protocolo internamente antes de publicá-lo
  5. O lançamento completo (spec + SDKs + servidores + cliente) eliminou a fricção inicial
  6. A base mínima do protocolo combinada com um roadmap iterativo e updates frequentes manteve o momentum
  7. A resposta rápida da equipe ao feedback da comunidade gerou confiança entre os early adopters

O resultado: em um ano, o MCP chegou a 97 milhões de downloads mensais dos SDKs e ultrapassou o OpenAPI em stars no GitHub.

A Agentic AI Foundation e a governança aberta

Em 9 de dezembro de 2025, a Linux Foundation anunciou a Agentic AI Foundation (AAIF), um fundo direcionado para desenvolver padrões abertos de IA agêntica. A fundação foi co-criada por Anthropic, Block e OpenAI. Os membros platinum incluem AWS, Bloomberg, Cloudflare, Google e Microsoft.

Três projetos formaram o núcleo da AAIF:

  • MCP (Anthropic): o protocolo de conexão entre LLMs e ferramentas
  • goose (Block): um framework open-source de agente de IA local que usa MCP para integrações
  • AGENTS.md (OpenAI): um padrão para dar a agentes de IA instruções específicas por repositório, publicado em agosto de 2025

A doação do MCP para a Linux Foundation tem um significado prático: o protocolo agora opera sob governança neutra. A Anthropic não controla mais sozinha o roadmap. A especificação evolui por consenso da comunidade, com a infraestrutura da Linux Foundation garantindo que nenhum vendor individual possa sequestrar o padrão.

Para quem acompanha a história do open source, isso é familiar. O Kubernetes saiu do Google para a CNCF. O Node.js saiu da Joyent para a OpenJS Foundation. O padrão se repete: uma empresa cria, a indústria adota, a governança migra para terreno neutro. O MCP seguiu o mesmo caminho em tempo recorde.

MCP na prática: construindo um servidor em TypeScript

A forma mais rápida de entender o MCP é construir um servidor. O SDK oficial em TypeScript usa Zod para validação de schemas e suporta transporte stdio e HTTP.

Instalação:

npm install @modelcontextprotocol/sdk zod@3

Um servidor MCP mínimo que expõe um tool:

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: "demo",
  version: "1.0.0",
});

server.registerTool(
  "search_users",
  {
    description: "Search users by name in the database",
    inputSchema: {
      query: z.string().describe("Search term for user name"),
      limit: z.number().min(1).max(100).default(10).describe("Max results"),
    },
  },
  async ({ query, limit }) => {
    // Aqui entra a lógica real: query no banco, chamada de API, etc.
    const results = await searchUsersInDb(query, limit);
    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(results, null, 2),
        },
      ],
    };
  }
);

async function main() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

main().catch(console.error);

O server define um tool com nome, descrição, schema de input (via Zod) e uma função de execução. O schema é exposto automaticamente para qualquer cliente MCP que se conectar. O LLM recebe a descrição e o schema, decide se e quando chamar o tool, e o servidor executa.

Para conectar esse servidor ao Claude Desktop, basta adicionar ao claude_desktop_config.json:

{
  "mcpServers": {
    "demo": {
      "command": "node",
      "args": ["/caminho/absoluto/para/build/index.js"]
    }
  }
}

O SDK Python segue a mesma lógica, com uma interface FastMCP que usa type hints e docstrings para gerar as definições automaticamente.

Os riscos que ninguém quer discutir

O crescimento do MCP veio acompanhado de problemas sérios de segurança. Em abril de 2025, pesquisadores da Invariant Labs demonstraram ataques de tool poisoning contra servidores MCP, mostrando como um tool malicioso conseguia exfiltrar dados de outros tools conectados ao mesmo cliente. Nos meses seguintes, a Palo Alto Networks publicou uma taxonomia consolidada com cinco vetores de ataque: prompt injection, tool shadowing, escalação de privilégios, exfiltração de dados e "rug pull", onde um tool altera silenciosamente sua definição após a instalação para redirecionar tokens de API.

Em junho de 2025, a vulnerabilidade CVE-2025-6514 atingiu o componente mcp-remote, com CVSS 9.6. O bug no proxy OAuth afetava mais de 437.000 downloads e permitia execução arbitrária de comandos, roubo de credenciais cloud e exfiltração de chaves SSH através de endpoints maliciosos.

O problema de fundo é um trade-off de design. O MCP priorizou interoperabilidade sobre segurança. Servidores MCP armazenam tokens OAuth para Gmail, Google Drive e recursos corporativos. Um servidor comprometido dá acesso a tudo, e o roubo aparece como atividade legítima da API.

Pesquisadores da Strobes destacaram que o requisito da especificação de supervisão humana deveria ser tratado como obrigatório, não opcional. Em um cenário onde agentes autônomos executam tools sem supervisão explícita, a superfície de ataque se expande proporcionalmente ao número de servidores conectados.

A AAIF tem a oportunidade de endereçar isso com governança comunitária, mas até agora a segurança continua sendo o calcanhar de Aquiles do ecossistema.

Conclusão

O MCP resolveu um problema real: a fragmentação das integrações entre LLMs e o mundo externo. Em um ano, saiu de especificação interna para padrão de facto da indústria, adotado por todas as grandes plataformas de IA. A doação para a Linux Foundation e a criação da AAIF formalizam o que já era verdade na prática: nenhuma empresa sozinha deveria controlar como agentes de IA se conectam ao mundo.

Para devs que trabalham com integração de IA, o MCP é o protocolo a aprender agora. Os SDKs em TypeScript e Python estão maduros, a documentação é sólida e os 10.000+ servidores públicos cobrem de ferramentas de desenvolvimento a deploys enterprise. A barreira de entrada nunca foi tão baixa.

O desafio que resta é segurança. Um protocolo universal que conecta LLMs a bancos de dados, APIs e credenciais corporativas precisa de defesas à altura. A governança aberta da AAIF pode acelerar isso, mas exige que a comunidade trate segurança como prioridade, não como feature para a próxima release.

Referências pesquisadas nesta publicação