mcp

MCP servers para Claude Code: o guia prático pra programar com IA em 2026

Model Context Protocol (MCP): o que é, como criar server e client em 10 minutos, e os 7 MCP servers que vale conectar ao Claude Code em 2026.

Felipe Fontoura 10 min de leitura claude code · agentes ia · model context protocol

Em 2025, a evolução da IA aconteceu em 3 ondas:

  1. ChatGPT puro (2022-2023): conversava, mas não fazia nada. Útil pra brainstorm, inútil pra trabalho real.
  2. Function Tools (2023-2024): IA aprendeu a chamar funções externas — busca web, banco de dados, sua API. Útil, mas cada integração era custom code.
  3. MCP (2024-2026): protocolo padrão pra conectar IA a qualquer ferramenta — uma vez e funciona em toda IA compatível.

Se você usa Claude Code, Cursor, ou Claude Desktop e ainda não conectou nenhum MCP server, está deixando 70% da capacidade da ferramenta na mesa. Esse guia é a versão prática de tudo que você precisa: o que é MCP, como criar seu primeiro server + client em 10 minutos, e os 7 MCPs que vale conectar agora.

Quer a versão vídeo: assiste em 12 minutos

O que é MCP, sem mistério

Model Context Protocol é um protocolo aberto criado pela Anthropic em novembro de 2024. Resolve um problema bem específico: como conectar uma IA a uma ferramenta externa sem escrever código de integração custom toda vez.

Antes de MCP:

  • Você queria que Claude lesse seus arquivos? Implementava função custom, dava ao Claude.
  • Queria que Cursor lesse mesmo arquivo? Implementava de novo, no formato Cursor.
  • Queria GPT? De novo, no formato OpenAI.

Com MCP:

  • Você implementa uma vez como MCP server
  • Conecta em qualquer cliente compatível (Claude Code, Claude Desktop, Cursor, Windsurf, etc.)
  • Mesma ferramenta, todos os ambientes

É como HTTP pra integração de IA. Pinta o protocolo, vence o ecossistema.

A arquitetura em 30 segundos

┌──────────────┐         ┌──────────────┐         ┌─────────────┐
│  MCP Client  │ ←──────→│  MCP Server  │ ←──────→│  Recurso    │
│  (Claude)    │  MCP    │  (sua tool)  │   API   │  (DB, API,  │
│              │ protocol│              │ nativa  │   arquivo)  │
└──────────────┘         └──────────────┘         └─────────────┘

MCP Server = o programa que expõe ferramentas/recursos MCP Client = a IA que consome ele (Claude Code, Cursor, etc.) Protocolo = JSON-RPC sobre stdio (terminal) ou HTTP+SSE

Você normalmente é o autor do server (escreve uma vez, expõe sua API/banco/serviço). Você é o usuário do client (configura no Claude pra usar o server).

As 3 ondas que levaram a MCP

Onda 1 — ChatGPT puro (2022-2023): “meio inútil”

ChatGPT bruto era conversa. Você perguntava, ele respondia. Pra qualquer tarefa real (“busca isso na minha base”, “atualiza esse ticket”, “lê esse arquivo”), você copiava manualmente.

Era impressionante. Não era ferramenta. Era brinquedo.

Onda 2 — Function Tools (2023-2024): “começou a virar útil”

OpenAI lançou function calling. Anthropic seguiu com tool use. De repente:

  • IA pode buscar Google, ler Wikipedia, calcular
  • IA pode chamar SUA API se você definir o schema da função
  • IA pode escrever código que executa em sandbox

Problema: cada integração era código custom. Se você quisesse Claude lendo seus 50 arquivos markdown do Obsidian, escrevia 200 linhas Python pra wrap. E essa wrap só funcionava no Claude — pra Cursor, refazia.

Útil pra um caso, insustentável em escala.

Onda 3 — MCP (2024-2026): “destravou consultoria de IA séria”

Anthropic publicou MCP open source em Nov/2024. Em 6 meses:

  • Anthropic, OpenAI, Google, Microsoft anunciaram suporte
  • Comunidade publicou ~500 MCP servers (filesystem, GitHub, Slack, Postgres, etc.)
  • Padrão virou de-facto

Por que importa pro consultor de IA: agora você pode entregar integração de IA na empresa do cliente num projeto de 1-2 semanas. Não 3 meses como antes.

Criando seu primeiro MCP server (10 minutos)

Vamos criar um MCP server simples que expõe uma ferramenta: “buscar nas minhas notas do Obsidian”. Stack: Node + TypeScript + SDK oficial da Anthropic.

Passo 1 — Setup do projeto

mkdir mcp-obsidian-server && cd $_
npm init -y
npm install @modelcontextprotocol/sdk typescript tsx
npm install -D @types/node

Passo 2 — server.ts mínimo

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
  CallToolRequestSchema,
  ListToolsRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { readdir, readFile } from "fs/promises";
import { join } from "path";

const VAULT_PATH = process.env.OBSIDIAN_VAULT_PATH ?? "/home/user/vault";

