In de afgelopen jaren werd de integratie van Large Language Models (LLM's) in softwaresystemen altijd geconfronteerd met een fundamenteel probleem: fragmentatie van dataconnectiviteit en functionaliteit [1, 2]. Wanneer ontwikkelaars een AI-assistent wilden koppelen aan een PostgreSQL-database, een GitHub-repository, een Jira-ticketsysteem of lokale bestanden op hun computer, waren ze gedwongen om voor elke combinatie van platforms aangepaste glue code (lijmcode) te schrijven [4, 5].
Deze situatie leidde tot een revolutionair initiatief dat inmiddels breed wordt omarmd door de wereldwijde ontwikkelaarsgemeenschap en open standaardenorganisaties: het Model Context Protocol (MCP) [1, 3]. Vaak omschreven als de "USB-C-poort voor AI-systemen", fungeert MCP als een open protocol dat de manier standardiseert waarop AI-agenten veilig, modulair en bidirectioneel communiceren met de externe wereld [4, 6].
1. Het oplossen van de $N \times M$-fragmentatieparadox
Voor de komst van MCP zat het AI-software-ecosysteem gevangen in de complexiteitsval van de $N \times M$-vermenigvuldiging [4, 5]:
VOOR MCP (N x M complexiteit):
[AI-model / Client] [Gegevensbron / Tools]
┌───────────────┐ ┌───────────────┐
│ Claude Desktop├─────────(Aangepaste connector)──► PostgreSQL │
│ Cursor IDE ├────(Aangepaste connector)───► GitHub API │
│ Custom Agent ├─(Verschillende JSON-schema's)─► Slack API │
│ VS Code AI ├─────────(Aangepaste connector)──► Lokaal bestand│
└───────────────┘ └───────────────┘
Elke AI-client moet een eigen integratie schrijven voor elke externe tool.
NA MCP (Universele N + M standaard):
[AI-model / Client] [MCP Open Protocol] [MCP Servers]
┌───────────────┐ ┌───────────────┐
│ Claude Desktop├────────┐ ┌───────►│ Postgres Serv │
│ Cursor IDE ├────────┤ JSON-RPC 2.0 │───────►│ GitHub Serv │
│ Custom Agent ├────────┼───[ MCP Standaard]─┼───────►│ Slack Serv │
│ VS Code / Zed ├────────┘ └───────►│ Filesystem Serv
└───────────────┘ └───────────────┘
Bouw slechts 1 MCP Server, en alle compatibele AI-apps kunnen deze gebruiken!
De meest accurate analogie om MCP te beschrijven is het succes van het Language Server Protocol (LSP) dat in het verleden door Microsoft werd geïnitieerd [3]. Vroeger moest elke tekstverwerker (Sublime, Vim, VS Code) zijn eigen modules voor syntax highlighting en autocomplete bouwen voor elke programmeertaal. LSP veranderde dit volledig door één enkel protocol in het leven te blazen: de maker van een programmeertaal hoeft slechts één Language Server te bouwen, en editors over de hele wereld kunnen deze direct ondersteunen [3, 6].
MCP past een vergelijkbaar principe toe voor AI: serviceproviders (zoals databaseproviders, cloud-API's of bedrijfssoftware) hoeven slechts één MCP Server te publiceren, en alle moderne AI-toepassingen hebben er direct toegang toe zonder integratiecode te hoeven herschrijven [3, 5].
2. Architectonische anatomie: Host, Client en Server
Structureel is de MCP-architectuur ontworpen met een zeer strikte scheiding van verantwoordelijkheden (separation of concerns) [6, 8]:
┌────────────────────────────────────────────────────────────────────────┐
│ MCP HOST (Hoofdapplicatie) │
│ (Voorbeeld: Claude Desktop, Cursor IDE, Zed, CLI Autonomous Agent) │
│ │
│ ┌────────────────────────┐ ┌────────────────────────┐ │
│ │ MCP Client 1 │ │ MCP Client 2 │ │
│ └───────────┬────────────┘ └───────────┬────────────┘ │
└────────────────┼─────────────────────────────────────┼─────────────────┘
│ (Transport: stdio / SSE) │ (Transport: stdio / SSE)
▼ ▼
┌─────────────────────┐ ┌─────────────────────┐
│ MCP Server 1 │ │ MCP Server 2 │
│(Lokaal: Filesystem) │ │ (Remote: Database) │
├─────────────────────┤ ├─────────────────────┤
│ • Resources (Data) │ │ • Resources (Data) │
│ • Tools (Functies) │ │ • Tools (Functies) │
│ • Prompts (Sjablonen)│ │ • Prompts (Sjablonen)│
└─────────────────────┘ └─────────────────────┘
- MCP Host (Orkestratiecontainer): Dit is de hoofdapplicatie die direct interactie heeft met de gebruiker of het AI-model [6, 8]. De host is verantwoordelijk voor het beheren van de interface-indeling, het beveiligen van gebruikersmachtigingen en het instantieëren van verbindingsclients.
- MCP Client (Sessiebeheerder): Bevindt zich binnen de Host. Telkens wanneer de Host verbinding wil maken met een bron van functionaliteit, maakt deze een MCP Client-instantie aan die een geïsoleerde 1-op-1-verbinding onderhoudt met de doelserver (MCP Server) [8].
- MCP Server (Functionaliteitsprovider): Een lichtgewicht programma dat fungeert als een brug (gateway) naar echte bronnen [6, 8]. De server declareert welke functionaliteiten deze bezit en wacht op opdrachten van de client.
3. JSON-RPC 2.0 communicatieprotocol en transportlaag
De communicatie tussen de MCP Client en Server is verpakt in het standaard JSON-RPC 2.0-formaat dat lichtgewicht, deterministisch en programmeertaal-onafhankelijk (language-agnostic) is [8, 2].
Het berichtformaat omvat:
- Requests: Berichten met een
id,methodenparams-parameters waarbij de client een antwoord (result) of foutmelding (error) verwacht [8]. - Notifications: Eenrichtingsberichten zonder
iddie worden gebruikt voor statusinrichting of realtime bestandsupdates zonder te wachten op een retourrespons [8].
Twee ingebouwde transportopties
MCP scheidt de datalaag (Data Layer) van de manier waarop databits worden verzonden (Transport Layer) [6, 8]:
stdio(Standard Input / Standard Output):- Werkingsmechanisme: De MCP Host voert de MCP Server uit als een lokaal subprocess (subprocess) op de computer van de gebruiker. Gegevensuitwisseling vindt plaats via
stdin- enstdout-pipes. - Voordelen: Zeer snel (sub-milliseconde latentie), volledig geïsoleerd in de lokale machine (sandbox), vereist geen netwerkpoort- of firewallconfiguratie, en is uiterst veilig voor lokale bestandsbewerkingen of SQLite-databases [6, 8].
- Werkingsmechanisme: De MCP Host voert de MCP Server uit als een lokaal subprocess (subprocess) op de computer van de gebruiker. Gegevensuitwisseling vindt plaats via
- SSE (Server-Sent Events) via HTTP:
- Werkingsmechanisme: Communicatie vindt plaats via standaard HTTP-netwerken. De client ontvangt gegevensstromen van de server via het SSE-protocol en stuurt opdrachten terug via HTTP POST.
- Voordelen: Ideaal voor externe servers (cloud-hosted), enterprise SaaS-diensten, gedistribueerde teamintegraties en microservices-architecturen [6, 8].
4. De drie primitieve pijlers van MCP: Resources, Tools en Prompts
Alle functionaliteiten die door een MCP Server worden aangeboden, zijn ingedeeld in drie intuïtieve primitieve categorieën [6, 7]:
| Primitief | Belangrijkste kenmerken | Wie heeft de controle? | Voorbeeldgebruik |
|---|---|---|---|
Resources (resources/) |
Passieve context, read-only. Levert ruwe data aan het model zonder neveneffecten op het systeem te veroorzaken. | Applicatie / Client | Het lezen van databaseschema's, serverfoutenlogboeken, configuratiebestanden of projectrichtlijnen. |
Tools (tools/) |
Actieve acties (executable verbs). Hiermee kan AI code uitvoeren, berekeningen doen of de status van externe systemen wijzigen. | AI-model (LLM) | Het uitvoeren van SQL-queries (run_query), het aanmaken van Jira-tickets (create_ticket) of het doen van een Git-commit. |
Prompts (prompts/) |
Patronen en gestructureerde workflow-sjablonen. Begeleidt interacties om consistente resultaten te produceren. | Gebruiker / Interface | Sneltoetsen voor prestatie-audits (/audit-performance) of een standaard indeling voor technische bugrapportages. |
5. Enterprise-beveiliging: Het voorkomen van ongecontroleerde uitvoeringsrampen
Het verlenen van volledige toegang aan kunstmatige intelligentiemodellen om direct te interacteren met productiesystemen brengt enorme beveiligingsrisico's met zich mee, variërend van de gevaren van prompt injection tot onbedoelde uitvoer van schadelijke opdrachten.
MCP lost dit dilemma op door een benadering van gelaagde beveiliging (human-in-the-loop security boundaries) toe te passen [4, 5, 13]:
- Granulaire toestemmingsverificatie (Explicit Permission Gates): Voordat de Host toestaat dat de functie
tools/callwordt aangeroepen met neveneffecten (zoals het verwijderen van tabelrijen of het verzenden van uitgaande e-mails), kan de Host expliciet een bevestigingsdialoog aan de gebruiker tonen [4, 7]. - Lokale omgevingsisolatie (Local-First Perimeter):
stdio-gebaseerde MCP-servers draaien onder de toegangsrechten van de lokale gebruiker, wat datalekken van gevoelige gegevens (credentials) naar het openbare internet voorkomt [8, 13]. - OAuth 2.0 Standaardintegratie: Voor cloud-gebaseerde servers (SSE) kan authenticatie worden beveiligd met behulp van standaard OAuth-protocollen, zodat de AI-agent uitsluitend handelt binnen de toegangsrechten (scope) van de betreffende gebruiker [5, 13].
6. Eenvoudig implementatievoorbeeld van een TypeScript-gebaseerde MCP Server
Het bouwen van een moderne MCP Server is uiterst compact dankzij de beschikbaarheid van officiële SDK's (Official SDK) in TypeScript, Python, Go, Rust en Java [2, 6]. Hieronder staat een conceptueel overzicht van het bouwen van een eenvoudige server voor weercontrole en bestandslezen:
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
// 1. Initialiseer de MCP Server
const server = new Server(
{ name: "system-monitor-mcp", version: "1.0.0" },
{ capabilities: { tools: {} } }
);
// 2. Declareer de lijst met beschikbare tools
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: "get_system_health",
description: "Retourneert de huidige status van CPU-belasting en geheugengebruik",
inputSchema: {
type: "object",
properties: {
detailed: { type: "boolean", description: "Of gedetailleerde metrieken moeten worden weergegeven" }
}
}
}
]
};
});
// 3. Handel tool-uitvoering af wanneer deze wordt aangeroepen door het AI-model
server.setRequestHandler(CallToolRequestSchema, async (request) => {
if (request.params.name === "get_system_health") {
const memoryUsage = process.memoryUsage();
return {
content: [
{
type: "text",
text: `Systeemstatus: OK | RSS: ${Math.round(memoryUsage.rss / 1024 / 1024)} MB`
}
]
};
}
throw new Error("Tool niet gevonden");
});
// 4. Start de verbinding via lokaal stdio-transport
const transport = new StdioServerTransport();
await server.connect(transport);
Met zo'n 30 regels code hierboven kan dit systeemmonitoringstool direct worden gedetecteerd en uitgevoerd door elke AI-editor, terminalagent of desktopchatinterface die MCP ondersteunt [6, 10].
Conclusie
Het Model Context Protocol (MCP) is de cruciale architectonische brug die de wereld van taalmodellen samenbrengt met het ecosysteem van echte softwareapplicaties. Door de focus van ontwikkelaars te verleggen van het schrijven van repetitieve lijmcode naar het bouwen van standaard functionaliteitsmodules, opent MCP de weg naar een nieuwe generatie intelligente applicaties die echt modulair, veilig en cross-platform inzetbaar zijn.
Voor elke software-engineer en systeemarchitect die AI-gebaseerde producten bouwt, is het beheersen en integreren van MCP niet langer slechts een optionele technische toevoeging, maar een onvermijdelijke standaard in het moderne computertijdperk.
Referenties & Citaties
- Wikipedia Reference — Model Context Protocol: History, Architecture, and Industry Adoption. Bronlink
- GitHub Open Source Repository — Model Context Protocol Specification and Core SDKs. Bronlink
- Medium Engineering Standards — Why Model Context Protocol Is the Language Server Protocol for Artificial Intelligence. Bronlink
- Anthropic Engineering Blog — Introducing the Model Context Protocol: An Open Standard for Connecting AI to Data. Bronlink
- Databricks Developer Insights — Solving the N x M AI Integration Bottleneck with Universal Open Protocols. Bronlink
- Model Context Protocol Documentation — Core Primitives, Architecture Layers, and Protocol Specification. Bronlink
- Deepsense AI Tech Review — Understanding Resources, Tools, and Prompts in Real-World MCP Implementations. Bronlink
- ModelContextProtocol.io Architecture Guide — JSON-RPC 2.0 Transport Channels: stdio versus SSE. Bronlink
- Descope Developer Series — Connecting AI Agents to Real-World APIs Securely via Standardized Protocols. Bronlink
- GitHub Developer Tools Review — Claude Code, Cursor, and the Power of Local-First MCP Integration. Bronlink
- Stytch Identity and Security Blog — Enterprise Access Control, Token Governance, and OAuth in MCP. Bronlink



