Você usa IA pra programar. Faz perguntas, cola logs de erro, talvez deixa ela escrever uma função ou duas. Ela responde com base no que sabe — que é o que aprendeu durante o treinamento, congelado no tempo como um mamute no gelo. Ela não consulta seu banco de dados. Não abre seu GitHub. Não pesquisa se aquela biblioteca que você vai instalar foi abandonada desde 2023. Sua IA vive numa caixa. 😼

A caixa é o problema. Uma IA que não consegue tocar na sua infraestrutura real é só um patinho de borracha muito eloquente.

Isso mudou em novembro de 2024 quando a Anthropic lançou o MCP (Model Context Protocol) — uma forma padronizada de conectar ferramentas de IA a serviços externos. Pense nisso como portas USB para sua IA: plugue um "server" (um programinha rodando em background), e de repente seu agente de IA pode consultar bancos de dados, gerenciar issues no GitHub, pesquisar na web ou controlar um navegador. Em março de 2026, o registro oficial de servidores MCP lista milhares desses plugins. A maioria são demos. Alguns estão quebrados. Cinco realmente importam pro dia a dia.

Vou te guiar por cada um, com instruções de instalação que você copia e cola em menos de cinco minutos.

Antes de começar: onde ficam as configs do MCP

Servidores MCP funcionam com qualquer client compatível — Claude Code, Claude Desktop, Cursor, Windsurf, Cline. Vou usar exemplos do Claude Code, mas o formato de config é praticamente idêntico em todos.

Seu arquivo de config fica aqui:

# Claude Code (nível de projeto)
.mcp.json

# Claude Code (global)
~/.claude.json

# Claude Desktop
~/Library/Application Support/Claude/claude_desktop_config.json  # macOS
~/.config/Claude/claude_desktop_config.json                       # Linux

Todo servidor segue o mesmo padrão:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "@package/server-name"],
      "env": {
        "API_KEY": "sua-chave-aqui"
      }
    }
  }
}

npx executa um pacote Node.js sem instalar globalmente. A flag -y pula o prompt de confirmação. Essa é toda a cerimônia necessária. Agora a parte boa.

1. PostgreSQL — converse com seu banco de dados em português

O que faz: Sua IA lê o schema do banco (a estrutura — tabelas, colunas, tipos), executa queries SQL (a linguagem que bancos de dados falam), e retorna resultados reais. Chega de copiar output do terminal e colar no chat.

Por que você liga: Metade do desenvolvimento é "olhar o banco, entender os dados, escrever uma query". Esse servidor transforma isso numa conversa.

Config:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-postgres",
        "postgresql://user:pass@localhost:5432/mydb"
      ]
    }
  }
}

Você diz: "Me mostra todos os usuários que se cadastraram essa semana mas nunca compraram nada." Claude roda SQL real contra seu banco. Dados reais voltam. Você diz: "Cria um index pra acelerar isso." Claude analisa o plano de execução e constrói o index correto.

O servidor expõe três ferramentas: query (rodar SQL somente leitura), list_tables e describe_table.

Segurança: Crie um usuário de banco somente leitura. Não entregue suas credenciais de admin pra nenhuma ferramenta automatizada:

CREATE USER mcp_readonly WITH PASSWORD 'senha_segura';
GRANT CONNECT ON DATABASE mydb TO mcp_readonly;
GRANT USAGE ON SCHEMA public TO mcp_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO mcp_readonly;

Veredicto: Primeiro servidor que instalo em todo projeto. Economiza 30+ minutos por dia de arqueologia copy-paste. 😸

2. GitHub — repos sem abrir o navegador

O que faz: Integração completa com GitHub — issues, pull requests (PRs — propostas de alteração de código), busca no código, operações com arquivos. Tudo pelo seu agente de IA.

Por que você liga: Ficar alternando entre terminal, chat e GitHub mata a concentração. Esse servidor te mantém num lugar só.

Config:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_seu_token_aqui"
      }
    }
  }
}

Você precisa de um personal access token — pegue um em github.com/settings/tokens. Scopes necessários: repo, read:org, read:user.

Agora você pode dizer: "Cria uma issue pro bug de timeout no login com o stack trace que acabei de te mostrar." Ou: "Revisa a PR #47 e comenta problemas de segurança." Claude lê o diff, analisa o código, posta comentários de review reais no GitHub.

Ferramentas principais: create_issue, list_pull_requests, search_code, create_branch, get_file_contents. Mais de uma dúzia no total.

Jogada de mestre: Combine com o servidor Postgres. "Verifica os logs de erro no banco, encontra o código relevante no GitHub, cria uma issue com os dois." Um prompt. Três ferramentas. Zero abas do navegador. 😹

Veredicto: Segundo servidor que instalo. A interface web do GitHub serve pra navegar. Pra trabalhar, isso aqui é mais rápido.

3. Filesystem — acesso a arquivos com proteção

O que faz: Dá ao seu agente de IA acesso pra ler, escrever, buscar e gerenciar arquivos — mas só dentro dos diretórios que você autoriza explicitamente. Ele não vai passear pelas suas chaves SSH ou arquivos .env.

Config:

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

Liste múltiplos diretórios — o servidor restringe o acesso apenas a esses caminhos. O servidor bloqueia tentativas de path traversal (truques como ../../etc/passwd).

