Wat is MCP? Het Model Context Protocol voor AI Agents

Elke AI-assistent heeft hetzelfde probleem: isolatie. Een AI kan tekst genereren, code schrijven en complexe problemen doorgronden, maar zonder maatwerk kan het niet je agenda raadplegen, je database doorzoeken of je tools aansturen. Tot nu toe moest je voor elke tool, elke API en elke databron specifieke integratiecode schrijven. Dat schaalt niet, en iedereen die het geprobeerd heeft weet dat.

Het Model Context Protocol (MCP) verandert dat. MCP is een open standaard, ontwikkeld door Anthropic en nu beheerd door de Linux Foundation, die AI-applicaties een universele manier geeft om te verbinden met externe tools, databronnen en diensten. Eén interface vervangt tientallen propriëtaire koppelingen.

Wat is MCP?

MCP staat voor Model Context Protocol. Het is een open protocol dat AI-applicaties een gestandaardiseerde manier geeft om te verbinden met externe databronnen en tools. In plaats van dat elke AI-tool z'n eigen integratie bouwt voor elke dienst, definieert MCP een gemeenschappelijke taal. Elke AI-client kan ermee praten met elke MCP-compatibele server.

Anthropic bracht MCP uit in november 2024. Het kwam voort uit pure frustratie: ze waren steeds dezelfde integratiecode aan het dupliceren tussen Claude Desktop en diverse IDE's. Binnen een jaar werd het de snelst geadopteerde open standaard in de AI-geschiedenis, met 97 miljoen maandelijkse SDK-downloads en adoptie door elk groot AI-platform.

Waarom MCP ertoe doet

Vóór MCP moest elke AI-applicatie maatwerk-integraties bouwen voor elke tool. Wil je dat Claude toegang krijgt tot je GitHub-repositories, Slack-kanalen en Postgres-database? Drie aparte integratie-codebases. Wil je dat ChatGPT dezelfde tools kan gebruiken? Nog eens drie. Het resultaat was een M×N-probleem: M applicaties keer N tools, elk met unieke verbindingscode.

MCP comprimeert dit tot een M+N-oplossing. Bouw één MCP-server voor je tool, en elke MCP-compatibele client kan ermee overweg. Bouw één MCP-client, en die praat met elke MCP-server. Hetzelfde patroon dat USB succesvol maakte: standaardiseer de interface en het ecosysteem groeit vanzelf.

Hoe MCP werkt

MCP gebruikt een client-server-architectuur gebouwd op JSON-RPC 2.0, geïnspireerd door het Language Server Protocol (LSP) dat IDE-tooling standaardiseerde. Als je met LSP hebt gewerkt voelt de structuur vertrouwd. Het protocol kent drie rollen:

• Hosts: AI-applicaties die verbindingen initiëren (Claude Desktop, Cursor, VS Code)
• Clients: Protocolconnectoren binnen de host die 1:1-verbindingen onderhouden met servers
• Servers: Diensten die tools, data en mogelijkheden beschikbaar stellen aan AI-modellen

Een host-applicatie bevat een of meer MCP-clients, elk verbonden met een andere MCP-server. Vraag je Claude om "mijn GitHub-issues te controleren", dan stuurt de host dat verzoek via z'n MCP-client naar de GitHub MCP-server. Die voert de actie uit en geeft het resultaat terug.

Server Primitives: Tools, Resources en Prompts

MCP-servers stellen drie typen primitives beschikbaar:

• Tools: Functies die het AI-model kan aanroepen om acties uit te voeren (een database doorzoeken, een e-mail versturen, een bestand aanmaken). Het model bepaalt wanneer en hoe ze worden gebruikt.
• Resources: Data die de server beschikbaar maakt voor context (bestanden, database-records, API-responses). Deze zijn alleen-lezen en worden gebruikt om het begrip van het model te verrijken.
• Prompts: Herbruikbare prompttemplates en workflows die de server aanbiedt. Gebruikers kunnen deze selecteren om hun interacties te structureren.

En het werkt ook andersom. MCP-clients kunnen mogelijkheden terugbieden aan servers:

• Sampling: Maakt het mogelijk dat servers LLM-completions opvragen via de client, waardoor recursieve agent-workflows ontstaan
• Roots: Laat servers het bestandssysteem of de URI-grenzen opvragen waarbinnen ze moeten opereren
• Elicitation: Maakt het mogelijk dat servers aanvullende informatie rechtstreeks bij gebruikers opvragen tijdens de uitvoering

Transport Types

MCP definieert twee standaard transportmechanismen. Welke je kiest hangt af van je deployment-model.

stdio: Lokale procescommunicatie

Bij het stdio-transport start de client de MCP-server als een subproces. Communicatie verloopt via standaard input en output. Het simpelste transport, en het werkt prima voor lokale tools zoals bestandssystemen, databases en development-utilities.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/Users/me/projects"]
    }
  }
}

Streamable HTTP: Remote servercommunicatie

Het Streamable HTTP-transport verving het eerdere HTTP+SSE-transport in de spec-revisie van 2025-03-26. Het maakt remote MCP-servers mogelijk die meerdere clientverbindingen over het netwerk aankunnen. De server stelt één HTTP-endpoint beschikbaar dat POST- en GET-requests accepteert, met optionele Server-Sent Events (SSE) voor streaming-responses.

Dit maakt MCP relevant voor webplatforms en SaaS-producten. In plaats van gebruikers een lokaal proces te laten draaien, host je een MCP-server op een URL als https://api.example.com/mcp en elke compatibele client kan op afstand verbinden.

Wat Streamable HTTP biedt:

• Sessiebeheer via Mcp-Session-Id headers voor stateful interacties
• Hervattbaarheid via SSE event-ID's, waardoor clients na verbindingsonderbrekingen opnieuw kunnen verbinden zonder berichten te verliezen
• Meerdere gelijktijdige verbindingen van verschillende clients naar dezelfde server
• Beveiligingsvereisten waaronder Origin-headervalidatie om DNS-rebindingaanvallen te voorkomen

Discovery: /.well-known/mcp.json

Voor remote MCP-servers is discovery het eerste probleem dat je moet oplossen. Hoe weet een client welke MCP-servers een domein aanbiedt? De opkomende standaard is een well-known discovery-endpoint op /.well-known/mcp.json dat beschikbare MCP-servers en hun endpoints opsomt.

{
  "version": "1.0",
  "servers": [
    {
      "name": "primary",
      "description": "Main API server for example.com",
      "endpoint": "https://mcp.example.com/v1"
    },
    {
      "name": "analytics",
      "description": "Analytics data access",
      "endpoint": "https://mcp.example.com/analytics"
    }
  ]
}

Hetzelfde idee als robots.txt voor crawlers of /.well-known/openid-configuration voor OAuth: clients vinden automatisch beschikbare diensten zonder handmatige configuratie. Vergeet niet de juiste CORS-headers (Access-Control-Allow-Origin: *) toe te voegen voor browser-gebaseerde clients.

Wie staat achter MCP?

MCP is geen project van één bedrijf meer. Op 9 december 2025, precies een jaar na de lancering, doneerde Anthropic MCP aan de Agentic AI Foundation (AAIF), een gericht fonds onder de Linux Foundation. De AAIF werd mede opgericht door Anthropic, Block en OpenAI, met ondersteuning van Google, Microsoft, AWS, Cloudflare en Bloomberg.

De AAIF beheert naast MCP ook twee andere founding projects:

• Goose (door Block): een open-source AI-agentframework
• AGENTS.md (door OpenAI): een standaard voor het beschrijven van agent-capabilities in repositories

De AAIF relateert ook nauw aan de agents.json-specificatie , die een gestandaardiseerde manier biedt voor websites om hun AI-agentcapaciteiten en ondersteunde protocollen te adverteren.

Die bestuursstructuur is belangrijk. MCP valt onder dezelfde foundation die Linux, Kubernetes en PyTorch beheert. Het gaat niet verdwijnen, en geen enkel bedrijf bepaalt de richting.

Huidige adoptie

