Claude Code Integraties: MCP-servers, IDE-setup en CI/CD

Claude Code is op zichzelf al krachtig. Het leest je bestanden, schrijft code, voert commando's uit. Maar op dit moment kopieer en plak je elke keer dat Claude iets moet weten buiten je project — een databaseschema, een GitHub-issue, een Sentry-fout. Jij bent de tussenpersoon.

Wat als Claude die informatie gewoon... zelf kon ophalen?

Dat is precies wat MCP-servers doen. Slechts 8% van de setups in onze analyse configureert ze, maar die behalen gemiddeld 7.5/10. De reden is simpel: MCP-servers elimineren de kopieer-plak-belasting die het grootste deel van de sessietijd opslokt.

Laten we er nu een opzetten. Je hebt het binnen vijf minuten werkend.

Je eerste MCP-server: GitHub

MCP staat voor Model Context Protocol. Het is een open standaard waarmee Claude met externe diensten kan communiceren via een gestructureerde interface. Een MCP-server is een klein programma dat op de achtergrond draait en Claude toegang geeft tot tools — zoals issues doorzoeken, databases bevragen of documentatie lezen.

Laten we beginnen met de GitHub MCP-server omdat de setup heel eenvoudig is en het voordeel direct voelbaar.

Voeg dit toe aan je .claude/settings.json:

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

Je hebt een GitHub Personal Access Token nodig. Ga naar GitHub > Settings > Developer Settings > Personal access tokens > Generate new token. Geef het de repo scope.

Herstart Claude Code en probeer dit:

> Lijst mijn 5 meest recente pull requests

Claude vraagt je niets te plakken. Het roept de GitHub MCP-server aan, haalt je PRs op en toont ze. Probeer nu:

> Wat is de status van issue #42? Lees de commentaren ook.

Claude haalt het issue op, leest de discussie en heeft de volledige context. Wanneer je zegt "werk aan issue #42", weet het daadwerkelijk wat issue #42 zegt — zonder dat jij de beschrijving in de chat kopieert.

Dat is het hele punt van MCP: Claude haalt de context zelf op in plaats van dat jij de koerier speelt.

De database MCP-server (die alles verandert)

Als je PostgreSQL gebruikt, is dit de MCP-server waarbij je je afvraagt hoe je ooit zonder werkte.

Voeg toe aan .claude/settings.json:

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

Wat dit ontgrendelt:

• Claude leest je echte tabelschema's voordat het queries schrijft — geen gokken op kolomnamen meer
• Het kan SELECT-queries uitvoeren om datastructuren te begrijpen
• Migratie-generatie wordt nauwkeurig omdat Claude het echte huidige schema ziet
• Kolomnaamfouten worden opgepikt voordat de code draait

Belangrijk: Gebruik een alleen-lezen databasegebruiker. Claude heeft geen schrijftoegang nodig om je schema te begrijpen:

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;

Probeer het. Vraag Claude: "Toon me het schema van de users-tabel." Het bevraagt de database direct en geeft je de exacte kolommen, typen en constraints. Geen "Ik neem aan dat het schema er ongeveer zo uitziet" meer.

Meer MCP-servers die de moeite waard zijn

Zodra je het principe doorhebt, zijn dit de andere servers die hun plek verdienen:

Slack — teamgesprekken doorzoeken

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

Werk je aan een feature die vorige week in Slack werd besproken? In plaats van dat jij het gesprek samenvat, zoekt Claude het direct op.

Sentry — foutrapportages ophalen

{
  "mcpServers": {
    "sentry": {
      "command": "npx",
      "args": ["-y", "@sentry/mcp-server"],
      "env": {
        "SENTRY_AUTH_TOKEN": "jouw_sentry_token",
        "SENTRY_ORG": "jouw-org",
        "SENTRY_PROJECT": "jouw-project"
      }
    }
  }
}

