Integrações do Claude Code: Servidores MCP, IDE e CI/CD

O Claude Code é poderoso por si só. Lê os seus ficheiros, escreve código, executa comandos. Mas neste momento, cada vez que precisa que ele saiba algo fora do seu projeto — um esquema de base de dados, uma issue do GitHub, um erro do Sentry — está a copiar e colar. Você é o intermediário.

E se o Claude pudesse simplesmente... ir buscar essa informação sozinho?

É exatamente isso que os servidores MCP fazem. Apenas 8% dos setups na nossa análise os configuram, mas esses obtêm 7.5/10 em média. A razão é simples: os servidores MCP eliminam o imposto do copiar e colar que consome a maior parte do tempo de sessão.

Vamos configurar um agora mesmo. Terá tudo a funcionar em menos de cinco minutos.

O seu primeiro servidor MCP: GitHub

MCP significa Model Context Protocol. É um padrão aberto que permite ao Claude comunicar com serviços externos através de uma interface estruturada. Um servidor MCP é um pequeno programa que corre em segundo plano e dá ao Claude acesso a ferramentas — como pesquisar issues, consultar bases de dados ou ler documentação.

Comecemos pelo servidor MCP do GitHub porque a configuração é muito simples e o benefício é imediato.

Adicione isto ao seu .claude/settings.json:

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

Vai precisar de um GitHub Personal Access Token. Vá a GitHub > Settings > Developer Settings > Personal access tokens > Generate new token. Dê-lhe o scope repo.

Reinicie o Claude Code e experimente:

> Lista os meus 5 pull requests mais recentes

O Claude não pede que cole nada. Chama o servidor MCP do GitHub, obtém os seus PRs e mostra-os. Agora experimente:

> Qual é o estado da issue #42? Lê os comentários também.

O Claude obtém a issue, lê a discussão e tem o contexto completo. Quando diz "trabalha na issue #42", ele sabe realmente o que a issue #42 diz — sem copiar a descrição para o chat.

É todo o propósito do MCP: o Claude obtém o contexto sozinho em vez de ser você a fazer de estafeta.

O servidor MCP de base de dados (o que muda tudo)

Se usa PostgreSQL, este é o servidor MCP que o vai fazer perguntar como trabalhava sem ele.

Adicione ao .claude/settings.json:

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "postgresql://dev:dev@localhost:5432/myapp_dev"
      }
    }
  }
}

O que isto desbloqueia:

• O Claude lê os seus esquemas de tabelas reais antes de escrever queries — acabou-se adivinhar nomes de colunas
• Pode executar queries SELECT para compreender a forma dos dados
• A geração de migrações torna-se precisa porque o Claude vê o esquema real atual
• Erros de nomes de colunas são apanhados antes de executar o código

Importante: Use um utilizador de base de dados apenas de leitura. O Claude não precisa de acesso de escrita para compreender o seu esquema:

CREATE USER claude_readonly WITH PASSWORD 'secure_password';
GRANT CONNECT ON DATABASE myapp_dev TO claude_readonly;
GRANT USAGE ON SCHEMA public TO claude_readonly;
GRANT SELECT ON ALL TABLES IN SCHEMA public TO claude_readonly;

Experimente. Pergunte ao Claude: "Mostra-me o esquema da tabela users." Ele consulta a base de dados diretamente e dá-lhe as colunas exatas, tipos e restrições. Acabou-se o "Vou assumir que o esquema é mais ou menos assim."

Mais servidores MCP que valem a pena configurar

Assim que apanhar o jeito, aqui estão os outros servidores que merecem o seu lugar:

Slack — pesquisar conversas da equipa

{
  "mcpServers": {
    "slack": {
      "command": "npx",
      "args": ["-y", "@anthropic/mcp-server-slack"],
      "env": {
        "SLACK_BOT_TOKEN": "xoxb-seu-token-bot"
      }
    }
  }
}

A trabalhar numa funcionalidade que foi discutida no Slack na semana passada? Em vez de ser você a resumir a conversa, o Claude pesquisa-a diretamente.

Sentry — obter relatórios de erros

{
  "mcpServers": {
    "sentry": {
      "command": "npx",
      "args": ["-y", "@sentry/mcp-server"],
      "env": {
        "SENTRY_AUTH_TOKEN": "seu_token_sentry",
        "SENTRY_ORG": "sua-org",
        "SENTRY_PROJECT": "seu-projeto"
      }
    }
  }
}

