Model Context Protocol: Bouw vandaag je eerste MCP-server

Het Model Context Protocol (MCP) is een open standaard die AI-modellen een universele manier geeft om verbinding te maken met externe tools, databronnen en diensten. In plaats van voor elke model-tool combinatie aangepaste integratiecode te schrijven, schrijf je één MCP-server en elk compatibel model kan hem gebruiken. Anthropic creëerde MCP eind 2024, de Linux Foundation beheert het nu, en OpenAI, Google en de rest van het agentische AI-ecosysteem hebben het geadopteerd. Hier is alles wat je moet begrijpen, bouwen en deployen met MCP.

MCP in één oogopslag

Als je de snelle versie wilt voordat je 6.000 woorden aan details induikt, hier is hij.

Laten we elk van deze punten uitpakken, te beginnen met wat MCP eigenlijk is en het probleem dat het noodzakelijk maakte.

Wat is het Model Context Protocol?

Het Model Context Protocol is een open, op JSON-RPC gebaseerd protocol dat standaardiseert hoe AI-modellen externe tools en data ontdekken en ermee interacteren. Zie het als HTTP voor AI-integraties -- een gedeelde taal die elk model en elke tool kan spreken.

Je hebt waarschijnlijk de USB-C-analogie gehoord, en die is nuttig tot op zekere hoogte: vóór USB-C had elk apparaat zijn eigen kabel nodig. MCP doet hetzelfde voor AI, maar de analogie onderschat het. USB-C draagt alleen data en stroom over. MCP draagt tooldefinities, datatoegangpatronen, herbruikbare prompt-templates en laat zelfs servers completions van het model opvragen. Het is een rijker protocol dan een kabelmetafoor suggereert.

Het M x N-probleem dat MCP oplost

Zonder MCP vereist het verbinden van M modellen met N tools M x N aangepaste integraties. Stel dat je 5 LLM's ondersteunt (Claude, GPT-4, Gemini, Llama, Mistral) en ze toegang moet geven tot 10 tools (GitHub, Postgres, Slack, Jira, enzovoort). Dat zijn 50 maatwerkintegratilagen, elk met eigen authenticatie, foutafhandeling en dataformattering.

Met MCP implementeert elk model het MCP-clientprotocol één keer, en elke tool implementeert één keer een MCP-server. Nu zijn het 5 + 10 = 15 implementaties in plaats van 50. Een nieuw model toevoegen? Het werkt meteen met alle 10 tools. Een nieuwe tool toevoegen? Alle 5 modellen kunnen hem gebruiken.

Een korte geschiedenis van MCP

Anthropic maakte MCP open source in november 2024 met SDK's voor Python en TypeScript plus connectoren voor Claude Desktop. Adoptie ging snel. OpenAI voegde MCP-ondersteuning toe aan ChatGPT in maart 2025. Google volgde voor Gemini in april 2025. In december 2025 doneerde Anthropic MCP aan de nieuwe Agentic AI Foundation (AAIF) van de Linux Foundation, mede opgericht met Block en OpenAI, waardoor MCP een leveranciersneutrale standaard werd met sectoroverschrijdend bestuur.

Wat MCP NIET is:

• Geen model en geen AI-framework (het is een protocol, zoals HTTP)
• Geen vervanging voor LangChain of LlamaIndex (dat zijn orchestratielagen; MCP zit daaronder)
• Niet beperkt tot Anthropic of Claude (het is modelonafhankelijk by design)
• Niet hetzelfde als function calling (meer hierover in de vergelijkingssectie)

Hoe werkt MCP? Architectuur in detail

MCP heeft drie rollen, en ze door elkaar halen is de meest voorkomende beginnersfout. Laten we het onderscheid duidelijk maken.

Host, Client en Server -- Wat is het verschil?