const server = new Server(
  { name: "obsidian-search", version: "0.1.0" },
  { capabilities: { tools: {} } },
);

// Declara as ferramentas que esse server expõe
server.setRequestHandler(ListToolsRequestSchema, async () => ({
  tools: [
    {
      name: "search_notes",
      description: "Search Obsidian markdown notes by keyword",
      inputSchema: {
        type: "object",
        properties: {
          query: { type: "string", description: "Keyword to search" },
        },
        required: ["query"],
      },
    },
  ],
}));

// Implementa o que cada ferramenta faz quando chamada
server.setRequestHandler(CallToolRequestSchema, async (req) => {
  if (req.params.name === "search_notes") {
    const query = (req.params.arguments as any).query.toLowerCase();
    const files = await readdir(VAULT_PATH, { recursive: true });
    const matches: string[] = [];

    for (const file of files) {
      if (typeof file !== "string" || !file.endsWith(".md")) continue;
      const content = await readFile(join(VAULT_PATH, file), "utf-8");
      if (content.toLowerCase().includes(query)) {
        matches.push(file);
      }
    }

    return {
      content: [
        {
          type: "text",
          text: `Encontradas ${matches.length} notas:\n${matches.join("\n")}`,
        },
      ],
    };
  }
  throw new Error(`Unknown tool: ${req.params.name}`);
});

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

Pronto. Server completo, 50 linhas.

Passo 3 — Conectar no Claude Desktop

Edita ~/Library/Application Support/Claude/claude_desktop_config.json (Mac) ou %APPDATA%\Claude\claude_desktop_config.json (Windows) ou ~/.config/Claude/claude_desktop_config.json (Linux):

{
  "mcpServers": {
    "obsidian": {
      "command": "tsx",
      "args": ["/path/to/mcp-obsidian-server/server.ts"],
      "env": {
        "OBSIDIAN_VAULT_PATH": "/home/user/Documents/MyVault"
      }
    }
  }
}

Reinicia Claude Desktop. No chat, pergunta: “busca nas minhas notas sobre ‘spec-driven’”. Claude vai chamar search_notes, ler os arquivos, retornar o resultado.

Acabou. Você acaba de dar superpoder ao Claude com 10 minutos de código.

Passo 4 — Conectar no Claude Code (CLI)

Mesma config, lugar diferente. Edita ~/.config/claude-code/mcp.json ou em .mcp.json no root do projeto (vira config compartilhado pra time):

{
  "mcpServers": {
    "obsidian": {
      "command": "tsx",
      "args": ["/path/to/server.ts"]
    }
  }
}

Roda claude no terminal. Pergunta a mesma coisa. Funciona idêntico.

Os 7 MCP servers que vale conectar agora

Lista curada pra programador/builder em 2026. Cortes feitos pela frequência de uso, não pela hype:

1. Filesystem (@modelcontextprotocol/server-filesystem)

O que faz: dá ao Claude acesso a diretórios específicos do seu HD (read + write).

Por que vale: indispensável. Sem ele, você fica copiando arquivos no chat manualmente. Com ele, “lê esse projeto e refatora” funciona de verdade.

Setup:

{
  "filesystem": {
    "command": "npx",
    "args": [
      "-y",
      "@modelcontextprotocol/server-filesystem",
      "/home/user/projects"
    ]
  }
}

2. GitHub (@modelcontextprotocol/server-github)

O que faz: Claude lê/cria issues, PRs, branches, commits via API GitHub.

Por que vale: “abre um PR com essas mudanças” passa a ser literal. Você nunca mais clica no botão “create pull request” do GitHub.

Setup: precisa de Personal Access Token GitHub.

3. Postgres / Sqlite (@modelcontextprotocol/server-postgres, -sqlite)

O que faz: Claude executa SQL direto no seu banco — com READ-ONLY mode opcional pra segurança.

Por que vale: análise ad-hoc fica trivial. “quantos usuários ativos tivemos no Q1?” vira pergunta natural, não 30 min de SQL + dashboard.

⚠️ Configure read-only em produção. Senão Claude pode rodar DROP TABLE se você pedir errado.

4. Brave Search / DuckDuckGo / Tavily

O que faz: Claude busca na web ao vivo.

Por que vale: Claude tem knowledge cutoff. Sem busca, ele alucina sobre versões novas de libs. Com busca, ele verifica.

Recomendo: Tavily se você quer melhor qualidade ($), Brave free se você tá começando.

5. Slack (@modelcontextprotocol/server-slack)

O que faz: Claude lê/envia mensagens em canais Slack.

Por que vale: “resume o que aconteceu no canal #engineering hoje” é case real e tira muita reunião. Bom pra tech lead.

⚠️ Privacidade: Claude lê mensagens privadas do canal autorizado. Pensa bem antes de conectar em workspace com dados sensíveis.

6. Puppeteer / Playwright (@modelcontextprotocol/server-puppeteer)

O que faz: Claude controla browser headless. Pode visitar páginas, tirar screenshot, scrappar dados.

Por que vale: “vai nessa página e me traz o JSON” funciona. Plus: pra testes E2E “abre o app e clica em login” → Claude executa.