Een productiefout aan het debuggen? Claude haalt de exacte stack trace, aantal getroffen gebruikers en foutfrequentie op uit Sentry. Geen screenshots van foutrapporten meer plakken in de chat.

Context7 — live documentatie

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

Deze is stiekem super handig. In plaats van te vertrouwen op trainingsdata (die verouderd kan zijn), haalt Claude de huidige docs op voor de exacte bibliotheekversie die je gebruikt. Vooral handig voor snel veranderende bibliotheken als Next.js, React of Prisma waar de API verandert tussen versies.

Filesystem — bestanden buiten je project benaderen

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": [
        "-y", "@modelcontextprotocol/server-filesystem",
        "/Users/jij/projecten/gedeelde-libs",
        "/Users/jij/projecten/design-system"
      ]
    }
  }
}

Monorepo? Claude moet je design system raadplegen terwijl het een feature bewerkt? De filesystem-server geeft het toegang tot mappen buiten het huidige project.

IDE-integratie: Claude ontmoeten waar je codet

VS Code

De snelste manier om te beginnen:

1. Installeer de Claude Code extensie uit de VS Code marketplace
2. Open je project
3. Druk op Cmd+Shift+P (Mac) of Ctrl+Shift+P (Windows/Linux) en typ "Claude"
4. Selecteer "Claude Code: Open Panel"

De VS Code extensie geeft Claude toegang tot je open bestanden, terminal-uitvoer, TypeScript-fouten, ESLint-waarschuwingen — alles zonder kopiëren en plakken.

JetBrains (IntelliJ, WebStorm, PyCharm)

Open de ingebouwde terminal in je JetBrains IDE en voer claude uit. Het werkt in het terminalpaneel met volledige projecttoegang. De JetBrains-plugin (momenteel in beta) voegt inline suggesties en een chatpaneel toe in de IDE.

Terminal met tmux

Als je in de terminal leeft, werkt dit patroon goed — Claude in het ene paneel, je editor in het andere:

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

Je codet links, Claude draait rechts. Zelfde projectmap, nul contextwissel.

CI/CD: Claude reviewt elke PR automatisch

Hier gaat Claude Code van persoonlijke tool naar teaminfrastructuur.

Geautomatiseerde PR-review met GitHub Actions

Maak .github/workflows/claude-review.yml aan:

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: |
            Review dit pull request. Controleer op:
            1. Beveiligingsproblemen (SQL-injectie, XSS, blootgestelde secrets)
            2. Prestatieproblemen (N+1 queries, ontbrekende indexen)
            3. Ontbrekende foutafhandeling
            4. Lacunes in testdekking

            Post je review als PR-commentaar met KRITIEK en INFORMATIEF secties.

Elke PR krijgt een grondige review voordat een mens er naar kijkt. Mechanische problemen worden automatisch opgevangen, zodat je menselijke reviewers zich kunnen richten op architectuur en ontwerpbeslissingen.

Geautomatiseerde issue-triage

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: |
            Analyseer dit GitHub issue. Gebaseerd op de codebase:
            1. Identificeer welke bestanden waarschijnlijk geraakt zijn
            2. Schat de complexiteit (triviaal / matig / complex)
            3. Stel relevante labels voor
            4. Als het een bug is, probeer de oorzaak te identificeren

            Post je analyse als commentaar.

Nieuwe issues worden automatisch geanalyseerd — getroffen bestanden geïdentificeerd, complexiteit geschat, labels voorgesteld. Je team besteedt minder tijd aan sorteren en meer aan bouwen.

Headless modus voor scripting

Claude Code kan niet-interactief draaien voor aangepaste automatisering:

# Enkele prompt uitvoeren en afsluiten
claude -p "Draai de testsuite en rapporteer fouten" --output-format json

# Invoer pipen
echo "Leg de architectuur van dit project uit" | claude -p --output-format text

# In een script gebruiken
RESULT=$(claude -p "Controleer op TODO-commentaren in src/" --output-format json)
echo "$RESULT" | jq '.output'