RedMonk noemde MCP "de snelst geadopteerde standaard" die ze ooit hebben gevolgd, met een S-curve adoptiepatroon dat doet denken aan Docker's snelle marktverzadiging. De tijdlijn:

Op dit moment wordt MCP ondersteund door vrijwel elke grote AI-codingtool en -assistent:

• Claude Desktop & Claude Code: Anthropic's eigen applicaties, MCP-native vanaf dag één
• ChatGPT: OpenAI voegde volledige MCP-ondersteuning toe in maart 2025
• Cursor: MCP-integratie staat centraal in de tool-use en contextbewustzijn
• VS Code + GitHub Copilot: Agent-modus gebruikt MCP om externe tools aan te roepen tijdens codeersessies
• Windsurf (Codeium): Volledige MCP-serverondersteuning voor AI-codeerworkflows
• Gemini: Google DeepMind bevestigde MCP-ondersteuning voor contextbewuste agentinteracties
• Microsoft Copilot: Enterprise-brede MCP-adoptie in het hele Copilot-ecosysteem
• Zed, Cline, Replit, Continue.dev: Het bredere ecosysteem van developer-tools

Het MCP-ecosysteem

Het ecosysteem rond MCP is hard gegroeid. Meer dan 10.000 actieve MCP-servers zijn publiek beschikbaar, van developer-tools tot enterprise-dataplatforms. De community onderhoudt meerdere registries en directories waar je servers kunt vinden voor jouw use case.

Populaire MCP-servers zijn er voor:

• Developer-tools: GitHub, GitLab, Jira, Linear, Sentry
• Data & databases: PostgreSQL, MongoDB, Snowflake, BigQuery
• Productiviteit: Google Drive, Slack, Notion, Confluence
• Infrastructuur: AWS, Cloudflare, Docker, Kubernetes
• Web & zoeken: Brave Search, Firecrawl, Puppeteer, Playwright
• Design: Figma, Blender

De officiële SDK's zijn beschikbaar in TypeScript en Python, met community-SDK's voor Go, Rust, Java, C#, Ruby en meer. De TypeScript SDK wordt onderhouden op @modelcontextprotocol/sdk en de Python SDK op mcp (met het high-level FastMCP framework voor snelle ontwikkeling).

Wat er verandert in de MCP-spec

De november 2025-specificatie (versie 2025-11-25) introduceerde een aantal features die laten zien waar MCP naartoe gaat:

• Async Tasks: Duurzame request-tracking met polling en uitgestelde resultaatopvraging, waardoor langlopende operaties mogelijk zijn zonder een verbinding open te houden
• URL Mode Elicitation: Servers kunnen gebruikers naar een browser-URL sturen voor gevoelige flows zoals OAuth-authenticatie of betalingsverwerking, zodat credentials veilig blijven
• Verbeterde OAuth: OpenID Connect Discovery-ondersteuning, incrementele scope-consent en Client ID Metadata Documents die de noodzaak van per-server registratie elimineren
• Server Icons: Servers kunnen icoon-metadata beschikbaar stellen voor tools, resources en prompts, wat de vindbaarheid in client-UI's verbetert
• Tool Calling in Sampling: Servers kunnen tooldefinities meegeven bij het opvragen van LLM-completions, waardoor complexere agentic workflows mogelijk worden
• Geformaliseerd bestuur: Werkgroepen, interessegroepen, SDK-tiering en richtlijnen voor community-communicatie

De community werkt verder aan gestandaardiseerde server-discovery via /.well-known/mcp.json, betere enterprise-autorisatiepatronen en diepere integratie met andere agentic protocols.

Hoe MCP te implementeren

Een MCP-server bouwen is vrij recht-toe-recht-aan met de officiële SDK's. Hier een minimaal voorbeeld dat een tool beschikbaar stelt aan een AI-assistent.

Een MCP-server bouwen in TypeScript

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

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

server.tool(
  "get-weather",
  "Get current weather for a city",
  { city: z.string().describe("City name") },
  async ({ city }) => {
    const response = await fetch(
      `https://api.weather.example.com/current?city=${city}`
    );
    const data = await response.json();
    return {
      content: [{
        type: "text",
        text: `Weather in ${city}: ${data.temperature}°C, ${data.condition}`
      }]
    };
  }
);

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

