MCP (Model Context Protocol): O Guia Completo em Português [2026]

O MCP (Model Context Protocol) é o protocolo aberto que conecta modelos de IA às ferramentas, dados e sistemas que você já usa, sem gambiarra e sem integração frágil para cada serviço. A Anthropic lançou o padrão no fim de 2024 e, ao longo de 2025, ele virou a forma como os agentes de IA conversam com o mundo real: bancos de dados, repositórios no GitHub, planilhas, APIs internas, ferramentas de design. Na Marfin, a gente sentiu a diferença no dia a dia quando parou de copiar e colar contexto na mão e deixou o modelo buscar a informação sozinho.

A ideia por trás do MCP é simples de explicar e poderosa na prática. Em vez de cada aplicação de IA inventar seu próprio jeito de plugar uma ferramenta, todo mundo passa a falar a mesma língua. É a mesma lógica do USB-C: um conector único que serve para tudo. Antes do MCP, conectar um modelo a dez fontes de dados significava dez integrações diferentes, cada uma com seu formato, sua autenticação e seus bugs. Com o protocolo, você escreve o servidor uma vez e ele funciona em qualquer cliente compatível.

Este guia cobre o que é o MCP (Model Context Protocol), como a arquitetura funciona por dentro, quais servidores a gente mais usa, como ligar tudo isso ao Claude Code e ao Cursor AI, o que olhar em segurança e quanto custa. No final tem uma lista de dicas práticas para você sair usando hoje. É o texto que a gente gostaria de ter lido quando começou a montar nossos próprios fluxos com agentes.

O que é o MCP (Model Context Protocol)

O MCP (Model Context Protocol) é um padrão aberto, com SDKs em Python, TypeScript e outras linguagens, que define como uma aplicação de IA fornece contexto e ações a um modelo de linguagem. Em vez de o modelo ficar preso ao texto que você digita, ele ganha acesso estruturado a recursos externos: pode ler um arquivo, consultar uma tabela no Postgres, abrir um issue no GitHub ou disparar uma busca na web. Tudo isso por uma interface única que qualquer ferramenta pode implementar.

Antes de o protocolo existir, o problema era o que os engenheiros chamam de explosão combinatória. Se você tem M aplicações de IA e N ferramentas para conectar, precisa de M vezes N integrações. Cada nova ferramenta exige reescrever a cola para cada aplicação. O MCP transforma isso em M mais N: cada aplicação implementa o protocolo uma vez como cliente, cada ferramenta implementa o protocolo uma vez como servidor, e os dois se entendem sem código extra. Essa mudança de matemática é o que destravou a adoção em massa.

A adoção, aliás, foi rápida. O protocolo nasceu na Anthropic, mas em 2025 a OpenAI passou a suportar MCP nos seus produtos de agente, o Google DeepMind anunciou compatibilidade e a Microsoft integrou o padrão no ecossistema do Windows e do Copilot. Quando empresas que competem direto adotam o mesmo padrão, é sinal de que ele resolveu uma dor real. Hoje, IDEs como Cursor AI, Windsurf, Zed e Replit já leem servidores MCP de forma nativa, e o Claude Code trata isso como recurso de primeira classe.

Vale separar o que o MCP é do que ele não é. Ele não é um modelo de IA, não é uma biblioteca de agentes e não substitui o seu backend. O MCP é a camada de comunicação entre o modelo e as capacidades externas. Pense nele como o protocolo HTTP da era dos agentes: ninguém liga para os detalhes do HTTP no dia a dia, mas é ele que faz a web inteira conversar. Se você já leu nosso conteúdo sobre agentes de IA para programação, o MCP é exatamente a peça que dá braços e pernas para esses agentes.

Como o MCP funciona por dentro

Para usar bem o MCP (Model Context Protocol), ajuda entender a arquitetura. Ela tem três papéis principais e algumas primitivas que definem o que cada lado pode fazer. Não é complicado, mas a clareza desses conceitos evita muita confusão quando algo dá errado na configuração.

Host, cliente e servidor

O host é a aplicação de IA com a qual você interage. Pode ser o Claude Desktop, o Claude Code rodando no terminal, o Cursor AI ou qualquer app que embuta um modelo. O host é quem orquestra a conversa e decide quando chamar uma ferramenta externa. Dentro do host vive o cliente MCP, que mantém uma conexão um para um com cada servidor. Se você liga três servidores, o host roda três clientes em paralelo, cada um cuidando da sua conexão.

