1 
2Het **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.
3 
4Sinds 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.
5 
6## Waarom MCP Bestaat
7 
8Vóó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.
9 
10Dit creëerde een **N×M-probleem**: N AI-applicaties die elk M aangepaste integraties nodig hadden, wat leidde tot dubbel werk en gefragmenteerde ecosystemen.
11 
12```mermaid
13graph TD
14    subgraph "Before MCP (N×M)"
15        A1[AI App 1] --> T1[GitHub Integration]
16        A1 --> T2[Slack Integration]
17        A1 --> T3[DB Integration]
18        A2[AI App 2] --> T4[GitHub Integration]
19        A2 --> T5[Slack Integration]
20        A2 --> T6[DB Integration]
21    end
22```
23 
24MCP lost dit op met **één protocol** dat elke AI-client kan gebruiken om te communiceren met elke MCP-server:
25 
26```mermaid
27graph TD
28    subgraph "With MCP (N+M)"
29        A1[AI App 1] --> MCP[MCP Protocol]
30        A2[AI App 2] --> MCP
31        MCP --> S1[GitHub Server]
32        MCP --> S2[Slack Server]
33        MCP --> S3[DB Server]
34    end
35```
36 
37## Kernconcepten
38 
39MCP heeft drie fundamentele primitieven:
40 
41### 1. Tools
42Tools 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.
43 
44```typescript
45{
46  name: "create_issue",
47  description: "Create a new GitHub issue",
48  inputSchema: {
49    type: "object",
50    properties: {
51      title: { type: "string", description: "Issue title" },
52      body: { type: "string", description: "Issue body" },
53      repo: { type: "string", description: "Repository name" }
54    },
55    required: ["title", "repo"]
56  }
57}
58```
59 
60### 2. Resources
61Resources zijn gegevens die de AI kan lezen. Ze vertegenwoordigen bestanden, databaserecords, API-responses of andere databronnen. Resources worden geïdentificeerd door URI's.
62 
63```typescript
64{
65  uri: "file:///Users/dev/project/README.md",
66  name: "Project README",
67  mimeType: "text/markdown"
68}
69```
70 
71### 3. Prompts
72Prompts zijn herbruikbare sjablonen die helpen bij het structureren van interacties. Ze kunnen dynamische parameters bevatten en zijn nuttig voor het standaardiseren van veelvoorkomende workflows.
73 
74```typescript
75{
76  name: "code_review",
77  description: "Review code changes for quality and security",
78  arguments: [
79    { name: "diff", description: "The code diff to review", required: true }
80  ]
81}
82```
83 
84## Architectuur
85 
86MCP volgt een client-server architectuur:
87 
88```mermaid
89graph LR
90    subgraph "Host Application"
91        Client[MCP Client]
92    end
93 
94    subgraph "MCP Server"
95        Server[Server Process]
96        Server --> Tools[Tools]
97        Server --> Resources[Resources]
98        Server --> Prompts[Prompts]
99    end
100 
101    Client -- "JSON-RPC 2.0\n(stdio or SSE)" --> Server
102```
103 
104- **Host**: De AI-applicatie (Claude Desktop, Cursor, je eigen app)
105- **Client**: Onderhoudt een 1:1 verbinding met een MCP-server
106- **Server**: Stelt tools, resources en prompts beschikbaar aan de client
107- **Transport**: Communicatie vindt plaats via JSON-RPC 2.0 over stdio (lokaal) of Server-Sent Events (extern)
108 
109## Een MCP-Server Bouwen
110 
111Laten we een praktische MCP-server bouwen die werkt met een takenlijst opgeslagen in een JSON-bestand.
112 
113### Setup
114 
115```bash
116mkdir mcp-todo-server && cd mcp-todo-server
117npm init -y
118npm install @modelcontextprotocol/sdk zod
119```
120 
121### Server Implementatie
122 
123```typescript
124// src/index.ts
125import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
126import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
127import { z } from "zod";
128import fs from "fs";
129 
130const TODO_FILE = "./todos.json";
131 
132function readTodos(): { id: number; text: string; done: boolean }[] {
133  if (!fs.existsSync(TODO_FILE)) return [];
134  return JSON.parse(fs.readFileSync(TODO_FILE, "utf-8"));
135}
136 
137function writeTodos(todos: { id: number; text: string; done: boolean }[]) {
138  fs.writeFileSync(TODO_FILE, JSON.stringify(todos, null, 2));
139}
140 
141const server = new McpServer({
142  name: "todo-server",
143  version: "1.0.0",
144});
145 
146// Tool: Add a todo
147server.tool(
148  "add_todo",
149  "Add a new todo item",
150  { text: z.string().describe("The todo text") },
151  async ({ text }) => {
152    const todos = readTodos();
153    const newTodo = { id: Date.now(), text, done: false };
154    todos.push(newTodo);
155    writeTodos(todos);
156    return { content: [{ type: "text", text: `Added: "${text}"` }] };
157  }
158);
159 
160// Tool: List todos
161server.tool(
162  "list_todos",
163  "List all todo items",
164  {},
165  async () => {
166    const todos = readTodos();
167    const list = todos
168      .map((t) => `${t.done ? "✅" : "⬜"} [${t.id}] ${t.text}`)
169      .join("\n");
170    return { content: [{ type: "text", text: list || "No todos yet." }] };
171  }
172);
173 
174// Tool: Complete a todo
175server.tool(
176  "complete_todo",
177  "Mark a todo as completed",
178  { id: z.number().describe("The todo ID to complete") },
179  async ({ id }) => {
180    const todos = readTodos();
181    const todo = todos.find((t) => t.id === id);
182    if (!todo) return { content: [{ type: "text", text: "Todo not found." }] };
183    todo.done = true;
184    writeTodos(todos);
185    return { content: [{ type: "text", text: `Completed: "${todo.text}"` }] };
186  }
187);
188 
189// Resource: Current todos as a readable resource
190server.resource(
191  "todos://list",
192  "Current todo list",
193  async () => ({
194    contents: [{
195      uri: "todos://list",
196      mimeType: "application/json",
197      text: JSON.stringify(readTodos(), null, 2),
198    }],
199  })
200);
201 
202// Start the server
203const transport = new StdioServerTransport();
204await server.connect(transport);
205```
206 
207### Configuratie
208 
209Om deze server met Claude Desktop te gebruiken, voeg het toe aan je configuratie:
210 
211```json
212{
213  "mcpServers": {
214    "todo": {
215      "command": "npx",
216      "args": ["tsx", "/path/to/mcp-todo-server/src/index.ts"]
217    }
218  }
219}
220```
221 
222## Een MCP-Client Bouwen
223 
224Je kunt ook een aangepaste client bouwen die verbinding maakt met elke MCP-server:
225 
226```typescript
227import { Client } from "@modelcontextprotocol/sdk/client/index.js";
228import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
229 
230const transport = new StdioClientTransport({
231  command: "npx",
232  args: ["tsx", "./src/index.ts"],
233});
234 
235const client = new Client({ name: "my-client", version: "1.0.0" });
236await client.connect(transport);
237 
238// List available tools
239const { tools } = await client.listTools();
240console.log("Available tools:", tools.map((t) => t.name));
241 
242// Call a tool
243const result = await client.callTool({
244  name: "add_todo",
245  arguments: { text: "Write MCP blog post" },
246});
247console.log(result);
248```
249 
250## Populaire MCP-Servers
251 
252Het MCP-ecosysteem is snel gegroeid. Hier zijn enkele van de populairste servers:
253 
254| Server | Beschrijving | Gebruik |
255|--------|-------------|---------|
256| **GitHub** | Issues aanmaken, PR's, repo's beheren | Ontwikkelworkflows |
257| **Slack** | Berichten versturen, kanalen beheren | Teamcommunicatie |
258| **PostgreSQL** | Databases bevragen en beheren | Datatoegang |
259| **Filesystem** | Bestanden lezen, schrijven en zoeken | Lokale ontwikkeling |
260| **Puppeteer** | Browserautomatisering en scraping | Webtesten |
261| **Sentry** | Foutmonitoring en debugging | Productieondersteuning |
262| **Supabase** | Database, auth, opslag | Backend-operaties |
263 
264## MCP vs A2A (Agent-to-Agent)
265 
266Terwijl MCP **agent-naar-tool** communicatie afhandelt, behandelt Googles **A2A (Agent-to-Agent)** protocol **agent-naar-agent** communicatie. Ze zijn complementair:
267 
268```mermaid
269graph TD
270    Agent1[Agent 1] -- "A2A Protocol" --> Agent2[Agent 2]
271    Agent1 -- "MCP Protocol" --> Tool1[GitHub MCP Server]
272    Agent2 -- "MCP Protocol" --> Tool2[Database MCP Server]
273```
274 
275- **MCP**: Hoe een AI-agent tools gebruikt (verticale integratie)
276- **A2A**: Hoe AI-agenten met elkaar samenwerken (horizontale integratie)
277 
278## Best Practices
279 
2801. **Houd servers gefocust**: Eén server per domein (GitHub-server, Slack-server, etc.). Bouw geen monolithische servers.
2812. **Valideer invoer met Zod**: Valideer altijd tool-invoer met correcte schema's.
2823. **Ga elegant om met fouten**: Retourneer betekenisvolle foutmeldingen, geen stack traces.
2834. **Gebruik resources voor alleen-lezen data**: Als de AI alleen data hoeft te lezen, stel het dan beschikbaar als resource in plaats van tool.
2845. **Voeg goede beschrijvingen toe**: Goede tool- en parameterbeschrijvingen helpen de AI begrijpen wanneer en hoe elk tool te gebruiken.
2856. **Test met de MCP Inspector**: Gebruik `npx @modelcontextprotocol/inspector` om je server interactief te testen.
286 
287## Aan de Slag
288 
289```bash
290# Create a new MCP server from template
291npx @modelcontextprotocol/create-server my-server
292 
293# Test with the MCP Inspector
294npx @modelcontextprotocol/inspector npx tsx ./src/index.ts
295```
296 
297## Conclusie
298 
299MCP 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.
300 
301**Volgende stappen:**
302- Verken de [MCP Specificatie](https://spec.modelcontextprotocol.io/)
303- Bekijk [bestaande MCP-servers](https://github.com/modelcontextprotocol/servers) voor inspiratie
304- Bouw je eerste server met de TypeScript of Python SDK
305- Test het met Claude Desktop of de MCP Inspector
306