Een MCP-server bouwen in Python

De Python SDK bevat FastMCP, een high-level framework dat het nog simpeler maakt:

from mcp.server.fastmcp import FastMCP

mcp = FastMCP("weather")

@mcp.tool()
async def get_weather(city: str) -> str:
    """Get current weather for a city."""
    response = await fetch_weather(city)
    return f"Weather in {city}: {response.temperature}°C, {response.condition}"

if __name__ == "__main__":
    mcp.run()

MCP-discovery toevoegen aan je website

Host je een remote MCP-server? Voeg dan een discovery-endpoint toe zodat clients je server automatisch vinden:

{
  "version": "1.0",
  "servers": [
    {
      "name": "your-platform",
      "description": "Access your platform data and tools via MCP",
      "endpoint": "https://api.yourplatform.com/mcp"
    }
  ]
}

Zet dit op /.well-known/mcp.json met de juiste CORS-headers, en MCP-clients vinden je server zonder handmatige configuratie.

Wat MCP implementeren betekent voor je platform

MCP-ondersteuning toevoegen aan je platform of API levert concrete voordelen op:

MCP vs A2A: hoe ze elkaar aanvullen

Google's Agent-to-Agent (A2A)-protocol is een andere standaard die je tegenkomt in de agentic AI-wereld. De vraag die ik vaak krijg: zijn MCP en A2A concurrenten? Nee. Ze lossen verschillende problemen op, op verschillende lagen.

In de praktijk gebruikt een goed ontworpen agentic systeem beide. Individuele agents gebruiken MCP om te verbinden met hun tools en databronnen (de verticale as). A2A stelt die agents in staat om elkaar te ontdekken en samen te werken (de horizontale as). MCP zijn de handen, A2A is het gesprek tussen teamleden.

MCP vs WebMCP: server-side ontmoet de browser

MCP verbindt AI-modellen met backend-tools en data. WebMCP doet hetzelfde, maar dan voor de browser. WebMCP (Web Model Context Protocol) is een W3C-voorstel, mede opgesteld door Google en Microsoft, dat websites hun functionaliteit laat aanbieden als gestructureerde tools. AI-agents kunnen die direct in de browser ontdekken en aanroepen, geen backend nodig.

Twee protocollen op verschillende lagen, maar hetzelfde mentale model: definieer tools met namen, beschrijvingen en inputschema's, en laat AI-agents ze aanroepen.

MCP geeft AI-agents toegang tot je backend (database bevragen, API aanroepen, infrastructuur beheren). WebMCP geeft ze toegang tot je frontend (productcatalogus doorzoeken, boekingsformulier invullen, beschikbaarheid controleren). Een reissite kan MCP gebruiken om z'n boekings-API beschikbaar te stellen aan AI-assistenten, en WebMCP om browser-gebaseerde agents direct in de UI vluchten te laten zoeken en boekingen te laten voltooien.

De protocollen vullen elkaar volledig aan. Implementeer je beide, dan geeft dat AI-agents het breedst mogelijke oppervlak om met je platform te interageren, of ze nu via een backend-integratie of via een browser komen.

Wie zou MCP moeten implementeren?

MCP is niet alleen voor AI-bedrijven. Elke organisatie die data of functionaliteit beschikbaar stelt kan er iets aan hebben:

• API-aanbieders: Als je een REST- of GraphQL-API hebt, maakt het verpakken ervan als MCP-server je dienst toegankelijk voor elke AI-assistent. Stripe, Twilio en vergelijkbare platforms zijn natuurlijke MCP-kandidaten.
• Dataplatforms: Databases, analysetools en datawarehouses kunnen query-interfaces beschikbaar stellen via MCP, zodat AI-modellen rechtstreeks toegang krijgen tot gestructureerde data.
• SaaS-producten: Elk product met een API kan naast zijn REST-endpoints een MCP-server aanbieden. Dit geeft klanten AI-aangedreven toegang zonder dat ze integratiecode hoeven te schrijven.
• Developer-tools: CI/CD-platforms, monitoringtools en infrastructuurdiensten kunnen hun mogelijkheden via MCP beschikbaar stellen voor AI-ondersteunde DevOps-workflows.
• Contentplatforms: CMS-systemen, documentatieplatforms en kennisbanken kunnen content als MCP-resources beschikbaar stellen, waardoor hun data direct beschikbaar is voor AI-agents. Begrijpen hoe AI-modellen zoals Claude bronnen selecteren kan helpen bij het effectief structureren van deze resources.
• Enterprise-systemen: CRM's, ERP's en interne tools kunnen MCP gebruiken om AI-assistenten gecontroleerde toegang te geven tot bedrijfsdata, met OAuth en permission-scoping ingebouwd in het protocol.