Hier is een concreet voorbeeld: je vraagt Claude Desktop om je open GitHub-pull requests te controleren. Claude Desktop is de host. Zijn ingebouwde MCP-client opent een verbinding met de GitHub MCP-server. De server roept de GitHub-API aan, haalt je PR's op en geeft de resultaten terug aan de client, die ze doorgeeft aan het model.

Een enkele host kan meerdere clients uitvoeren, elk verbonden met een andere server. Zo kan Claude Desktop tegelijkertijd toegang hebben tot GitHub, je Postgres-database en Slack -- drie afzonderlijke MCP-servers, drie afzonderlijke clientverbindingen, één host.

Hoe berichten stromen (JSON-RPC 2.0)

Alle MCP-communicatie gebruikt JSON-RPC 2.0 -- een lichtgewicht verzoek/antwoord-protocol. Hier is hoe een tools/list-uitwisseling er op de draad uitziet:

// Clientverzoek: "Welke tools heb je?"
{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/list"
}

// Serverantwoord: één tool beschikbaar
{
  "jsonrpc": "2.0",
  "id": 1,
  "result": {
    "tools": [
      {
        "name": "get_weather",
        "description": "Huidig weer voor een stad ophalen",
        "inputSchema": {
          "type": "object",
          "properties": {
            "city": { "type": "string" }
          },
          "required": ["city"]
        }
      }
    ]
  }
}

Het model leest deze tooldefinities, beslist wanneer ze aan te roepen op basis van het verzoek van de gebruiker, en de client stuurt een tools/call-verzoek terug naar de server met de juiste argumenten.

Verbindingslevenscyclus

Elke MCP-sessie volgt dezelfde levenscyclus:

1. Initialiseren -- client stuurt capabilities, server antwoordt met de zijne
2. Capability-onderhandeling -- beide partijen komen overeen over ondersteunde functies (tools, resources, prompts, sampling)
3. Gereed -- de verbinding is actief; verzoeken stromen in beide richtingen
4. Verzoeken/antwoorden -- tools/call, resources/read, enz.
5. Afsluiten -- schone verbreking

Deze handshake zorgt voor voorwaartse compatibiliteit. Als een server een nieuwe primitive toevoegt, negeren oudere clients die op een nette manier in plaats van te crashen.

MCP-primitieven: Tools, Resources, Prompts en Sampling

MCP definieert vier primitieven, en begrijpen wie elk beheert is de sleutel tot het ontwerpen van goede MCP-servers.

Tools (modelgestuurd)

Tools zijn functies die het model kan aanroepen. De server declareert ze met een naam, beschrijving en JSON Schema-invoerdefinitie. Het model leest deze definities en beslist, wanneer het verzoek van een gebruiker dat vereist, de tool aan te roepen.

// Client stuurt tools/call-verzoek
{
  "jsonrpc": "2.0",
  "id": 2,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": { "city": "Amsterdam" }
  }
}

Als je OpenAI function calling hebt gebruikt, zullen tools vertrouwd aanvoelen -- maar ze zijn gestandaardiseerd voor elk MCP-compatibel model.

Resources (applicatiegestuurd)

Resources zijn alleen-lezen data-endpoints. In tegenstelling tot tools beslist het model niet zelf om een resource op te halen -- de hostapplicatie of gebruiker koppelt resources expliciet aan de conversatiecontext. Zie ze als GET-endpoints: postgres://mydb/users/schema, file://docs/api-reference.md.

Resources ondersteunen abonnementen via resources/subscribe, zodat de client op de hoogte gesteld kan worden wanneer data verandert.

Prompts (gebruikersgestuurd)

Prompts zijn herbruikbare templates die een MCP-server beschikbaar stelt. Een code_review-prompt kan een bestandspad accepteren en een gestructureerd review-verzoek genereren. De gebruiker (of de host-UI) triggert prompts expliciet -- ze worden niet automatisch door het model aangeroepen.

Sampling (servergeïnitieerd) -- Geavanceerd

