MCP está em todo lugar. Todo anúncio de ferramenta de IA no início de 2026 menciona. Todo artigo sobre "stack moderna de IA" lista. Mas quando você pergunta pra alguém o que MCP realmente é, recebe ou uma tese de doutorado ou um pitch de marketing.

Aqui vai a versão de uma frase: MCP é uma porta USB para agentes de IA.

Essa é toda a explicação. Tá, beleza, aqui vai o resto. 😼

O mundo antes do padrão

Imagina seu setup lá por fim de 2024. Você tá construindo um agente de IA — um programa que usa um modelo de linguagem grande (LLM — o cérebro por trás do ChatGPT, Claude, Gemini) pra tomar decisões e agir por conta própria. Seu agente precisa consultar um banco PostgreSQL, pesquisar na web, gerenciar issues no GitHub e ler arquivos locais.

Pra cada ferramenta, você escreve código de integração customizado:

# Cada ferramenta precisa do seu próprio código de cola
from custom_postgres import query_db
from custom_github import create_issue
from custom_search import web_search
from custom_files import read_file

# Cada integração tem:
# - Métodos de autenticação diferentes
# - Formatos de resposta diferentes
# - Tratamento de erro diferente
# - Gerenciamento de conexão diferente

Cada vendor de IA construiu seu próprio sistema de integração. Claude tinha "tool use." OpenAI tinha "function calling." LangChain tinha "tools." Todos faziam a mesma coisa de formas incompatíveis. Construir uma integração pra um significava reconstruir pra outro.

Essa é a era da porta serial, porta paralela e carregador proprietário da IA. Lembra disso? Antes do USB, cada dispositivo tinha seu próprio cabo. Caos total. 😹

A lacuna que precisava ser preenchida

O problema não era que integrações eram difíceis. O problema era que eram difíceis todas as vezes. Ferramenta nova aparece — você escreve mais 200 linhas de integração customizada. Multiplica isso por cada cliente de IA no mercado. A conta é cruel.

Alguém precisava definir um plugue universal.

Entra o MCP

A Anthropic lançou o MCP (Model Context Protocol) no final de 2024 como um padrão aberto — um padrão de plugue universal para ferramentas de IA, tipo USB mas para dados. Em março de 2026, virou a forma padrão de agentes de IA se conectarem ao mundo exterior.

Veja como fica conectar quatro ferramentas com MCP:

{
  "mcpServers": {
    "postgres": { "command": "npx", "args": ["-y", "@mcp/server-postgres", "..."] },
    "github": { "command": "npx", "args": ["-y", "@mcp/server-github"] },
    "search": { "command": "npx", "args": ["-y", "@mcp/server-brave-search"] },
    "files": { "command": "npx", "args": ["-y", "@mcp/server-filesystem", "/home"] }
  }
}

Quatro ferramentas. Quatro linhas de config. Zero código customizado. Todo server fala o mesmo protocolo — um conjunto de regras de como programas se comunicam — e todo client entende.

A arquitetura: três atores, zero mágica

MCP tem exatamente três partes móveis:

┌──────────────────┐
│       HOST       │  (Claude Code, Cursor, seu app)
│                  │
│  ┌────────────┐  │
│  │   CLIENT   │──── MCP Protocol ──── SERVER (Postgres, GitHub)
│  └────────────┘  │
│                  │
│  ┌────────────┐  │
│  │   CLIENT   │──── MCP Protocol ──── SERVER (Search, Files)
│  └────────────┘  │
└──────────────────┘

Host — a aplicação de IA com a qual você interage. Claude Code, Claude Desktop, Cursor, Windsurf, ou seu próprio app customizado.

Client — vive dentro do host. Gerencia a conexão com um server. Um host pode rodar vários clients conectados a vários servers ao mesmo tempo.

Server — fornece ferramentas e dados. Roda como um processo separado — um programa independente — seja na sua máquina ou em um servidor remoto.

Sem camada de orquestração. Sem fila de mensagens. Sem service mesh. Só um client conversando com um server através de um protocolo padrão. É isso. 😸

O que passa pelo cano

MCP servers podem fornecer três tipos de coisas:

1. Tools — ações que a IA pode executar

Tools são funções — operações independentes — que a IA pode chamar. Tipo "rodar uma query SQL" ou "criar uma issue no GitHub."