Aan de slag met MCP

Klaar om je platform MCP-compatibel te maken? Dit is een praktisch pad:

1. Kies je SDK: Gebruik de officiële TypeScript SDK of Python SDK (met FastMCP voor snelle ontwikkeling).
2. Definieer je tools: Identificeer de belangrijkste acties en dataquery's die je platform biedt. Elk API-endpoint is een potentiële MCP-tool.
3. Kies een transport: Gebruik stdio voor lokale dev-tools, Streamable HTTP voor remote/productieservers.
4. Implementeer authenticatie: Implementeer voor remote servers OAuth 2.0-flows volgens de MCP-autorisatiespec. De november 2025-update voegde Client ID Metadata Documents toe om registratie te vereenvoudigen.
5. Voeg discovery toe: Serveer een /.well-known/mcp.json bestand met je MCP-server-endpoints.
6. Test met echte clients: Verbind je server met Claude Desktop, Cursor of VS Code om te verifiëren dat het werkt met verschillende MCP-hosts.

De standaard is gezet

MCP heeft iets zeldzaams bereikt: snelle convergentie op één standaard. In iets meer dan een jaar ging het van een intern Anthropic-experiment naar het universele protocol voor AI-naar-tool-integratie. Elk groot AI-bedrijf staat erachter, de Linux Foundation beheert het. Het past in de bredere verschuiving van traditionele SEO naar AI Engine Optimization , waar je platform machineleesbaar maken net zo belangrijk wordt als het menselijk leesbaar maken.

Voor platformbouwers is de boodschap helder: MCP is hoe AI-assistenten verbinding gaan maken met je tools. Vroege adopters zien hun diensten al gebruikt worden in AI-workflows via Claude, ChatGPT, Gemini en tientallen codeertools. Nu bouwen betekent meeliften op het momentum, niet later achter de feiten aanlopen.

Bronnen

• Model Context Protocol - Officiële documentatie - Protocoloverzicht, handleidingen en specificatie
• MCP Specificatie 2025-11-25 - Huidige protocolspecificatie met architectuur, features en beveiligingsmodel
• MCP Transports Specificatie - stdio en Streamable HTTP transportdetails
• MCP Specificatie Changelog - Wijzigingen in de november 2025-specificatierelease
• Introducing the Model Context Protocol - Anthropic - Oorspronkelijke aankondiging van november 2024
• Donating MCP to the Agentic AI Foundation - Anthropic - December 2025-donatie aan de Linux Foundation
• Agentic AI Foundation Announcement - Linux Foundation - AAIF-oprichting met MCP, Goose en AGENTS.md
• A Year of MCP: From Internal Experiment to Industry Standard - Pento - Uitgebreide tijdlijn van MCP's eerste jaar
• .well-known/mcp Discovery Discussion - GitHub - Community-discussie over het MCP-server-discoveryformaat
• MCP TypeScript SDK - GitHub - Officiële TypeScript SDK voor het bouwen van MCP-servers en -clients
• MCP Python SDK - GitHub - Officiële Python SDK met FastMCP-framework
• MCP 2025-11-25 Spec Update - WorkOS - Analyse van async tasks, OAuth-verbeteringen en enterprise-features
• MCP vs A2A Clearly Explained - Clarifai - Vergelijking van MCP- en A2A-protocollen
• MCP Joins the Linux Foundation - GitHub Blog - GitHub's perspectief op de MCP-bestuursovergang