Hier is de primitief die de meeste gidsen overslaan. Sampling laat de server de client vragen een completion te genereren met de LLM. Dit keert de gebruikelijke stroom om: in plaats van dat het model een tool aanroept, roept de tool het model aan.

Waarom? Agentische lussen. Stel je een MCP-server voor die supporttickets verwerkt. Hij leest het ticket (een resource), gebruikt sampling/createMessage om het model naar een samenvatting te vragen, en gebruikt die samenvatting vervolgens om het ticket via een tool te routeren. De server orkestreert een meerstaps workflow waarbij de intelligentie van het model wordt benut.

Sampling wordt beheerd door de hostapplicatie -- de gebruiker moet het goedkeuren, en de host beheert wat de server kan aanvragen. Dit voorkomt ongecontroleerde lussen en behoudt menselijk toezicht.

Je eerste MCP-server bouwen: Python en TypeScript naast elkaar

Genoeg theorie. Laten we een werkende MCP-server bouwen die een get_weather-tool beschikbaar stelt. Ik laat zowel Python als TypeScript zien zodat je de ontwikkelaarservaring kunt vergelijken en de stack kunt kiezen die bij je project past.

Python met FastMCP

FastMCP is de officiële high-level Python SDK. Het regelt alle protocolinfrastructuur zodat je je kunt concentreren op je toollogica.

# FastMCP installeren
pip install fastmcp

# weather_server.py
from fastmcp import FastMCP

mcp = FastMCP("Weather Server")

@mcp.tool()
def get_weather(city: str) -> str:
    """Huidig weer voor een stad ophalen."""
    # In productie hier een echte weer-API aanroepen
    weather_data = {
        "Amsterdam": "Bewolkt, 10°C",
        "Tokyo": "Zonnig, 22°C",
        "New York": "Regenachtig, 8°C",
    }
    return weather_data.get(city, f"Geen data voor {city}")

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

Dat is het -- 15 regels. FastMCP leidt het invoerschema van de tool af uit de Python-typehints en docstring. Geen JSON Schema-boilerplate.

TypeScript met de officiële SDK

De TypeScript SDK (@modelcontextprotocol/sdk) is iets explicieter maar geeft je volledige controle over schemadefinities.

# SDK en Zod voor schemavalidatie installeren
npm install @modelcontextprotocol/sdk zod

// weather-server.ts
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 Server",
  version: "1.0.0",
});

server.tool(
  "get_weather",
  "Huidig weer voor een stad ophalen",
  { city: z.string() },
  async ({ city }) => {
    const weatherData: Record<string, string> = {
      Amsterdam: "Bewolkt, 10°C",
      Tokyo: "Zonnig, 22°C",
      "New York": "Regenachtig, 8°C",
    };
    return {
      content: [
        { type: "text", text: weatherData[city] ?? `Geen data voor ${city}` },
      ],
    };
  }
);

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

De TypeScript-versie gebruikt Zod-schema's in plaats van typehints en geeft gestructureerde inhoudsblokken terug. Uitgebreider, maar de typeveiligheid is uitstekend.

Verbinden met Claude Desktop

Om een van beide servers te koppelen aan Claude Desktop, voeg hem toe aan je claude_desktop_config.json:

{
  "mcpServers": {
    "weather-python": {
      "command": "python",
      "args": ["weather_server.py"],
      "cwd": "/pad/naar/je/project"
    },
    "weather-typescript": {
      "command": "npx",
      "args": ["tsx", "weather-server.ts"],
      "cwd": "/pad/naar/je/project"
    }
  }
}

Herstart Claude Desktop en beide weerservers verschijnen in de toollijst. Vraag "Wat is het weer in Amsterdam?" en het model roept je get_weather-tool automatisch aan.

Testen met MCP Inspector

Voordat je je server aan een host koppelt, test hem geïsoleerd met de MCP Inspector:

npx @modelcontextprotocol/inspector python weather_server.py

De Inspector opent een browser-UI waar je ontdekte tools kunt zien, ze handmatig kunt aanroepen en de JSON-RPC-berichten kunt inspecteren die heen en weer gaan. Het is het beste debuggingtool in het MCP-ecosysteem -- gebruik het vroeg en vaak.

MCP-transporten: stdio voor ontwikkeling, Streamable HTTP voor productie

MCP-berichten hebben een manier nodig om tussen client en server te reizen. Dat is de transportlaag, en de juiste kiezen is belangrijk.

stdio werkt door de MCP-server als subproces te starten en te communiceren via stdin/stdout. Dat is wat je in de bovenstaande tutorial gebruikte -- geen poorten, geen TLS, geen authenticatie nodig. Perfect voor ontwikkeling en eengebruikers lokale tools.

Streamable HTTP is het productietransport, toegevoegd in de 2025-specificatie-update. Clients sturen standaard HTTP POST-verzoeken naar de server. De server kan synchroon of via een SSE-stream voor langdurige operaties antwoorden. Het is stateless-vriendelijk, werkt achter load balancers en ondersteunt standaard HTTP-authenticatie.

Als je oudere tutorials ziet die "HTTP+SSE" als twee afzonderlijke transporten noemen (één voor verzenden, één voor ontvangen), dat is de verouderde aanpak. Streamable HTTP consolideert beide in één enkel, schoner mechanisme.

De beslissing is eenvoudig: gebruik stdio bij lokale ontwikkeling, schakel over naar streamable-http bij deployment voor anderen.

// Overschakelen van stdio naar Streamable HTTP in TypeScript
import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";

const transport = new StreamableHTTPServerTransport({ port: 3001 });
await server.connect(transport);

MCP vs Function Calling vs REST API's -- Wanneer gebruik je wat

Dit is de vraag die in elk MCP-gesprek opkomt, dus laten we het regelen met een directe vergelijking.

Wanneer function calling voldoet

Als je minder dan 5 tools hebt en één model gebruikt, is function calling eenvoudiger. Je definieert je toolschema's inline bij elke API-aanroep, het model geeft de functienaam en argumenten terug, en je voert ze uit in je applicatiecode. Geen server om te draaien, geen protocol om te leren. Voor een chatbot die de bestelstatus controleert en FAQ's opzoekt, is function calling prima.

Wanneer MCP de moeite waard is

MCP rechtvaardigt zijn complexiteit wanneer:

• Je meerdere LLM's ondersteunt en tooldefinities niet opnieuw wilt schrijven voor elke aanbieder
• Je tool-ontdekking nodig hebt -- het model kan opvragen wat beschikbaar is in plaats van dat je schema's hardcoded
• Je resources en prompts wilt, niet alleen toolaanroepen
• Je AI-agenten bouwt die autonoom coördineren en een gestandaardiseerde integratielaag nodig hebben
• Je team groeit en verschillende ingenieurs verschillende tools bouwen -- MCP laat hen onafhankelijk werken

Conclusie: MCP wint wanneer je gestandaardiseerde, multi-model toegang tot tools nodig hebt. Function calling wint voor eenvoudige, eenmodels-gebruiksgevallen. REST API's blijven de juiste keuze voor traditionele service-naar-service communicatie zonder LLM.

Het MCP-ecosysteem in 2026: Wie ondersteunt het en wat is beschikbaar

MCP is in minder dan 18 maanden van een Anthropic-nevenproject naar een industriestandaard gegaan. Hier staat het.

Welke LLM's ondersteunen MCP?

Populaire MCP-servers die het waard zijn om te kennen

De aankondiging van de Linux Foundation AAIF noemde 10.000+ actieve servers en 97 miljoen maandelijkse SDK-downloads op het moment van de overdracht van MCP in december 2025. Het ecosysteem is niet meer experimenteel -- het is productieklaar.

