MCP (Model Context Protocol): De Complete Gids voor Ontwikkelaars

Het Model Context Protocol (MCP) is een open standaard gemaakt door Anthropic die definieert hoe AI-modellen communiceren met externe tools, databronnen en diensten. Beschouw het als de "USB-C van AI" - een universele connector die elke AI-agent laat communiceren met elk tool via een gestandaardiseerde interface.

Sinds de lancering heeft MCP 97 miljoen maandelijkse SDK-downloads overschreden en is het geadopteerd door alle grote AI-aanbieders: Anthropic, OpenAI, Google, Microsoft en Amazon. In deze gids verkennen we alles wat je moet weten om met MCP te bouwen.

Waarom MCP Bestaat

Vóór MCP moest elke AI-applicatie aangepaste integraties bouwen voor elk tool dat het wilde gebruiken. Wil je dat je AI bestanden leest? Schrijf aangepaste code. Een database bevragen? Meer aangepaste code. Posten op Slack? Weer een andere integratie.

Dit creëerde een N×M-probleem: N AI-applicaties die elk M aangepaste integraties nodig hadden, wat leidde tot dubbel werk en gefragmenteerde ecosystemen.

MCP lost dit op met één protocol dat elke AI-client kan gebruiken om te communiceren met elke MCP-server:

Kernconcepten

MCP heeft drie fundamentele primitieven:

1. Tools

Tools zijn functies die de AI kan aanroepen. Ze vertegenwoordigen acties zoals "maak een bestand", "bevraag een database" of "stuur een bericht". Elk tool heeft een naam, beschrijving en een JSON Schema voor zijn parameters.

{
  name: "create_issue",
  description: "Create a new GitHub issue",
  inputSchema: {
    type: "object",
    properties: {
      title: { type: "string", description: "Issue title" },
      body: { type: "string", description: "Issue body" },
      repo: { type: "string", description: "Repository name" }
    },
    required: ["title", "repo"]
  }
}

2. Resources

Resources zijn gegevens die de AI kan lezen. Ze vertegenwoordigen bestanden, databaserecords, API-responses of andere databronnen. Resources worden geïdentificeerd door URI's.

{
  uri: "file:///Users/dev/project/README.md",
  name: "Project README",
  mimeType: "text/markdown"
}

3. Prompts

Prompts zijn herbruikbare sjablonen die helpen bij het structureren van interacties. Ze kunnen dynamische parameters bevatten en zijn nuttig voor het standaardiseren van veelvoorkomende workflows.

{
  name: "code_review",
  description: "Review code changes for quality and security",
  arguments: [
    { name: "diff", description: "The code diff to review", required: true }
  ]
}

Architectuur

MCP volgt een client-server architectuur:

• Host: De AI-applicatie (Claude Desktop, Cursor, je eigen app)
• Client: Onderhoudt een 1:1 verbinding met een MCP-server
• Server: Stelt tools, resources en prompts beschikbaar aan de client
• Transport: Communicatie vindt plaats via JSON-RPC 2.0 over stdio (lokaal) of Server-Sent Events (extern)

Een MCP-Server Bouwen

Laten we een praktische MCP-server bouwen die werkt met een takenlijst opgeslagen in een JSON-bestand.

Setup

mkdir mcp-todo-server && cd mcp-todo-server
npm init -y
npm install @modelcontextprotocol/sdk zod

Server Implementatie

// src/index.ts
import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import fs from "fs";

const TODO_FILE = "./todos.json";

function readTodos(): { id: number; text: string; done: boolean }[] {
  if (!fs.existsSync(TODO_FILE)) return [];
  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
}

function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
}

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

// Tool: Add a todo
server.tool(
  "add_todo",
  "Add a new todo item",
  { text: z.string().describe("The todo text") },
  async ({ text }) => {
    const todos = readTodos();
    const newTodo = { id: Date.now(), text, done: false };
    todos.push(newTodo);
    writeTodos(todos);
    return { content: [{ type: "text", text: `Added: "${text}"` }] };
  }
);

