MCP Servers: hoe AI-agents met je website communiceren

Wat is het Model Context Protocol?

Het Model Context Protocol — bibliotheekterm, kortweg MCP, is een open standaard die definieert hoe AI-agents communiceren met externe systemen. Waar traditionele API's zijn ontworpen voor mens-naar-machine interactie, is MCP specifiek gebouwd voor machine-naar-machine communicatie met AI-agents als gebruiker. Het protocol is ontwikkeld door Anthropic en wordt inmiddels breed geadopteerd door de AI-industrie.

MCP lost een fundamenteel probleem op: AI-modellen zijn krachtig in het verwerken van taal en het redeneren, maar ze hebben geen directe toegang tot de buitenwereld. Ze kunnen geen databases raadplegen, geen API's aanroepen en geen bestanden lezen, tenzij er een brug wordt geslagen tussen het model en die externe bronnen. MCP is die brug.

Om te begrijpen waarom MCP zo belangrijk is voor de toekomst van het web, is het nuttig om eerst te begrijpen wat AEO inhoudt en hoe AI-modellen steeds actiever content consumeren. MCP tilt die interactie naar een hoger niveau: van passief lezen naar actief samenwerken.

Hoe MCP werkt: clients, servers en het protocol

De architectuur van MCP is gebaseerd op een client-server model. Een MCP-client is typisch een AI-agent of applicatie die namens een gebruiker handelt. Een MCP-server is een dienst die specifieke capabilities aanbiedt aan die agent. Het protocol definieert hoe deze twee partijen met elkaar communiceren via een gestandaardiseerd JSON-RPC formaat.

• De MCP-client (AI-agent) ontdekt welke servers beschikbaar zijn en welke mogelijkheden ze bieden.
• De MCP-server publiceert een server card met metadata over de beschikbare tools, resources en prompts.
• Communicatie verloopt via JSON-RPC 2.0 over HTTP of Server-Sent Events (SSE).
• Het protocol ondersteunt authenticatie via OAuth 2.0 voor beveiligde toegang.
• Servers kunnen zowel stateless tools (zoals een rekenmachine) als stateful resources (zoals database-queries) aanbieden.

Het verschil tussen MCP en een traditionele REST API

Een veelgestelde vraag is: "Wat voegt MCP toe dat een REST API niet al biedt?" Het antwoord ligt in de discovery-laag en de semantische beschrijving. Bij een REST API moet een ontwikkelaar handmatig documentatie lezen, endpoints integreren en authenticatie configureren. MCP standaardiseert dit hele proces zodat een AI-agent het autonoom kan doorlopen.

// Traditionele REST API: developer-gestuurd
GET /api/v1/products?category=laptops
Headers: Authorization: Bearer 

// MCP: agent-gestuurd (discovery + semantische beschrijving)
1. Agent leest server card → ontdekt tools en capabilities
2. Agent selecteert tool "search_products" op basis van doel
3. Agent authenticeert via OAuth discovery (automatisch)
4. Agent roept tool aan met gestructureerde parameters

// Het verschil: de agent begrijpt WAT de tool doet,
// niet alleen HOE je hem aanroept.

De MCP server card: je digitale visitekaartje voor AI

Het hart van een MCP-server is de server card, een JSON-document dat beschrijft wat de server kan. Dit document vertelt AI-agents precies welke tools beschikbaar zijn, welke resources ze kunnen raadplegen en welke prompts ze kunnen gebruiken. Hieronder een voorbeeld van hoe zo'n server card eruitziet.

{
  "name": "aeo-scanner",
  "version": "1.0.0",
  "description": "AEO Scanner API voor website-analyse",
  "capabilities": {
    "tools": true,
    "resources": true,
    "prompts": true
  },
  "tools": [
    {
      "name": "scan_url",
      "description": "Scan een URL op AEO-gereedheid en retourneer scores",
      "inputSchema": {
        "type": "object",
        "properties": {
          "url": {
            "type": "string",
            "description": "De te scannen URL"
          }
        },
        "required": ["url"]
      }
    },
    {
      "name": "get_recommendations",
      "description": "Haal verbeteradviezen op voor een eerder gescande URL",
      "inputSchema": {
        "type": "object",
        "properties": {
          "scan_id": {
            "type": "string",
            "description": "Het ID van een eerdere scan"
          }
        },
        "required": ["scan_id"]
      }
    }
  ],
  "resources": [
    {
      "uri": "aeo://scans/latest",
      "name": "Laatste scan resultaten",
      "description": "De meest recente scanresultaten voor het account",
      "mimeType": "application/json"
    }
  ]
}

Tools versus resources

MCP maakt een belangrijk onderscheid tussen tools en resources. Tools zijn actieve operaties die de agent kan uitvoeren, vergelijkbaar met functies. Resources zijn passieve databronnen die de agent kan lezen. Een tool zou bijvoorbeeld een scan kunnen starten, terwijl een resource de resultaten van eerdere scans beschikbaar stelt.

Prompts: voorgebakken instructies

Naast tools en resources biedt MCP ook ondersteuning voor prompts. Dit zijn vooraf gedefinieerde instructiesets die de agent kan gebruiken als startpunt voor een taak. Denk aan een prompt "analyse_rapport" die de agent helpt om scanresultaten samen te vatten in een helder overzicht. Prompts verlagen de drempel voor agents om complexe taken correct uit te voeren met je server.

Waarom MCP relevant is voor je website