MCP Apps is een nieuwe primitief geïntroduceerd in januari 2026. Het laat servers interactieve UI-componenten bieden die worden weergegeven in de hostapplicatie. Nog vroeg, maar het signaleert de evolutie van MCP van een dataprotocol naar een volledig agentapplicatieframework. De moeite waard om in de gaten te houden.

Bestuur: Van Anthropic naar de Linux Foundation

MCP wordt beheerd door de Agentic AI Foundation (AAIF) onder de Linux Foundation, mede opgericht door Anthropic, Block en OpenAI. Dit is belangrijk voor bedrijfsadoptie: MCP is niet gebonden aan de roadmap van één leverancier. De 2026-roadmap richt zich op transportevolutie, agent-naar-agent-communicatie (een nieuwe "Tasks"-primitief), bestuursmaturatie en bedrijfsgereedheid.

Voor teams die productie-AI-systemen bouwen, integreren frameworks zoals een autonoom AI-agentframework zoals OpenClaw al met MCP-servers om agenten echte mogelijkheden te geven.

MCP-beveiliging: OAuth 2.1, dreigingen en een praktische checklist

Beveiliging is waar het MCP-ecosysteem het meest bij te halen heeft. En de cijfers schilderen een duidelijk beeld.

Het 88%-probleem: Waarom de meeste MCP-servers onveilig zijn

Astrix Security analyseerde 5.200+ open-source MCP-server-implementaties en ontdekte dat 88% op een of andere manier inloggegevens vereist -- maar 53% vertrouwt op onveilige langlevende statische geheimen zoals API-sleutels en persoonlijke toegangstokens die hardcoded zijn in configuratiebestanden. Slechts 8,5% implementeert OAuth.

Dat betekent dat de overgrote meerderheid van MCP-servers in het wild het authenticatie-equivalent gebruikt van je huissleutel aan de voordeur plakken.

OAuth 2.1 voor MCP-servers

De MCP-specificatie vereist OAuth 2.1 voor alle op HTTP gebaseerde servers vanaf de update van juni 2025. De stroom werkt als volgt: de MCP-client initieert een OAuth 2.1-autorisatiestroom met de server, verkrijgt een toegangstoken met beperkt bereik en voegt het toe aan elk volgend verzoek. PKCE (Proof Key for Code Exchange) is vereist voor alle clients -- geen uitzonderingen.

Als je een MCP-server bouwt die via Streamable HTTP werkt, is OAuth 2.1 niet optioneel. Het is vereist door de specificatie.

Dreigingsmodel: Wat er mis kan gaan

Vier dreigingen verdienen aandacht bij elke MCP-implementatie:

• Prompt-injectie via tools -- Een kwaadaardige of gecompromitteerde databron geeft content terug die is ontworpen om het model te manipuleren. Als een tool een webpagina ophaalt en die pagina verborgen instructies bevat, kan het model ze uitvoeren.
• Confused deputy-aanval -- Het model roept een tool aan met bredere rechten dan de gebruiker bedoelde. Als de MCP-server beheerderstoegang tot een database heeft, kan het model theoretisch een tabel verwijderen.
• Token-concentratierisico -- Een MCP-server die API-sleutels bewaart voor GitHub, Slack en je productiedatabase is één enkel doelwit van hoge waarde. Eén server compromitteren, alles compromitteren waarmee hij verbinding maakt.
• Onveilig transport -- Een HTTP MCP-server zonder TLS uitvoeren stelt elk verzoek bloot, inclusief OAuth-tokens en gevoelige data, in leesbare tekst.

Beveiligingschecklist voor productie-MCP