{
  "name": "query",
  "description": "Run a read-only SQL query against the database",
  "inputSchema": {
    "type": "object",
    "properties": {
      "sql": { "type": "string", "description": "The SQL query to execute" }
    },
    "required": ["sql"]
  }
}

Quando o server inicia, ele diz pro client: "Aqui estão as tools que eu forneço, aqui está o que cada uma faz, aqui estão os parâmetros." O modelo de IA lê essas descrições e decide quando usar — da mesma forma que você decide qual app abrir no celular.

2. Resources — dados que a IA pode ler

Resources são pedaços de dados que o server expõe. O conteúdo de um arquivo, um schema do banco (a estrutura das suas tabelas), uma configuração.

A distinção importa: tools fazem coisas, resources fornecem contexto. A IA lê resources pra entender o ambiente antes de agir. Pense nisso como ler o cardápio do restaurante antes de fazer o pedido.

3. Prompts — templates prontos

Templates pré-escritos que o server oferece, tipo "analise esta tabela" ou "revise este pull request." São atalhos de conveniência que sabem como usar as tools do server de forma eficiente.

A maioria das pessoas ignora prompts e só conversa com a IA normalmente. Tá tudo bem. São opcionais.

Rastreando uma requisição real

Vamos acompanhar o que acontece quando você digita "Me mostra todos os usuários que se cadastraram hoje" no Claude Code com um MCP server de Postgres conectado:

1. VOCÊ digita: "Me mostra todos os usuários que se cadastraram hoje"

2. CLAUDE vê que as tools MCP do Postgres estão disponíveis
   (query, list_tables, describe_table)

3. CLAUDE chama 'describe_table' primeiro pra entender
   a estrutura da tabela users

4. CLIENT envia pro SERVER:
   { "method": "tools/call",
     "params": { "name": "describe_table",
                 "arguments": { "table": "users" } } }

5. SERVER consulta o PostgreSQL, retorna o schema

6. CLAUDE escreve a query SQL baseada no schema:
   SELECT * FROM users WHERE created_at >= CURRENT_DATE

7. CLIENT envia a query pro SERVER, SERVER executa

8. CLAUDE formata os resultados e mostra pra você

Tudo leva 1-2 segundos. Você perguntou em português, a IA descobriu o SQL, o MCP server executou, e você recebeu os resultados. Sem escrever query na mão. Esse é o momento "aha" pra maioria das pessoas. 😻

A camada de transporte — como os bits viajam

MCP funciona por dois métodos de transporte:

STDIO (servers locais) — o server roda como um processo filho na sua máquina. A comunicação acontece via stdin/stdout — os mesmos pipes de texto que seu terminal usa. Esse é o setup mais comum:

{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "env": { "DB_URL": "..." }
    }
  }
}

Simples, rápido, sem rede envolvida.

Streamable HTTP (servers remotos) — pra servers em outras máquinas. Hospedados na nuvem, compartilhados com o time, ou serviços de terceiros:

{
  "mcpServers": {
    "remote-server": {
      "url": "https://mcp.example.com/sse",
      "headers": { "Authorization": "Bearer your-token" }
    }
  }
}

Requisições vão como HTTP POST normal. Respostas voltam em streaming e tempo real. É assim que deploys enterprise funcionam — servers centralizados aos quais múltiplos devs se conectam.

Construa o seu em 20 linhas

Aqui está o MCP server funcional mais simples que você pode escrever usando o SDK oficial em TypeScript:

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

const server = new McpServer({
  name: "my-tool",
  version: "1.0.0"
});

server.tool(
  "hello",
  "Says hello to someone",
  { name: { type: "string", description: "Person to greet" } },
  async ({ name }) => ({
    content: [{ type: "text", text: `Hello, ${name}!` }]
  })
);

const transport = new StdioServerTransport();
await server.connect(transport);

Instala o SDK (npm install @modelcontextprotocol/sdk), define suas tools, conecta o transporte. O SDK cuida da negociação do protocolo — o handshake onde client e server concordam sobre o que ambos suportam — parsing de mensagens e tratamento de erros.

Um exemplo prático — API de clima

server.tool(
  "get_weather",
  "Get current weather for a city",
  {
    city: { type: "string", description: "City name" },
    units: { type: "string", description: "celsius or fahrenheit", default: "celsius" }
  },
  async ({ city, units }) => {
    const response = await fetch(
      `https://wttr.in/${encodeURIComponent(city)}?format=j1`
    );
    const data = await response.json();
    const current = data.current_condition[0];
    const temp = units === "fahrenheit"
      ? current.temp_F + "°F"
      : current.temp_C + "°C";
    return {
      content: [{ type: "text", text: `${city}: ${temp}, ${current.weatherDesc[0].value}` }]
    };
  }
);