O servidor MCP é o programa que expõe as capacidades. Ele pode rodar localmente na sua máquina, comunicando por stdio (entrada e saída padrão do processo), ou rodar remoto, comunicando por HTTP. Em 2025 o transporte remoto evoluiu para o chamado Streamable HTTP, que simplificou conexões persistentes e tornou os servidores remotos bem mais estáveis do que a versão antiga baseada só em SSE. Um servidor de filesystem, por exemplo, roda local e dá ao modelo acesso a pastas específicas. Já um servidor de busca na web costuma rodar remoto, atrás de uma API.

O fluxo é direto. O host descobre quais ferramentas cada servidor oferece, apresenta essa lista ao modelo, e quando o modelo decide que precisa de uma ação, o cliente manda a requisição para o servidor certo. O servidor executa, devolve o resultado, e o modelo continua o raciocínio com a informação nova em mãos. Tudo isso acontece em segundos e, do seu lado, parece mágica: você pede algo em linguagem natural e o agente vai lá, busca os dados e responde.

Tools, resources e prompts

Um servidor MCP expõe três tipos de primitiva. As tools são funções que o modelo pode chamar para executar uma ação, como criar um registro no banco, enviar uma mensagem ou rodar um teste. São o que dá poder de agir ao agente. Os resources são fontes de dados que o modelo pode ler para ganhar contexto, como o conteúdo de um arquivo, o resultado de uma query ou um documento. E os prompts são modelos de instrução pré-montados que o servidor oferece para tarefas recorrentes, poupando o usuário de reescrever o mesmo pedido toda vez.

Do lado do cliente também existem primitivas. O sampling permite que o servidor peça ao host para gerar uma resposta do modelo, útil quando o próprio servidor precisa de um raciocínio de IA no meio do processo. Os roots definem quais diretórios ou escopos o servidor pode acessar, criando uma fronteira de segurança. E a elicitation, adicionada nas versões mais recentes do protocolo, deixa o servidor pedir informação extra ao usuário durante a execução, como uma confirmação ou um dado que faltou. Essa separação clara de responsabilidades é o que mantém o sistema previsível mesmo quando você conecta muitos servidores ao mesmo tempo.

MCP na prática com Claude Code e Cursor

Claude Code é a ferramenta de programação com IA que mais usamos na Marfin, e é também onde o MCP (Model Context Protocol) brilha mais no nosso fluxo. O Claude Code roda no terminal, lê o projeto inteiro e executa tarefas completas de forma autônoma. Quando você pluga servidores MCP nele, o agente deixa de ficar limitado ao código local e passa a consultar bancos de dados, abrir pull requests e buscar documentação sem que você precise sair do terminal. Se você ainda não usa, vale começar pelo nosso tutorial do Claude Code.

Ligar um servidor no Claude Code é questão de poucos comandos. Você adiciona o servidor com o comando de configuração, informa o transporte (local via stdio ou remoto via HTTP) e as credenciais quando necessário. A partir daí, o agente já enxerga as ferramentas daquele servidor e decide sozinho quando usá-las. No nosso caso, plugamos o servidor do Supabase e passamos a pedir coisas como "verifique quantos usuários se cadastraram esta semana e gere um resumo", sem abrir o painel nem escrever SQL na mão. O agente faz a query, lê o resultado e responde em português.

O Cursor AI, a IDE que usamos para building no dia a dia, também lê servidores MCP de forma nativa. A configuração fica em um arquivo de projeto e, uma vez ligada, qualquer membro do time que abrir o repositório herda os mesmos servidores. Isso padroniza o ambiente: todo mundo trabalha com o agente conectado às mesmas fontes. Para quem está começando do zero, nosso tutorial do Cursor AI mostra o caminho completo, e o MCP entra como o passo que transforma a IDE num ambiente de verdade conectado ao resto da operação.

Modelos importam aqui, e muito. A gente roda os fluxos de agente em cima do Claude Opus 4.8, lançado em maio de 2026, com seus Dynamic Workflows e o controle de esforço que deixa você calibrar quanto o modelo pensa antes de agir. Para tarefas mais pesadas de engenharia, o Opus 4.7 entrega 87,6% no SWE-bench Verified com janela de 200 mil tokens de contexto. Quanto melhor o modelo decide quando e como chamar uma ferramenta MCP, menos correção manual você faz depois. Se quiser entender a família de modelos a fundo, temos um guia de como usar o Claude que cobre isso.

Servidores MCP que mais usamos

A graça do MCP (Model Context Protocol) está no ecossistema de servidores prontos. Em vez de escrever integração para cada serviço, você instala um servidor existente e parte para o uso. Existe um registro oficial de servidores que cresceu muito ao longo de 2025, e a maioria das ferramentas populares já tem o seu, mantido pela própria empresa ou pela comunidade.