Ferramentas: read_file, write_file, create_directory, list_directory, move_file, search_files, read_multiple_files.

Quem precisa: Usuários do Claude Desktop, principalmente. O Claude Code já tem acesso ao filesystem embutido, então esse servidor é redundante lá. Mas pro Claude Desktop — onde a IA normalmente não consegue tocar nos seus arquivos — é essencial. O sandboxing de diretórios (restringir acesso a pastas específicas) é uma feature de segurança genuinamente boa.

Veredicto: Pule se você usa Claude Code. Instale imediatamente se usa Claude Desktop.

4. Brave Search — dados da web em tempo real

O que faz: Busca na web através da API do Brave Search. Sua IA pesquisa coisas ao vivo em vez de chutar baseado nos dados de treinamento.

Por que você liga: "Qual o preço atual de um VPS na Hetzner?" "Essa biblioteca ainda é mantida?" "Qual a última versão do Next.js?" Essas perguntas precisam de respostas em tempo real. Dados de treinamento não sabem o que aconteceu terça passada.

Config:

{
  "mcpServers": {
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_sua_chave_aqui"
      }
    }
  }
}

Pegue uma API key gratuita em brave.com/search/api. Plano free: 2.000 queries/mês, 1 request/segundo. Pra um dev solo, é mais que suficiente. Plano pago começa em $5/mês por 20.000 queries se você estourar o limite gratuito.

Duas ferramentas: brave_web_search (busca web geral com paginação) e brave_local_search (busca de negócios locais).

Uso inteligente: Valide as sugestões de arquitetura da sua IA antes de se comprometer. "Pesquisa problemas conhecidos com Prisma 6.x e PostgreSQL 17" é uma excelente checagem de sanidade antes de você estar três dias no meio de uma implementação.

Veredicto: Preenche a maior lacuna da IA pra programação — a incapacidade de verificar o que é verdade agora. 😼

5. Puppeteer — automação de navegador por conversa

O que faz: Controla um navegador headless (um navegador Chromium que roda invisível, sem janela). Sua IA navega em páginas, tira screenshots, clica em botões, preenche formulários, extrai conteúdo de sites renderizados com JavaScript.

Config:

{
  "mcpServers": {
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Sem API keys. Sem configuração. O Puppeteer baixa o Chromium automaticamente.

Ferramentas: puppeteer_navigate, puppeteer_screenshot, puppeteer_click, puppeteer_fill, puppeteer_evaluate (rodar JavaScript na página).

Diga: "Vai em localhost:3000, tira screenshot da página de login, me diz se tá renderizando certo." Depois: "Preenche credenciais de teste e envia." Claude navega, preenche os campos, clica em enviar, tira screenshot do resultado.

Eu uso pra testes de regressão visual — "Navega em cada rota e tira screenshot" me dá um snapshot visual que o Claude pode comparar com os layouts esperados. Sem setup de Playwright, sem framework de teste. Só "vai lá e olha a página."

Atenção: Isso roda um navegador real. Cada instância come 200-500MB de RAM. Não deixe rodando num notebook com memória apertada. O servidor limpa tudo automaticamente quando você fecha o client MCP.

Veredicto: O servidor mais divertido dessa lista. Automação de navegador por linguagem natural é genuinamente satisfatório. Essencial pra trabalho frontend e web scraping. 😸

A config completa — copia e cola

Todos os cinco servidores, um arquivo:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres",
               "postgresql://mcp_readonly:password@localhost:5432/mydb"]
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "ghp_xxx"
      }
    },
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem",
               "/home/user/projects"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "BSA_xxx"
      }
    },
    "puppeteer": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-puppeteer"]
    }
  }
}

Substitua os valores placeholder pelas suas credenciais reais. Salve em .mcp.json na raiz do projeto ou ~/.claude.json pra acesso global.

Encontrando mais (e sabendo quando parar)

O registro oficial fica em github.com/modelcontextprotocol/servers. O mcpservers.org lista servidores da comunidade. Navegue se tiver curiosidade.

Mas resista à tentação de instalar 15 servidores "por precaução". Cada um é um processo rodando. Cada um adiciona tempo de startup. Cada um é uma superfície de ataque — um ponto de entrada potencial pra problemas de segurança. 80% dos devs precisam de dois ou três servidores, no máximo.

Agora você é perigoso

Você começou com uma IA que vivia numa caixa de texto. Agora você tem uma que consulta seu banco de dados, gerencia seu GitHub, pesquisa a web ao vivo e controla um navegador. O protocolo por baixo — JSON-RPC (um formato simples de mensagem) sobre stdio (entrada/saída padrão, como programas conversam entre si) — é chato. Protocolos chatos que funcionam são exatamente o que a gente precisava.

Esses cinco servidores cobrem 90% do que um dev solo precisa. Todo o resto no diretório MCP é ou ferramental de nicho pra casos de uso específicos ou uma demo que vai quebrar no instante que você depender dela de verdade. Comece com Postgres e GitHub. Adicione Brave Search quando precisar de dados em tempo real. Adicione Puppeteer quando quiser se sentir em 2030.

A caixa está aberta. Sua IA tem mãos agora. Tenta não deixar ela derrubar nada importante. 😹