7. Memory / Knowledge Base (@modelcontextprotocol/server-memory)

O que faz: persistência simples entre sessões — Claude pode lembrar fatos sobre você/projeto que ele anotou em sessões anteriores.

Por que vale: você não precisa explicar contexto toda vez. “Felipe é builder solo, foca em Base25, prefere Tailwind v4” — Claude grava uma vez, lembra sempre.

Bônus pra workflow Base25-style

  • Astro MCP (@astrojs/mcp — quando lançar): pra Claude entender estrutura Astro com convenções
  • shadcn MCP (shadcn@latest mcp — já existe): pra adicionar primitives via prompt
  • Anthropic MCP servers oficiais: monitoram em https://github.com/modelcontextprotocol/servers

Referências externas: Anthropic MCP introduction (post oficial do lançamento), Awesome MCP servers (lista curada pela comunidade). Pra aprofundar como agentes em produção usam MCP, ver Agentes de IA em produção e case real: 13 apps em 70 dias com MCP.

Anti-padrões: quando NÃO usar MCP

1. Pra ferramenta que você usa 1× por mês. Custo de setup > ganho. Use direto pela web.

2. Pra ação muito destrutiva sem confirmação. Sem auth/confirmação, Claude com MCP delete_database é roleta russa. Implemente confirmação na ferramenta server-side.

3. Em workspace com dados sensíveis sem fine-grained perm. MCP server tem permissão completa do processo onde roda. Se você dá acesso ao /home, Claude lê tudo. Use sandboxing (Docker, jail) se segurança importa.

4. Como atalho pra evitar aprender o sistema. Conectei Slack MCP e perguntei “me conta o que rolou”. Resposta: 800 mensagens resumidas. Inútil. Você ainda precisa saber o que perguntar. MCP não substitui clareza.

O que vem a seguir (MCP em 2027)

Hipóteses razoáveis (não predição):

  • MCP marketplaces com revenue-share (Anthropic talvez)
  • MCP servers self-hosted virando produto-saas (tipo “Postgres MCP managed”)
  • Standard de auth federada pra MCP (hoje é por-server, é dor)
  • MCP em IDE puro (Cursor, VSCode-AI-mode) virando default — sem precisar config separada

Pra ficar de olho: github.com/modelcontextprotocol.

Próximos passos

Se você ainda não tem nenhum MCP conectado, conecta o filesystem hoje. 5 minutos, valor instantâneo.

Se já tem alguns conectados e quer ir além — construir MCP server custom pra sua stack — o ebook SDD tem capítulo dedicado a integrar MCP num workflow .claude/ real:

→ Ebook SDD (gratuito com email)

Se quer aprender o workflow inteiro (SDD + Claude Code + MCP) aplicado a projeto real, em 6 semanas, com revisão na mão:

→ Formação Consultor AI — Academy

Perguntas frequentes

MCP funciona com OpenAI/GPT? Tecnicamente sim — OpenAI anunciou suporte em mar/2026. Na prática, melhor maturidade ainda é Anthropic (criadora). Mas a comunidade é cross-vendor.

Posso vender MCP servers? Pode. Mercado emergente. Alguns padrões: assinatura mensal pra MCP managed, one-time setup fee, freemium com tiers de uso.

MCP é seguro pra produção? Depende do server. O protocolo é OK. O risco está em (a) quais permissões o server tem e (b) se Claude pode chamar ações destrutivas. Sempre implemente confirm/dry-run pra ações destrutivas, e use service accounts com least-privilege.

Diferença prática entre MCP e Function Calling antigo? Function calling: você define schema por integração, código custom, vendor-locked. MCP: server uma vez, qualquer cliente conecta. A diferença é ecossistema, não capacidade técnica raw.

Posso conectar MCP num agente autônomo (não interativo)? Pode. Claude Code já roda em modo headless. MCP funciona idêntico. Use-case clássico: agente CI que roda spec + MCP filesystem + MCP GitHub pra implementar tasks autonomamente.

Como debugar MCP server que não conecta? Logs em ~/Library/Logs/Claude/mcp-server-<nome>.log (Mac) ou similar. Erros comuns: path errado no command, env var faltando, server crashando no startup. Testa o server standalone primeiro com tsx server.ts — se rodar limpo no terminal, problema é config do client.

Anthropic vai matar MCP a favor de proprietary? Improvável. Eles lançaram open-source explicitamente porque MCP só vale se virar padrão. Se for proprietário, OpenAI/Google fazem o deles e Anthropic fica de fora.

Posso usar MCP no claude.ai (web)? Não diretamente — Claude web ainda não suporta MCP servers locais (e nem deveria, por segurança). Suporte vai chegar via “Claude Hosted MCPs” (servers cloud que você autoriza). Por enquanto: MCP é Claude Code, Claude Desktop, Cursor, etc.

A IA não substitui quem pensa. Ela multiplica quem sabe construir.
Conhecer a Formação Consultor AI →

Quer receber os próximos?

Novos artigos, recursos e abertura de turmas direto no seu e-mail.

Sem spam. Só artigos novos da Library e abertura de turmas.