A depurar um erro de produção? O Claude obtém a stack trace exata, número de utilizadores afetados e frequência do erro do Sentry. Acabou-se fazer capturas de ecrã de relatórios de erros e colá-los no chat.

Context7 — documentação em tempo real

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

Este é sorrateiramente útil. Em vez de se fiar nos dados de treino (que podem estar desatualizados), o Claude obtém a documentação atual para a versão exata da biblioteca que está a usar. Particularmente útil para bibliotecas que evoluem depressa como Next.js, React ou Prisma onde a API muda entre versões.

Filesystem — aceder a ficheiros fora do seu projeto

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/Users/voce/projetos/libs-partilhadas",
        "/Users/voce/projetos/design-system"
      ]
    }
  }
}

Monorepo? Precisa que o Claude referencie o seu design system enquanto edita uma funcionalidade? O servidor filesystem dá-lhe acesso a diretórios fora do projeto atual.

Integração IDE: encontrar o Claude onde programa

VS Code

A forma mais rápida de começar:

1. Instale a extensão Claude Code do marketplace do VS Code
2. Abra o seu projeto
3. Prima Cmd+Shift+P (Mac) ou Ctrl+Shift+P (Windows/Linux) e escreva "Claude"
4. Selecione "Claude Code: Open Panel"

A extensão VS Code dá ao Claude acesso aos seus ficheiros abertos, saída do terminal, erros TypeScript, avisos ESLint — tudo sem copiar e colar.

JetBrains (IntelliJ, WebStorm, PyCharm)

Abra o terminal integrado no seu IDE JetBrains e execute claude. Funciona no painel do terminal com acesso completo ao projeto. O plugin JetBrains (atualmente em beta) adiciona sugestões inline e um painel de chat no IDE.

Terminal com tmux

Se vive no terminal, este padrão funciona bem — Claude num painel, o seu editor no outro:

tmux new-session -d -s dev
tmux split-window -h
tmux send-keys -t dev:0.1 'claude' Enter
tmux attach -t dev

Programa à esquerda, Claude corre à direita. Mesmo diretório de projeto, zero mudança de contexto.

CI/CD: Claude revê cada PR automaticamente

É aqui que o Claude Code passa de ferramenta pessoal a infraestrutura de equipa.

Revisão automatizada de PR com GitHub Actions

Crie .github/workflows/claude-review.yml:

name: Claude Code Review
on:
  pull_request:
    types: [opened, synchronize]

jobs:
  review:
    runs-on: ubuntu-latest
    permissions:
      contents: read
      pull-requests: write
    steps:
      - uses: actions/checkout@v4
        with:
          fetch-depth: 0

      - name: Claude Code Review
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Revê este pull request. Verifica:
            1. Problemas de segurança (injeção SQL, XSS, secrets expostos)
            2. Problemas de desempenho (queries N+1, índices em falta)
            3. Tratamento de erros em falta
            4. Lacunas na cobertura de testes

            Publica a revisão como comentário de PR com secções CRÍTICA e INFORMATIVA.

Cada PR recebe uma revisão completa antes de um humano sequer olhar. Problemas mecânicos são apanhados automaticamente, para que os seus revisores humanos possam focar-se em arquitetura e decisões de design.

Triagem automatizada de issues

name: Issue Triage
on:
  issues:
    types: [opened]

jobs:
  triage:
    runs-on: ubuntu-latest
    permissions:
      issues: write
    steps:
      - uses: actions/checkout@v4

      - name: Triage Issue
        uses: anthropics/claude-code-action@v1
        with:
          anthropic_api_key: ${{ secrets.ANTHROPIC_API_KEY }}
          prompt: |
            Analisa esta issue do GitHub. Com base no codebase:
            1. Identifica que ficheiros estão provavelmente afetados
            2. Estima a complexidade (trivial / moderada / complexa)
            3. Sugere labels relevantes
            4. Se é um bug, tenta identificar a causa raiz

            Publica a análise como comentário.

Novas issues são analisadas automaticamente — ficheiros afetados identificados, complexidade estimada, labels sugeridos. A sua equipa gasta menos tempo a triar e mais a construir.

Modo headless para scripting

O Claude Code pode correr em modo não-interativo para automatização personalizada:

# Executar um prompt único e sair
claude -p "Executa a suite de testes e reporta falhas" --output-format json

# Enviar entrada por pipe
echo "Explica a arquitetura deste projeto" | claude -p --output-format text

# Usar num script
RESULT=$(claude -p "Verifica se há comentários TODO em src/" --output-format json)
echo "$RESULT" | jq '.output'

