Werken met Claude Code Deel 4 van 5
Werken met Claude Code: MCP Servers
Gemini/Vic Boomer illustratie
Tooling

Werken met Claude Code: MCP Servers

Het Model Context Protocol verbindt Claude Code met externe tools en data. Van concept tot werkende MCP server.

Tom Notton
· 7 min leestijd

Je werkt in Claude Code aan een feature die data uit je PostgreSQL-database nodig heeft. Je schrijft een SQL-query, kopieert hem naar een terminal-tab, draait hem tegen de dev-database, kopieert de output terug naar Claude Code als context, en vraagt Claude om de feature op basis van die data af te maken. Twee stappen later is de data verouderd en klopt de context niet meer.

Dit is het probleem dat MCP oplost.

Wat MCP is

MCP staat voor Model Context Protocol. Het is een open standaard — oorspronkelijk geïntroduceerd door Anthropic — die definieert hoe een AI-model communiceert met externe tools en databronnen. In de context van Claude Code: MCP maakt het mogelijk om tools toe te voegen die verder gaan dan de ingebouwde Read, Write, Edit, Bash en Grep.

Het model gebruikt de term “server” voor een MCP-integratie. Dat is verwarrend als je denkt aan webservers. Een MCP server is een lokaal draaiend proces dat tools aanbiedt aan Claude Code. Het kan een database-connectie zijn, een API-wrapper, een bestandssysteem-interface, of een custom tool die je zelf bouwt. Claude Code communiceert met de MCP server via een gestandaardiseerd protocol, en de tools die de server aanbiedt verschijnen als extra opties naast de ingebouwde tools.

De architectuur:

Claude Code (client) ←→ MCP Protocol ←→ MCP Server (tool-provider)

Claude Code is de client. Het stuurt verzoeken naar de server. De server voert de actie uit en retourneert het resultaat. De communicatie verloopt via JSON-RPC over stdio of HTTP. Je hoeft het protocol zelf niet te implementeren — er zijn SDK’s voor TypeScript en Python.

Claude Code als MCP client

Claude Code kan meerdere MCP servers tegelijk draaien. Je configureert ze in .claude/settings.json:

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

Na deze configuratie start Claude Code de postgres MCP server automatisch bij elke sessie. De server biedt tools aan — in dit geval tools om SQL-queries uit te voeren tegen je database. Claude Code ziet die tools en kan ze gebruiken wanneer het relevant is.

In de praktijk:

> Welke orders zijn vandaag aangemaakt met een bedrag boven €100?

Claude Code herkent dat dit een databasevraag is, formuleert een SQL-query, stuurt die via de MCP server naar PostgreSQL, krijgt de resultaten terug, en presenteert ze in je sessie. Geen kopieer-plak. Geen terminal-tab wisselen. De data is actueel op het moment van de vraag.

Beschikbare MCP servers

Het MCP-ecosysteem groeit. Er zijn kant-en-klare servers voor de meest voorkomende use cases.

Database-servers

{
  "mcpServers": {
    "postgres": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-postgres"],
      "env": { "DATABASE_URL": "postgresql://..." }
    },
    "sqlite": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-sqlite", "--db-path", "./data/app.db"]
    }
  }
}

Met een database-server kan Claude Code schema’s inspecteren, queries draaien, en data ophalen als context voor code-beslissingen. Dit is bijzonder nuttig bij het schrijven van migraties, het debuggen van data-gerelateerde bugs, en het genereren van seed-data.

Bestandssysteem-servers

De ingebouwde Read-tool van Claude Code werkt al met je lokale bestandssysteem. Maar een MCP filesystem-server kan toegang bieden tot bestanden buiten je projectmap, of tot bestanden op een remote systeem.

API-wrapper servers

Een MCP server kan elke HTTP API wrappen. Stel dat je een interne API hebt voor gebruikersbeheer:

{
  "mcpServers": {
    "user-api": {
      "command": "node",
      "args": ["./mcp-servers/user-api/index.js"],
      "env": { "API_BASE_URL": "http://localhost:3000/api" }
    }
  }
}

De server biedt tools aan als getUser, listUsers, updateUser. Claude Code kan die tools gebruiken om context op te halen of acties uit te voeren als onderdeel van een bredere taak.

Memory en knowledge servers

Er zijn MCP servers die persistent geheugen bieden — een key-value store die Claude Code kan gebruiken om informatie te onthouden tussen sessies. Dit gaat verder dan CLAUDE.md: het model kan zelf beslissen wat het opslaat en ophaalt.

Een eigen MCP server bouwen

De kracht van MCP zit in de uitbreidbaarheid. Elke tool die je als functie kunt schrijven, kan een MCP server worden. De TypeScript SDK maakt het eenvoudig.

De structuur

Een MCP server heeft drie onderdelen:

  1. Server-initialisatie — definieer de server en zijn metadata.
  2. Tool-definities — beschrijf welke tools de server aanbiedt, met parameters en return-types.
  3. Tool-handlers — implementeer wat elke tool doet.

Een minimaal voorbeeld

Stel dat je een server wilt die de huidige git-status samenvat:

import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { execSync } from "child_process";
import { z } from "zod";

const server = new McpServer({
  name: "git-summary",
  version: "1.0.0",
});