O servidor do Supabase é o que mais aparece nos nossos projetos. Como o Supabase é o backend padrão que adotamos para vibe coding, plugar o servidor MCP dele significa deixar o agente consultar o banco PostgreSQL, checar políticas de RLS, ler logs e até rodar migrações com supervisão. A combinação de agente mais Supabase mais MCP virou a espinha dorsal de vários protótipos que tiramos do papel em dias. Para quem quer dominar essa base, vale o nosso tutorial do Supabase.

O servidor do GitHub é outro que roda em quase todo fluxo. Com ele, o agente lista issues, abre pull requests, comenta em revisões e lê o histórico de commits sem que você troque de janela. Junto dele costumamos usar o servidor de filesystem, que dá ao modelo acesso controlado a pastas específicas, e o servidor de busca na web, que mantém o agente atualizado com informação que não estava no contexto. Há também servidores para Slack, Notion, Figma, Stripe, Sentry e bancos como Postgres direto, cada um abrindo uma porta nova para o agente agir dentro da sua stack. Se você está montando o ambiente da sua empresa do zero, nosso guia de tech stack para startups brasileiras ajuda a decidir o que conectar primeiro.

Escrever o seu próprio servidor também é viável e mais simples do que parece. Com os SDKs oficiais, você descreve as tools que quer expor, conecta na sua API interna e pronto: o agente passa a operar dentro do seu sistema proprietário. Foi assim que ligamos algumas ferramentas internas da Marfin que nenhum servidor público cobriria. O trabalho de escrever o servidor uma vez se paga rápido, porque a partir dali ele funciona em qualquer cliente compatível, do Claude Code ao Cursor.

MCP vs integrações tradicionais e plugins

Antes do MCP (Model Context Protocol), cada plataforma tinha seu próprio sistema de plugins. Quem lembra dos plugins do ChatGPT sabe a dor: você construía a integração para um ecossistema fechado, presa a uma única plataforma, e se quisesse levar para outro lugar precisava começar do zero. O MCP quebra esse aprisionamento porque é aberto e neutro. O servidor que você escreve hoje serve para o Claude, para o Cursor, para o Windsurf e para qualquer cliente que adote o padrão amanhã.

Comparado a chamar APIs direto pelo código, a diferença é o nível de abstração e a descoberta automática. Com uma integração tradicional, você programa exatamente qual endpoint chamar, quando e com quais parâmetros, tudo na mão. Com o MCP, o servidor anuncia suas capacidades e o modelo decide em tempo real qual ferramenta usar para resolver o pedido. Você ganha flexibilidade: adiciona um servidor novo e o agente já incorpora aquela capacidade sem você reescrever a lógica de orquestração. Para casos simples e fixos, a chamada de API direta ainda é mais previsível. Para fluxos abertos, onde o agente precisa raciocinar sobre qual ação tomar, o MCP é o que faz diferença.

Onde o MCP não substitui nada é na camada de regra de negócio. Ele padroniza a comunicação, mas a lógica do que pode ou não acontecer continua sendo sua responsabilidade, dentro do servidor. Pensar no MCP como bala de prata leva a erro. Ele é uma camada de transporte e descoberta muito bem desenhada, não um substituto para arquitetura. Quem entende isso usa o protocolo no lugar certo e evita frustração. Se o tema de agentes autônomos te interessa, o tutorial do Devin AI mostra outro modelo de agente que também se beneficia desse tipo de conexão padronizada.

Segurança no MCP

Dar a um agente o poder de ler bancos e executar ações exige cuidado com segurança, e o MCP (Model Context Protocol) não foge disso. O risco mais comentado é o de injeção de prompt: um dado externo, como o texto de um issue ou o conteúdo de uma página, carrega instruções escondidas que tentam sequestrar o comportamento do modelo. Como o agente lê esses dados via servidores MCP, um conteúdo malicioso pode tentar fazer o modelo agir contra você. A defesa começa por nunca dar ao agente mais permissão do que a tarefa precisa.

Há outros vetores a vigiar. O envenenamento de ferramenta acontece quando um servidor mal-intencionado descreve suas tools de forma enganosa para induzir o modelo a usá-las de jeito errado. O problema do delegado confuso surge quando o agente usa uma credencial poderosa para executar algo que o usuário final não deveria poder fazer. Por isso, instale apenas servidores de fontes confiáveis, revise o que cada servidor expõe e prefira servidores oficiais mantidos pela própria empresa do serviço. Tratar servidor MCP de terceiro como você trataria qualquer dependência de código é o método certo: audite antes de confiar.