Dit is de bouwsteen voor aangepaste CI/CD-stappen, pre-commit hooks en elke workflow waar je Claude een specifieke taak wilt laten uitvoeren en rapporteren.

Houd je tokens veilig

MCP-servers draaien met je credentials. Neem dat serieus.

Commit nooit tokens in settings.json. Gebruik in plaats daarvan omgevingsvariabele-referenties:

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

Gebruik alleen-lezen credentials waar mogelijk. Claude heeft zelden schrijftoegang nodig tot je database of GitHub.

Beperk tot wat je nodig hebt. Verbind geen productiedatabase — gebruik dev of staging.

Controleer MCP-servercode. Het zijn npm-pakketten die met je credentials draaien. Controleer de broncode, geef de voorkeur aan officiële pakketten en pin versies.

De complete setup

Hier is de volledige .claude/settings.json voor een goed geïntegreerd project — permissies, MCP-servers en hooks die samenwerken:

{
  "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"
      }
    ]
  }
}

Toegang tot databaseschema, GitHub issues en PRs, live documentatie, beveiligingsguards en verstandige permissies. Dat is een verbonden ontwikkelomgeving, geen geïsoleerde chatbot.

Wat volgt

Met integraties op hun plaats stopt Claude Code een tool te zijn waar je context in plakt en wordt het een tool dat zijn eigen context ophaalt. De volgende stappen:

• Workflow-patronen — subagents, code review-orkestratie en de debugging-strategieën van power users
• Kostenoptimalisatie — MCP-servers voegen tokenverbruik toe, dus deze strategieën houden je rekening beheersbaar
• Beoordeel je setup om te zien hoe je integraties zich verhouden tot topconfiguraties

Veelgestelde vragen

Hoeveel MCP-servers kan ik tegelijk draaien?

Geen harde limiet, maar elke server is een apart proces dat geheugen en CPU gebruikt. In de praktijk is 3-5 het optimale punt. Daarboven neemt de opstarttijd toe en raakt Claudes context vol met toolbeschrijvingen. Begin met de servers die je het meeste kopieer-plakwerk besparen — meestal database en GitHub.

Werken MCP-servers met het Max-plan of alleen API?

Beide. MCP-servers draaien lokaal op je machine ongeacht het factureringsmodel. Het enige kostenverschil: MCP-tool-aanroepen genereren extra tokens (toolbeschrijvingen, invoer, uitvoer), wat meer uitmaakt bij API-prijzen per token dan bij het vaste Max-plan.

Kan ik mijn eigen MCP-server schrijven?

Ja, en het is eenvoudiger dan je denkt. Een MCP-server communiceert via stdio met JSON-RPC. Het @modelcontextprotocol/sdk pakket biedt TypeScript-helpers:

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);

Er zijn ook SDKs voor Python, Go en Rust.

Is de GitHub Actions integratie veilig?

De officiële anthropics/claude-code-action draait in een gesandboxte CI-omgeving. Het kan alleen benaderen wat je toekent via GitHub Actions permissies (contents: read, pull-requests: write). Sla je Anthropic API-sleutel op als GitHub secret, nooit hardcoded. Het belangrijkste risico zijn kosten — een ongecontroleerde action op een drukke repo kan aanzienlijke API-kosten genereren. Stel bestedingsalarmen in en beperk welke events de action triggeren.

Waarom MCP in plaats van Claude shell-commando's laten uitvoeren?

Shell-commando's werken, maar ze zijn fragiel. Met een PostgreSQL MCP-server roept Claude query("SELECT * FROM users LIMIT 5") aan — het hoeft je psql-connectiestring niet uit te puzzelen, geen authenticatie af te handelen of tabulaire uitvoer te parsen. MCP geeft Claude getypeerde, gestructureerde toegang tot je tools. Minder fouten, betrouwbaardere resultaten, en je kunt database-leestoegang geven zonder volledige shell-toegang.