// Tool: List todos
server.tool(
  "list_todos",
  "List all todo items",
  {},
  async () => {
    const todos = readTodos();
    const list = todos
      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
      .join("\n");
    return { content: [{ type: "text", text: list || "No todos yet." }] };
  }
);

// Tool: Complete a todo
server.tool(
  "complete_todo",
  "Mark a todo as completed",
  { id: z.number().describe("The todo ID to complete") },
  async ({ id }) => {
    const todos = readTodos();
    const todo = todos.find((t) => t.id === id);
    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
    todo.done = true;
    writeTodos(todos);
    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
  }
);

// Resource: Current todos as a readable resource
server.resource(
  "todos://list",
  "Current todo list",
  async () => ({
    contents: [{
      uri: "todos://list",
      mimeType: "application/json",
      text: JSON.stringify(readTodos(), null, 2),
    }],
  })
);

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

Configuratie

Om deze server met Claude Desktop te gebruiken, voeg het toe aan je configuratie:

{
  "mcpServers": {
    "todo": {
      "command": "npx",
      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
    }
  }
}

Een MCP-Client Bouwen

Je kunt ook een aangepaste client bouwen die verbinding maakt met elke MCP-server:

import { Client } from "@modelcontextprotocol/sdk/client/index.js";
import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";

const transport = new StdioClientTransport({
  command: "npx",
  args: ["tsx", "./src/index.ts"],
});

const client = new Client({ name: "my-client", version: "1.0.0" });
await client.connect(transport);

// List available tools
const { tools } = await client.listTools();
console.log("Available tools:", tools.map((t) => t.name));

// Call a tool
const result = await client.callTool({
  name: "add_todo",
  arguments: { text: "Write MCP blog post" },
});
console.log(result);

Populaire MCP-Servers

Het MCP-ecosysteem is snel gegroeid. Hier zijn enkele van de populairste servers:

MCP vs A2A (Agent-to-Agent)

Terwijl MCP agent-naar-tool communicatie afhandelt, behandelt Googles A2A (Agent-to-Agent) protocol agent-naar-agent communicatie. Ze zijn complementair:

• MCP: Hoe een AI-agent tools gebruikt (verticale integratie)
• A2A: Hoe AI-agenten met elkaar samenwerken (horizontale integratie)

Best Practices

1. Houd servers gefocust: Eén server per domein (GitHub-server, Slack-server, etc.). Bouw geen monolithische servers.
2. Valideer invoer met Zod: Valideer altijd tool-invoer met correcte schema's.
3. Ga elegant om met fouten: Retourneer betekenisvolle foutmeldingen, geen stack traces.
4. Gebruik resources voor alleen-lezen data: Als de AI alleen data hoeft te lezen, stel het dan beschikbaar als resource in plaats van tool.
5. Voeg goede beschrijvingen toe: Goede tool- en parameterbeschrijvingen helpen de AI begrijpen wanneer en hoe elk tool te gebruiken.
6. Test met de MCP Inspector: Gebruik npx @modelcontextprotocol/inspector om je server interactief te testen.

Aan de Slag

# Create a new MCP server from template
npx @modelcontextprotocol/create-server my-server

# Test with the MCP Inspector
npx @modelcontextprotocol/inspector npx tsx ./src/index.ts

Conclusie

MCP is in 2026 de de facto standaard geworden voor AI-tool gebruik. Of je nu aangepaste AI-agenten bouwt, Claude Code uitbreidt of integraties maakt voor bestaande platforms, MCP begrijpen is essentieel. Het protocol is eenvoudig genoeg om in een middag te leren maar krachtig genoeg om productie-waardige AI-workflows te bouwen.

Volgende stappen:

• Verken de MCP Specificatie
• Bekijk bestaande MCP-servers voor inspiratie
• Bouw je eerste server met de TypeScript of Python SDK
• Test het met Claude Desktop of de MCP Inspector