No transporte remoto, a recomendação é usar OAuth para autenticação dos servidores HTTP, com escopos bem definidos e tokens de curta duração. Os roots do protocolo ajudam a limitar quais diretórios um servidor local enxerga, e as confirmações de execução, quando o host pede sua aprovação antes de uma ação sensível, são a última linha de defesa. Na Marfin, a regra é simples: ambiente de produção nunca recebe um servidor sem revisão, e ações destrutivas sempre passam por aprovação humana. O Claude Opus 4.8 trouxe quatro vezes menos erros não reportados do que a geração anterior, o que reduz o risco de o agente fazer algo errado em silêncio, mas a supervisão continua sendo sua.

Preços e planos

O MCP (Model Context Protocol) em si é gratuito e de código aberto, distribuído sob licença permissiva. Não existe assinatura do protocolo, não há taxa de licença e os SDKs oficiais são abertos. Você pode escrever servidores, rodar clientes e montar toda a sua arquitetura sem pagar nada pelo padrão em si. O custo aparece em três lugares diferentes, e entender essa separação evita surpresa na fatura.

O primeiro custo é o do modelo que roda o agente. Se você usa o Claude Code com a API da Anthropic, paga pelo consumo de tokens do modelo escolhido, seja o Opus 4.8, o Opus 4.7, o Sonnet 4.5 ou o Haiku 4.5, que é o mais barato e rápido para automações. O fast mode do Opus 4.8 chegou três vezes mais barato que a geração anterior, o que ajuda em fluxos de agente que fazem muitas chamadas. Quem usa o Claude via assinatura do claude.ai tem o Sonnet 4.5 como modelo padrão no plano.

O segundo custo é o dos serviços que você conecta. Um servidor MCP do Supabase é grátis para usar, mas o Supabase tem seus próprios planos: Free para começar, Pro a US$ 25 por mês, Team a US$ 599 e Enterprise sob consulta. O mesmo vale para qualquer serviço pago que você plugue via MCP, do Stripe ao Notion. O terceiro custo, quando existe, é a infraestrutura para hospedar seus servidores remotos, caso você escolha rodá-los na nuvem em vez de local. Servidores locais via stdio não custam nada além da sua própria máquina. Para a maioria dos times que estão começando, dá para montar um setup completo de agentes com MCP gastando muito pouco, escalando o investimento só quando o uso justifica.

7 dicas para usar o MCP na prática

1. Comece com um servidor só. Não pluge dez servidores de uma vez. Conecte um, entenda como o agente decide usar as ferramentas dele e só então adicione o próximo. Isso facilita demais o diagnóstico quando algo não funciona como esperado.

2. Prefira servidores oficiais. Quando a própria empresa do serviço mantém o servidor MCP, você ganha em segurança e em estabilidade. Servidores da comunidade são ótimos, mas exigem que você audite o código antes de confiar nas ações que eles executam.

3. Limite o escopo de cada servidor. Use os roots para restringir quais pastas um servidor local acessa e dê ao agente só as permissões que a tarefa precisa. Um servidor de filesystem apontado para a raiz do disco é pedido para acidente.

4. Ative confirmação para ações destrutivas. Configure o host para pedir aprovação antes de deletar, sobrescrever ou rodar comandos que mudam produção. Essa fricção de um segundo já evitou estrago em vários dos nossos fluxos.

5. Escreva seu próprio servidor para sistemas internos. Se a sua empresa tem uma API ou ferramenta que nenhum servidor público cobre, escreva o seu com os SDKs oficiais. O trabalho se paga rápido porque o servidor passa a funcionar em todos os clientes compatíveis.

6. Padronize a configuração no repositório. Deixe os servidores MCP definidos no arquivo de projeto, versionado no Git. Assim todo mundo do time herda o mesmo ambiente ao abrir o repositório, sem configurar nada na mão.

7. Combine MCP com bons prompts. Um agente conectado a servidores potentes ainda depende de instruções claras. Vale investir em prompt engineering para que o modelo escolha a ferramenta certa na hora certa e não desperdice chamadas.

O MCP deixou de ser novidade técnica para virar a base de como os agentes de IA operam de verdade. Quem trabalha com IA em 2026 e ainda não conectou seus modelos às ferramentas via MCP está deixando produtividade na mesa, copiando contexto na mão quando o agente poderia buscar sozinho. A barreira de entrada é baixa, o protocolo é aberto e o ecossistema de servidores cobre quase tudo que uma operação precisa. Na Marfin, foi o que transformou o agente de um assistente que sugere em um colega que executa. Pegue um servidor, plugue no Claude Code ou no Cursor, e em poucos minutos você vai entender por que esse padrão pegou tão rápido.

Leia também:

TL;DR