De opkomst van AI-agents die zelfstandig taken uitvoeren voor gebruikers is geen toekomstmuziek meer. Tools als Claude met computer use, OpenAI's browsing agent en Google's Project Mariner zijn de voorlopers van een wereld waarin AI-agents namens consumenten websites bezoeken, producten vergelijken en transacties uitvoeren.

Websites die via MCP hun diensten aanbieden aan AI-agents krijgen een concurrentievoordeel. In plaats van dat een agent je website moet scrapen en HTML moet interpreteren, bied je een gestructureerde, betrouwbare interface aan die de agent direct kan gebruiken. Dit is sneller, nauwkeuriger en schaalbaarder.

Praktijkvoorbeelden per branche

• E-commerce: een AI-agent kan via MCP direct producten zoeken, beschikbaarheid checken en namens de gebruiker een bestelling plaatsen, zonder je webshop-interface te hoeven interpreteren.
• SaaS-platforms: je kunt via MCP dashboarddata, gebruikersstatistieken en rapportages beschikbaar stellen. Een agent kan dan een weekrapport genereren zonder je UI te openen.
• Kennisbanken en documentatie: MCP maakt het mogelijk om specifieke artikelen, FAQ-antwoorden en handleidingen direct doorzoekbaar te maken voor AI-agents.
• Reisbureaus en boekingsplatforms: agents kunnen vluchten zoeken, prijzen vergelijken en boekingen maken via gestandaardiseerde MCP-tools.

MCP implementeren: de eerste stappen

Het implementeren van een MCP-server hoeft niet complex te zijn. Begin met het identificeren van de kernfunctionaliteit die je aan AI-agents wilt aanbieden. Voor de meeste websites zijn dit de informatie-ophaal functies: productgegevens, artikelen, prijzen en beschikbaarheid.

1. Identificeer de kernfuncties van je website die waardevol zijn voor AI-agents.
2. Definieer tools voor actieve operaties (zoeken, bestellen) en resources voor passieve data (catalogi, prijslijsten).
3. Implementeer de MCP-server met JSON-RPC 2.0 als transport protocol.
4. Voeg OAuth 2.0 authenticatie toe voor beveiligde endpoints.
5. Publiceer je server card op een discoverable locatie zodat AI-agents je server kunnen vinden.
6. Test je implementatie met bestaande MCP-clients zoals de Claude desktop app.

Een minimale MCP-server in Node.js

Om het concept tastbaar te maken, hier een vereenvoudigd voorbeeld van een MCP-server. Dit illustreert de kernprincipes zonder productiecomplexiteit.

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: "mijn-website",
  version: "1.0.0",
});

// Definieer een tool
server.tool(
  "zoek_artikelen",
  "Zoek artikelen op de website op basis van een zoekterm",
  { query: z.string(), limit: z.number().optional().default(10) },
  async ({ query, limit }) => {
    const results = await zoekInDatabase(query, limit);
    return {
      content: [{
        type: "text",
        text: JSON.stringify(results, null, 2),
      }],
    };
  }
);

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

De authenticatie van je MCP-server is een apart hoofdstuk. Lees meer over hoe je dat veilig inricht in ons artikel over OAuth discovery voor AI-agents. En vergeet niet je llms.txt bestand aan te vullen met een verwijzing naar je MCP-server, zodat AI-modellen ook via die route je capabilities ontdekken.

MCP en de bredere agent-infrastructuur

MCP staat niet op zichzelf. Het maakt deel uit van een groeiend ecosysteem van protocollen en standaarden die samen de agent-economie vormgeven. Waar MCP de communicatie regelt tussen een agent en jouw server, regelt het A2A-protocol de communicatie tussen agents onderling. En robots.txt bepaalt welke content agents in de eerste plaats mogen benaderen.

De toekomst: een web van AI-agents

MCP is onderdeel van een bredere beweging richting een web dat niet alleen door mensen wordt gebruikt, maar ook door AI-agents. Samen met standaarden als OAuth discovery — bibliotheekterm voor agents, Web Bot Auth en robots.txt — bibliotheekterm AI-regels vormt MCP de protocollen die de agent-economie mogelijk maken. Websites die deze standaarden adopteren, worden de preferred partners van AI-agents.

De parallel met de vroege dagen van het web is treffend. Zoals websites destijds geoptimaliseerd moesten worden voor zoekmachines om vindbaar te zijn, moeten websites nu geoptimaliseerd worden voor AI-agents om bruikbaar te zijn. MCP is het HTTP van de agent-wereld: het protocol dat alles verbindt.

Samenvatting: de belangrijkste punten

• MCP is een open standaard van Anthropic die definieert hoe AI-agents communiceren met externe systemen via een gestandaardiseerd JSON-RPC protocol.
• De server card is het hart van MCP: een machine-leesbaar document dat tools, resources en prompts beschrijft zodat agents autonoom kunnen ontdekken wat je website te bieden heeft.
• Het onderscheid tussen tools (actieve operaties) en resources (passieve databronnen) bepaalt hoe agents met je server interacteren.
• MCP biedt een gestructureerd alternatief voor webscraping, waardoor agents je diensten sneller, nauwkeuriger en schaalbaarder kunnen gebruiken.
• Door nu al MCP te implementeren of voor te bereiden, positioneer je je website als voorloper in de opkomende agent-economie.

Veelgestelde vragen

MCP doet voor AI-agents wat HTTP deed voor webbrowsers: het creëert een universele taal voor communicatie tussen machines en diensten.