1. OAuth 2.1 implementeren voor elke server die via HTTP toegankelijk is. Geen statische API-sleutels in configuratiebestanden.
2. Least-privilege scoping toepassen. Als je tool alleen data leest, moeten de inloggegevens van de server alleen-lezen zijn. Geef een rapportagetool geen schrijftoegang.
3. Inloggegevens isoleren. Elke MCP-server moet zijn eigen beperkte tokens hebben. Deel niet één enkel "god-token" over servers.
4. TLS overal afdwingen. Streamable HTTP zonder HTTPS is automatisch niet geschikt voor productie.
5. Tool-uitvoer valideren en opschonen. Behandel data die door tools wordt geretourneerd op dezelfde manier als gebruikersinvoer -- vertrouw het niet blind.
6. Toolaanroepen snelheidsbeperken. Een ongecontroleerde agentlus die een tool duizenden keren aanroept, kan API-quota uitputten of onbedoelde bijwerkingen veroorzaken.
7. Elke toolaanroep controleren en loggen. Voeg verzoek-ID's, tijdstempels, het aanroepende model en de toolargumenten toe. Je hebt dit nodig voor debugging en voor reactie op beveiligingsincidenten.

MCP debuggen: Inspector, logging en veelvoorkomende fouten

Je zult fouten tegenkomen. Elke ontwikkelaar doet dat. Hier is hoe je ze snel oplost.

MCP Inspector is het officiële debuggingtool en je eerste verdedigingslinie. Het verbindt met elke MCP-server, ontdekt zijn tools/resources/prompts en laat je ze handmatig aanroepen terwijl het het ruwe JSON-RPC-verkeer toont.

# Inspector starten tegen je Python-server
npx @modelcontextprotocol/inspector python weather_server.py

# Of tegen een TypeScript-server
npx @modelcontextprotocol/inspector npx tsx weather-server.ts

De Inspector opent een browsergebaseerde UI met tabbladen voor Tools, Resources, Prompts en een meldingenpaneel. Je kunt elke tool aanroepen met aangepaste argumenten en precies zien welke JSON over de draad gaat. Gebruik het voordat je verbinding maakt met een hostapplicatie -- het is veel eenvoudiger om de server geïsoleerd te debuggen.

Veelvoorkomende fouten en oplossingen

• "Server niet gevonden" in Claude Desktop -- Bijna altijd een padprobleem in claude_desktop_config.json. Controleer of command verwijst naar een echt binair bestand en cwd naar de juiste map. Op macOS, gebruik absolute paden.
• Toolschema-validatiefouten -- Als het model argumenten stuurt die niet overeenkomen met het inputSchema van de tool, weigert de server de aanroep. Controleer of je schematypes overeenkomen met wat het model verwacht. Zod (TypeScript) en typehints (Python) vangen de meeste hiervan af bij de definitietijd.
• Transportverbindingsdroppages -- Voor stdio betekent dit meestal dat het serverproces is gecrasht. Controleer de stderr-uitvoer. Voor Streamable HTTP, controleer time-outinstellingen -- langlopende tools kunnen standaard HTTP-time-outs overschrijden.
• "Permission denied" of 401-fouten -- OAuth-bereik te smal. De server wijst het token af omdat het niet de vereiste rechten heeft. Vergroot het bereik, maar alleen zo veel als de tool echt nodig heeft.

Best practices voor logging

Structureer je logs met verzoek-ID's zodat je een enkel gebruikersverzoek kunt traceren via de MCP-client, server en eventuele downstream API's. Log elke tools/call-aanroep met de toolnaam, argumenten, responstijd en resultatenstatus. In productie, stuur deze logs naar een observabiliteitsplatform -- wanneer er om 3 uur 's nachts iets mis gaat, zul je blij zijn dat je dat hebt gedaan.

Hoe Techsy bouwt met MCP

We integreren MCP in klantprojecten sinds begin 2025, en het patroon dat we het vaakst zien is dit: een team heeft een AI-functie die werkt met één model en een handvol tools, maar plant te schalen -- meer modellen, meer databronnen, meer agentmogelijkheden. Dat is het kantelpunt waar MCP zijn vruchten begint af te werpen.