Este é o bloco de construção para passos CI/CD personalizados, hooks de pre-commit e qualquer workflow onde queira que o Claude faça um trabalho específico e reporte o resultado.

Mantenha os seus tokens seguros

Os servidores MCP correm com as suas credenciais. Leve isto a sério.

Nunca faça commit de tokens em settings.json. Use referências a variáveis de ambiente:

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

Use credenciais apenas de leitura sempre que possível. O Claude raramente precisa de acesso de escrita à sua base de dados ou GitHub.

Limite ao que precisa. Não ligue uma base de dados de produção — use dev ou staging.

Reveja o código dos servidores MCP. São pacotes npm que correm com as suas credenciais. Verifique o código-fonte, prefira pacotes oficiais e fixe versões.

O setup completo

Aqui está o .claude/settings.json completo para um projeto bem integrado — permissões, servidores MCP e hooks a trabalhar juntos:

{
  "permissions": {
    "allow": [
      "Bash(npm run *)",
      "Bash(git *)",
      "Read",
      "Glob",
      "Grep"
    ],
    "deny": [
      "Bash(rm -rf *)",
      "Bash(git push --force*)"
    ]
  },
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": {
        "DATABASE_URL": "${DEV_DATABASE_URL}"
      }
    },
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_TOKEN}"
      }
    },
    "context7": {
      "command": "npx",
      "args": ["-y", "@context7/mcp-server"]
    }
  },
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "command": ".claude/hooks/pre-tool-guard.sh"
      }
    ]
  }
}

Acesso ao esquema de base de dados, issues e PRs do GitHub, documentação em tempo real, guards de segurança e permissões sensatas. Isto é um ambiente de desenvolvimento conectado, não um chatbot isolado.

Próximos passos

Com integrações no lugar, o Claude Code deixa de ser uma ferramenta onde cola contexto e passa a ser uma ferramenta que vai buscar o seu próprio contexto. Os próximos passos:

• Padrões de workflow — subagents, orquestração de revisão de código e as estratégias de depuração dos power users
• Otimização de custos — os servidores MCP adicionam uso de tokens, então estas estratégias mantêm a sua fatura controlada
• Avaliar o seu setup para ver como as suas integrações se comparam com as melhores configurações

Perguntas frequentes

Quantos servidores MCP posso executar ao mesmo tempo?

Sem limite rígido, mas cada servidor é um processo separado a usar memória e CPU. Na prática, 3-5 é o ponto ideal. Para além disso, o tempo de arranque aumenta e o contexto do Claude enche-se de descrições de ferramentas. Comece com os servidores que lhe poupam mais copiar e colar — tipicamente base de dados e GitHub.

Os servidores MCP funcionam com o plano Max ou apenas API?

Ambos. Os servidores MCP correm localmente na sua máquina independentemente do modelo de faturação. A única diferença de custo: chamadas de ferramentas MCP geram tokens adicionais (descrições, entradas, saídas), o que pesa mais com preços API por token do que com o plano Max de tarifa fixa.

Posso escrever o meu próprio servidor MCP?

Sim, e é mais simples do que pensa. Um servidor MCP comunica via stdio usando JSON-RPC. O pacote @modelcontextprotocol/sdk fornece helpers TypeScript:

import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";

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

server.setRequestHandler("tools/list", async () => ({
  tools: [{ name: "my_tool", description: "Does something useful", inputSchema: { type: "object" } }]
}));

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

Existem também SDKs para Python, Go e Rust.

A integração GitHub Actions é segura?

A ação oficial anthropics/claude-code-action corre num ambiente CI sandboxed. Só pode aceder ao que conceder via permissões GitHub Actions (contents: read, pull-requests: write). Guarde a sua chave API Anthropic como secret do GitHub, nunca hardcoded. O principal risco é o custo — uma ação fora de controlo num repo ativo pode gerar encargos API significativos. Configure alertas de gastos e limite que eventos ativam a ação.

Porquê usar MCP em vez de dizer ao Claude para executar comandos shell?

Comandos shell funcionam, mas são frágeis. Com um servidor MCP PostgreSQL, o Claude chama query("SELECT * FROM users LIMIT 5") — não precisa de descobrir a sua connection string psql, tratar autenticação ou fazer parse de saída tabular. O MCP dá ao Claude acesso tipado e estruturado às suas ferramentas. Menos erros, resultados mais fiáveis, e pode dar acesso de leitura à base de dados sem dar acesso shell completo.