Wat is MCP? Hoe AI-assistenten tools en data gebruiken

MCP staat voor Model Context Protocol, een open protocol dat AI-applicaties via compatibele servers verbindt met externe tools en data. De MCP-client van een applicatie ontdekt wat een server aanbiedt en kan tools aanroepen, binnen de toegangsregels van de server en de rechten van de applicatie.

Als website-eigenaar kun je met een MCP-server acties via een API aanbieden, ook wanneer er geen browsertab openstaat. WebMCP biedt tools binnen een geopende pagina aan. Voor beide protocollen heb je een implementatie nodig die de client van de agent kan gebruiken.

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. Zonder MCP bouwt elke AI-tool een eigen integratie voor elke dienst. Met MCP kan elke AI-client via één gedeeld protocol met elke MCP-compatibele server praten.

Anthropic bracht MCP uit in november 2024. Anthropic bouwde het omdat het steeds dezelfde integratiecode dupliceerde tussen Claude Desktop en diverse IDE's. Binnen een jaar haalde MCP 97 miljoen maandelijkse SDK-downloads en kreeg het steun van de grote AI-platforms, waaronder OpenAI, Google DeepMind en Microsoft.

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 verkleint 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. USB werkt op dezelfde manier: met een standaardinterface implementeert elke kant die één keer.

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.

Clients kunnen ook mogelijkheden aan servers aanbieden:

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

Transport Types

MCP definieert twee standaard transportmechanismen. Je deployment-model bepaalt welke je kiest.

stdio: Lokale procescommunicatie

Bij het stdio-transport start de client de MCP-server als een subproces. Communicatie verloopt via standaard input en output. Het is het simpelste transport en 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.

Daardoor is 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.

Streamable HTTP voegt toe:

• 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 voorgestelde aanpak 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"
    }
  ]
}

Dit volgt hetzelfde idee als robots.txt voor crawlers en /.well-known/openid-configuration voor OAuth: clients vinden beschikbare diensten zonder handmatige configuratie. Voeg de juiste CORS-headers toe (Access-Control-Allow-Origin: *) 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.

Naast MCP beheert de AAIF 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 agents.json-specificatie behandelt een verwant onderwerp. Ze biedt websites een gestandaardiseerde manier om hun AI-agentcapaciteiten en ondersteunde protocollen bekend te maken.

MCP valt nu onder de Linux Foundation, die ook Linux, Kubernetes en PyTorch onderbrengt. Geen enkel bedrijf bepaalt de richting.

Huidige adoptie

RedMonk noemde MCP "de snelst geadopteerde standaard" die het ooit heeft gevolgd, en beschreef een S-curve-adoptiepatroon dat lijkt op de snelle marktverzadiging van Docker. De tabel toont de belangrijkste mijlpalen:

Nu ondersteunen de meeste grote AI-codingtools en -assistenten MCP:

• 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 voor tool-use en context
• 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: MCP-ondersteuning in het hele Copilot-ecosysteem
• Zed, Cline, Replit, Continue.dev: Andere developer-tools met MCP-ondersteuning

Het MCP-ecosysteem

Het ecosysteem rond MCP is hard gegroeid. Meer dan 10.000 actieve MCP-servers zijn publiek beschikbaar, voor onder meer developer-tools en 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 snellere ontwikkeling).

Wat er verandert in de MCP-spec

De november 2025-specificatie (versie 2025-11-25) voegde een aantal features toe:

• Async Tasks: Duurzame request-tracking met polling en uitgestelde resultaatopvraging, zodat langlopende operaties geen open verbinding nodig hebben
• 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 per-server registratie overbodig maken
• 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

Met de officiële SDK's is een MCP-server snel gebouwd. Het volgende minimale voorbeeld stelt één tool beschikbaar 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 waarmee je nog minder code nodig hebt:

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 kunnen 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. Clients die discovery ondersteunen vinden je server dan zonder handmatige configuratie.

Wat MCP implementeren betekent voor je platform

MCP-ondersteuning toevoegen aan je platform of API heeft vier belangrijke voordelen:

MCP vs A2A: hoe ze elkaar aanvullen

Google's Agent-to-Agent (A2A)-protocol is een andere standaard in de agentic AI-wereld. MCP en A2A concurreren niet. Ze lossen verschillende problemen op, op verschillende lagen.

In de praktijk kan een agentic systeem beide gebruiken. Elke agent gebruikt MCP om te verbinden met zijn tools en databronnen (de verticale as), en A2A laat agents elkaar ontdekken en samenwerken (de horizontale as).

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, zonder backend.

Beide protocollen werken op dezelfde manier. Je definieert tools met namen, beschrijvingen en inputschema's, en AI-agents roepen ze aan.

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 zijn 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 aan. Implementeer je beide, dan kunnen AI-agents je platform bereiken via een backend-integratie of via de browser.

Wie zou MCP moeten implementeren?

Elke organisatie die data of functionaliteit beschikbaar stelt kan een MCP-server aanbieden:

• API-aanbieders: Als je een REST- of GraphQL-API hebt, maakt het verpakken ervan als MCP-server je dienst toegankelijk voor elke MCP-compatibele 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. Klanten krijgen vanuit hun AI-assistent toegang zonder integratiecode 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

Volg deze stappen om je platform MCP-compatibel te maken:

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 en Streamable HTTP voor remote servers en productieservers.
4. Implementeer authenticatie: Gebruik 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.

Waar MCP nu staat

In iets meer dan een jaar ging MCP van een intern Anthropic-experiment naar een protocol dat OpenAI, Google, Microsoft en anderen ondersteunen, onder beheer van de Linux Foundation. Het past in de bredere verschuiving van traditionele SEO naar AI Engine Optimization , waar het net zo belangrijk wordt om je platform machineleesbaar te maken als menselijk leesbaar.

Voor platformbouwers is MCP nu een belangrijke manier waarop AI-assistenten verbinding maken met je tools. De TypeScript- en Python-voorbeelden hierboven laten zien hoe klein een eerste server kan zijn.

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 - Tijdlijn van het eerste jaar van MCP
• .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