Onze aanpak volgt drie stappen:

1. Geschiktheid beoordelen. Niet elk project heeft MCP nodig. Als je twee tools aanroept vanuit één model, is function calling eenvoudiger en dat zullen we je zeggen. MCP is zinvol wanneer je 3+ databronnen verbindt, meerdere modellen ondersteunt, of agentworkflows bouwt waarbij tools ontdekbaar moeten zijn.
2. Servers geïsoleerd bouwen en testen. We ontwikkelen aangepaste MCP-servers voor elke databron -- interne databases, SaaS-API's, eigen diensten -- en valideren ze met MCP Inspector voordat we verbinding maken met een host.
3. Deployen met Streamable HTTP en OAuth 2.1. Voor productie draaien we MCP-servers als gecontaineriseerde diensten achter TLS, met beperkte OAuth-tokens en gestructureerde logging vanaf dag één. Geen statische geheimen.

De meest voorkomende integraties die we bouwen: AI-assistenten verbinden met interne Postgres-databases, aangepaste MCP-servers bouwen voor SaaS-platforms van klanten, en teams migreren van verspreide function-calling-setups naar een gestandaardiseerde MCP-architectuur.

Bouw je AI-aangedreven tools die verbinding moeten maken met je infrastructuur? We helpen teams MCP-integraties te ontwerpen en implementeren. Vraag een gratis consultatie aan

Veelgestelde vragen over MCP

Wat is het Model Context Protocol (MCP)?

MCP is een open standaard, oorspronkelijk gemaakt door Anthropic en nu beheerd door de Linux Foundation, die definieert hoe AI-modellen verbinding maken met externe tools, databronnen en diensten. Het standaardiseert de integratielaag zodat één MCP-server werkt met elk compatibel model -- zoals een universele stekker voor AI.

Hoe werkt MCP?

MCP gebruikt een driedelige architectuur: een host-applicatie (zoals Claude Desktop of Cursor), een MCP-client binnen de host die verbindingen beheert, en MCP-servers die tools en data beschikbaar stellen. Alle communicatie gebruikt JSON-RPC 2.0-berichten via stdio (lokaal) of Streamable HTTP (extern).

Waarvoor wordt MCP gebruikt?

Veelgebruikte toepassingen omvatten het verbinden van AI-assistenten met databases (Postgres, MySQL), integratie met codeplatforms (GitHub, GitLab), toegang tot SaaS-tools (Slack, Notion, Google Drive) en het bouwen van autonome AI-agenten die moeten interacteren met echte diensten.

Is MCP hetzelfde als function calling?

Nee. Function calling is modelspecifiek (het formaat van OpenAI verschilt van dat van Anthropic) en per verzoek -- je stuurt toolschema's bij elke API-aanroep. MCP is een gestandaardiseerd protocol dat over modellen heen werkt, tool-ontdekking ondersteunt en resources en prompts omvat naast alleen functie-uitvoering.

Wat zijn MCP-servers?