Agora seu agente de IA pode checar o clima. Mais importante, perceba o padrão: buscar dados de qualquer API (interface de programação de aplicações — a forma como programas conversam entre si), encapsular numa tool MCP, e todo client compatível com MCP no planeta pode usar.

O handshake de capacidades

Quando um client se conecta pela primeira vez a um server, eles negociam:

Client: "Eu suporto tools, resources e prompts. O que você tem?"
Server: "Eu forneço 3 tools e 2 resources. Aqui estão."
Client: "Entendi. Pronto."

Isso significa que clients não precisam saber o que um server oferece antecipadamente. Servers podem adicionar ou remover features sem quebrar nada. Clients diferentes podem usar o mesmo server de formas diferentes. É evolução elegante, não acoplamento frágil.

O que não é perfeito

Vamos não fingir que isso é impecável. Em março de 2026:

Segurança ainda é problema seu. Um MCP server pode fazer tudo que você der permissão pra fazer. Um server malicioso poderia vazar dados através de tool calls. Não tem sandboxing nativo — nenhum isolamento automático do resto do seu sistema. Você confia em cada server da mesma forma que confia em qualquer pacote npm que instala. Pensa nisso por um segundo.

Descoberta é uma bagunça. Encontrar o MCP server certo pro seu caso significa navegar registries como mcpservers.org ou glama.ai/mcp/servers. Ainda não tem um marketplace centralizado e verificado. A qualidade varia absurdamente.

Debug é sofrido. Quando uma tool call falha, as mensagens de erro geralmente passam por múltiplas camadas — client, protocolo, server, API subjacente — e saem do outro lado como uma papa. Tá melhorando, mas ainda dói.

Overhead de performance existe. Toda tool call é uma ida e volta JSON-RPC — uma mensagem de requisição-resposta em formato JSON. Pra servers STDIO locais, isso é desprezível. Pra servers remotos via HTTP, a latência se acumula quando a IA encadeia múltiplas chamadas.

O que isso significa pra você

Se você usa ferramentas de IA pra código como Claude Code ou Cursor: MCP significa que sua IA ganha habilidades novas sem atualização de software. Apareceu um MCP server novo pro Jira? Instala, e sua IA gerencia seus tickets. Server novo pra AWS? Sua IA gerencia sua infra. Você não espera o vendor da ferramenta construir integrações — a comunidade constrói.

Se você constrói ferramentas ou APIs: MCP significa que você escreve uma integração e funciona com Claude, Cursor, Windsurf, Cline e todo futuro client compatível com MCP. Um server, dezenas de clients. Essa é a matemática do USB.

Se você é founder: construir um MCP server pro seu produto tá se tornando o mínimo esperado, como construir uma API REST era 10 anos atrás. Se sua ferramenta de dev não tem um MCP server, seus usuários vão perguntar por quê.

O ecossistema em março de 2026

  • Servers oficiais da Anthropic: PostgreSQL, GitHub, Filesystem, Brave Search, Puppeteer, Google Maps, Slack, e mais — veja o repositório de MCP servers
  • Servers enterprise da AWS, Cloudflare, Sentry
  • Servers da comunidade pra Docker, Kubernetes, Notion, Linear, Figma, Stripe — centenas e contando
  • O roadmap de 2026 foca em comunicação agente-a-agente, escalabilidade horizontal, e um mecanismo de descoberta .well-known pra servers se anunciarem automaticamente

USB matou o carregador proprietário. MCP mata integrações customizadas.

MCP é a coisa mais importante que aconteceu com ferramentas de IA desde que as janelas de contexto — a memória de trabalho da IA — ficaram grandes o suficiente pra caber um codebase real. Não é sexy. É um protocolo JSON-RPC sobre stdio. Mas USB também não era sexy, e matou todo conector proprietário no caminho.

A coisa mais inteligente que você pode fazer agora: pare de ler documentos de especificação. Instale um MCP server de Postgres, conecte ao Claude Code, e pergunte sobre seu banco de dados. Você vai entender MCP em 30 segundos.

A especificação é pra quem constrói o protocolo. Você tá usando. 😹