server.tool(
  "git_status_summary",
  "Geeft een samenvatting van de huidige git-status",
  {},
  async () => {
    const status = execSync("git status --porcelain").toString();
    const branch = execSync("git branch --show-current").toString().trim();
    const lastCommit = execSync("git log -1 --oneline").toString().trim();

    const lines = status.split("\n").filter(Boolean);
    const modified = lines.filter((l) => l.startsWith(" M")).length;
    const added = lines.filter((l) => l.startsWith("A")).length;
    const untracked = lines.filter((l) => l.startsWith("??")).length;

    return {
      content: [
        {
          type: "text",
          text: `Branch: ${branch}\nLaatste commit: ${lastCommit}\nGewijzigd: ${modified}, Toegevoegd: ${added}, Untracked: ${untracked}`,
        },
      ],
    };
  }
);

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

Registreer de server in .claude/settings.json:

{
  "mcpServers": {
    "git-summary": {
      "command": "npx",
      "args": ["tsx", "./mcp-servers/git-summary/index.ts"]
    }
  }
}

Vanaf nu kan Claude Code de git_status_summary tool gebruiken. Wanneer je vraagt “wat is de huidige status van het project?”, kan Claude deze tool aanroepen naast de ingebouwde tools.

Tools met parameters

Tools kunnen parameters accepteren met een JSON Schema-definitie via Zod:

server.tool(
  "git_diff_file",
  "Toont de diff van een specifiek bestand",
  {
    filePath: z.string().describe("Pad naar het bestand"),
    staged: z.boolean().optional().describe("Toon staged changes"),
  },
  async ({ filePath, staged }) => {
    const flag = staged ? "--staged" : "";
    const diff = execSync(`git diff ${flag} -- ${filePath}`).toString();
    return {
      content: [{ type: "text", text: diff || "Geen wijzigingen." }],
    };
  }
);

Claude Code ziet de parameterbeschrijvingen en vult ze automatisch in op basis van de conversatie-context. Als je vraagt “wat heb ik veranderd in src/api/auth.ts?”, roept Claude git_diff_file aan met filePath: "src/api/auth.ts".

MCP in de praktijk

Drie patronen die goed werken:

Patroon 1: Database als eersteklas context

Met een PostgreSQL MCP server kan Claude Code vragen beantwoorden die code en data combineren:

> De functie calculateRevenue in src/services/analytics.ts geeft een
> verkeerd totaal. Draai dezelfde query die de functie gebruikt direct
> tegen de database en vergelijk het resultaat met de verwachte output.

Claude leest de functie, extraheert de query-logica, voert een vergelijkbare query uit via de MCP server, en identificeert het verschil. Dit soort debugging is zonder MCP een manueel proces van vijf stappen.

Patroon 2: API-integratie als ontwikkeltool

Wanneer je werkt aan een frontend die data ophaalt van je eigen API, kan een MCP server die API direct beschikbaar maken:

> Haal de huidige gebruiker op via de user-api en genereer een
> TypeScript type dat de response beschrijft.

Claude roept de API aan, inspecteert de response, en genereert een type-definitie die exact past bij de werkelijke data. Geen handmatig opzoeken van API-documentatie.

Patroon 3: Custom tools voor projectspecifieke workflows

Elk project heeft repetitieve taken die niet in de standaard toolset passen. Een MCP server kan die taken wrappen:

  • Een tool die je Stripe test-account query’t voor recente transacties.
  • Een tool die je feature-flags ophaalt uit LaunchDarkly.
  • Een tool die je error-tracking (Sentry, Bugsnag) doorzoekt.

De investering is een paar uur per server. Het rendement is dat Claude Code die informatie kan opvragen wanneer het relevant is, zonder dat jij de context handmatig moet aanleveren.

Veiligheid en grenzen

MCP servers draaien lokaal en hebben toegang tot alles wat je ze geeft. Een database MCP server met een productie-connectionstring kan productiedata lezen en schrijven. Een API-wrapper met admin-credentials kan admin-acties uitvoeren.

Drie regels:

  1. Gebruik dev-credentials. MCP servers in Claude Code horen tegen dev- of staging-omgevingen te draaien. Productie-credentials in een lokale .claude/settings.json zijn een risico.

  2. Beperk schrijftoegang. Als een MCP server alleen leestoegang nodig heeft, configureer dan een read-only database-gebruiker of API-key.

  3. Review tool-calls. In de standaard permissie-modus toont Claude Code MCP tool-calls voordat ze uitgevoerd worden. Beoordeel ze net zo kritisch als Bash-commando’s.

Het grotere plaatje

MCP transformeert Claude Code van een code-editor-assistent naar een platform dat met je hele development-omgeving communiceert. Zonder MCP is Claude Code beperkt tot wat het in je bestanden en terminal kan vinden. Met MCP heeft het toegang tot databases, API’s, monitoring-tools en alles wat je als server kunt wrappen.

Dat is een fundamentele verschuiving in wat “context” betekent voor een AI-codeertool. Context is niet langer alleen de bestanden in je project. Context is je hele ontwikkelomgeving — data, services, infrastructuur — beschikbaar via een gestandaardiseerd protocol.

In deel 5 kijken we naar hoe je Claude Code inzet bij complexe projecten: multi-file refactoring, sub-agents voor parallelle taken, en wanneer Claude Code de juiste tool is en wanneer niet.

Dit is deel 4 van de serie “Werken met Claude Code”. Lees deel 1-3 voor de basis.

Meer in deze serie
claude code tutorial