MCP-servers zijn programma's die tools, resources en prompts beschikbaar stellen aan AI-modellen via het MCP-protocol. Ze omhullen externe API's en databronnen in een gestandaardiseerde interface. Voorbeelden zijn de GitHub MCP-server (voor PR- en issuebeheer) en de Postgres MCP-server (voor databasequery's).

Hoe bouw ik een MCP-server?

Gebruik Python met FastMCP (pip install fastmcp) of TypeScript met de officiële SDK (npm install @modelcontextprotocol/sdk). Definieer je tools als gedecoreerde functies (Python) of geregistreerde handlers (TypeScript), start dan de server. Zie de tutorialsectie hierboven voor volledig werkende code.

Is MCP veilig?

Het protocol zelf ondersteunt OAuth 2.1 voor authenticatie en beperkte rechten. Echter, Astrix Security-onderzoek vond dat 88% van de bestaande MCP-server-implementaties vertrouwt op statische geheimen in plaats van OAuth. Het protocol is veilig by design, maar de meeste echte implementaties hebben dat nog niet ingehaald.

Welke LLM's ondersteunen MCP?

Claude heeft native MCP-ondersteuning sinds zijn creatie in november 2024. ChatGPT voegde ondersteuning toe in maart 2025, en Gemini volgde in april 2025. Open-source modellen kunnen MCP gebruiken via adapters in LangChain en LlamaIndex.

Wat is het verschil tussen MCP en een REST API?

REST API's zijn ontworpen voor algemene service-naar-service communicatie. MCP is specifiek ontworpen voor interactie met AI-modellen -- het omvat tool-ontdekking, schema-onderhandeling, resourcetoegang en prompt-templates die REST niet heeft. Je zou je REST API's niet vervangen door MCP; ze dienen verschillende lagen.

Wie onderhoudt MCP nu?

De Agentic AI Foundation (AAIF) van de Linux Foundation, opgericht in december 2025, beheert MCP. Het werd mede opgericht door Anthropic, Block en OpenAI. Dit leveranciersneutrale bestuur is een belangrijke reden waarom bedrijven MCP adopteren.

Wat is Streamable HTTP in MCP?

Streamable HTTP is het productietransportmechanisme toegevoegd in de 2025 MCP-specificatie-update. Het vervangt het oudere HTTP+SSE-transport door een schoner ontwerp: clients sturen HTTP POST-verzoeken en servers kunnen synchroon of via SSE-streaming antwoorden. Het werkt achter load balancers en ondersteunt standaard HTTP-authenticatie.

Hoeveel MCP-servers zijn er?

De Linux Foundation noemde 10.000+ actieve servers en 97 miljoen maandelijkse SDK-downloads toen MCP in december 2025 werd overgedragen aan AAIF. Het ecosysteem omvat databases, codetools, SaaS-integraties, zoekmachines en cloudinfrastructuurproviders.

Conclusie

MCP is in iets meer dan een jaar van Anthropics open-source experiment naar het industriestandaard protocol voor het verbinden van AI-modellen met tools gegaan. Hier is wat er toe doet:

• MCP lost het M x N-probleem op -- één server werkt met elk compatibel model, één client werkt met elke server
• Je kunt een werkende MCP-server bouwen in minder dan 50 regels Python (FastMCP) of TypeScript
• Gebruik stdio voor ontwikkeling, Streamable HTTP voor productie -- de transportkeuze is eenvoudig
• Beveilig je servers met OAuth 2.1 -- 88% van de huidige implementaties doet dat niet, en dat is een echt risico
• Het ecosysteem is productieklaar -- 10.000+ servers, alle grote LLM's, leveranciersneutraal bestuur onder de Linux Foundation

Vooruitkijkend richt de 2026-roadmap zich op agent-naar-agent communicatie via een nieuwe Tasks-primitief, verbeterde bedrijfsbeveiliging en MCP Apps voor interactieve servergestuurde UI. MCP is niet meer alleen een protocol voor toegang tot tools -- het wordt de infrastructuurlaag voor agentische AI.

Begin met de tutorialcode hierboven, test hem in MCP Inspector en verbind hem met Claude Desktop. Je hebt een werkende MCP-integratie in minder dan een uur.

Bronnen

• MCP-specificatie (2025-11-25)
• MCP-autorisatiespecificatie
• MCP-transportspecificatie
• MCP Inspector-documentatie
• Introductie van het Model Context Protocol -- Anthropic
• MCP doneren aan de Linux Foundation -- Anthropic
• Linux Foundation AAIF-aankondiging
• Google Cloud MCP-ondersteuning
• FastMCP Python SDK
• MCP TypeScript SDK
• Astrix Security: Stand van MCP-serverbeveiliging 2025
• MCP 2026-roadmap