Elke tool wil ineens “MCP-compatible” zijn
Sinds eind 2024 staat één afkorting in vrijwel elke AI-aankondiging: MCP, het Model Context Protocol. Tools adverteren dat ze “MCP-compatible” zijn, platforms openen een “MCP-marketplace” en op elke conferentie valt het woord. Net als bij AI agents verbergt de hype een idee dat eigenlijk goed te volgen is.
De aanleiding is een praktisch probleem. Een AI-agent is pas nuttig als hij bij je echte systemen kan: je CRM, je agenda, je database, je documenten. Dat koppelen kostte tot voor kort voor elke combinatie opnieuw werk. MCP is het antwoord daarop, en het is bewust een open standaard geworden in plaats van het trucje van één leverancier.
Het probleem: een eigen koppeling voor elke tool
Stel je hebt drie AI-toepassingen (een chat-assistent, een code-assistent, een supportbot) en je wilt ze alle drie laten praten met drie systemen (Slack, je database, Google Drive). Zonder standaard bouw je elke verbinding apart. Drie toepassingen keer drie systemen zijn negen koppelingen, elk met hun eigen formaat, foutafhandeling en onderhoud. Voeg een vierde tool toe en het aantal loopt hard op.
Zonder standaard schrijf je voor elke AI-tool en elk systeem een aparte integratie. Dat schaalt vermenigvuldigend, en dat is precies waar het in de praktijk vastloopt.
Dat is het patroon dat elke developer kent van vóór de USB-standaard: elk apparaat een eigen kabel en een eigen driver. Het werkt, tot je er tien hebt. Eén koppeling bouwen is technisch simpel. De rem zit in de aantallen: hoeveel koppelingen je moet bouwen en daarna blijven onderhouden.
MCP is een universele stekker
MCP lost dit op met één afspraak over hoe een AI-model en een tool met elkaar praten. Bouw je tool één keer als MCP-server, dan kan elke AI-toepassing die MCP spreekt er direct mee overweg. Andersom hoeft een AI-toepassing maar één protocol te ondersteunen om bij het hele ecosysteem te kunnen.
MCP is voor AI-tools wat USB-C werd voor randapparatuur: één stekker waar alles in past, zodat je niet voor elk apparaat een aparte kabel hoeft te verzinnen.
Daarmee verandert de rekensom uit de vorige paragraaf. Drie toepassingen en drie systemen vragen dan nog maar zes onderdelen die hetzelfde protocol spreken: elke toepassing praat MCP, elk systeem biedt een MCP-server. Toevoegen wordt optellen in plaats van vermenigvuldigen. Het protocol is open en is eind 2024 door Anthropic geïntroduceerd, waarna grote spelers het snel oppakten.
Client en server: hoe MCP technisch werkt
MCP volgt een vertrouwd model: een client die vraagt en een server die levert. De AI-toepassing draait een MCP-client, elk systeem dat je wilt ontsluiten draait een MCP-server. Daartussen lopen berichten in een vast formaat.
De host met de MCP-client
De AI-toepassing (denk aan een chat-assistent of een agent) bevat een MCP-client. Die maakt verbinding met één of meer servers en houdt bij welke mogelijkheden ze aanbieden.
De MCP-server
Een dunne laag rond een systeem of databron: je database, Slack, een agenda, een eigen API. De server vertaalt het MCP-protocol naar wat dat systeem begrijpt, en weer terug.
Tools, resources en prompts
Een server biedt drie soorten dingen aan: tools (acties die het model kan uitvoeren), resources (data die het model kan inlezen) en prompts (kant-en-klare instructies). Het model ontdekt zelf wat beschikbaar is.
Het transport ertussen
De berichten lopen over een vast kanaal, lokaal tussen processen of over het netwerk. Het formaat staat vast, dus client en server hoeven niets over elkaars binnenkant te weten.
Het belangrijke detail: het model hoeft de tools niet vooraf te kennen. Bij het verbinden vraagt de client aan de server welke tools en data er zijn, en die lijst geeft hij aan het model mee. Voeg je een server toe, dan groeit het arsenaal van de agent zonder dat je de agent zelf hoeft aan te passen.
MCP of function calling: wat is het verschil?
Deze twee worden vaak door elkaar gehaald, terwijl ze verschillende lagen zijn die op elkaar leunen. Function calling is het vermogen van het model om te besluiten dat het een tool nodig heeft en de parameters in te vullen. MCP is de afspraak over hoe die tool wordt beschreven, gevonden en bereikt.
Function calling: het model beslist
Het LLM ziet welke tools er zijn, kiest er één en vult de parameters in. Dit zit in het model en bepaalt de keuze: welke tool, met welke waarden.
MCP: de tool wordt bereikbaar
Het protocol regelt hoe die tool zich aanmeldt, welke acties hij aanbiedt en hoe het resultaat terugkomt. Dit zit tussen de toepassing en het systeem en bepaalt de verbinding.
Ze werken samen. Function calling is de beslissing, MCP is de stekker waarlangs die beslissing een echt systeem bereikt. Je kunt function calling gebruiken met handgebouwde koppelingen, en dan doet elke tool het op zijn eigen manier. MCP maakt van die koppelingen één herbruikbare standaard, zodat dezelfde tool in elke MCP-toepassing werkt.
Waar MCP in een agentic workflow past
MCP staat zelden op zichzelf. Het is de koppellaag onder het grotere AI-landschap waar we eerder over schreven. In een agentic workflow doorloopt een agent meerdere stappen en roept onderweg tools aan. MCP is precies hoe hij die tools bereikt: elke stap die de buitenwereld raakt, loopt over een MCP-server.
Ook de andere bouwstenen sluiten hierop aan. Een RAG-systeem dat je eigen documenten doorzoekt, kun je als MCP-server aanbieden, zodat elke agent de vraag “wat staat hierover in onze bronnen?” kan stellen. En de AI-harness eromheen bepaalt welke servers een agent mag gebruiken en onder welke voorwaarden. MCP regelt de verbinding, de harness regelt de grenzen.
Waar het misgaat: één protocol is geen vrijbrief
Een tool aansluiten wordt met MCP bijna triviaal, en daar zit meteen het addertje. Elke MCP-server is een deur naar een echt systeem: je database, je mailbox, je bestanden. Een protocol dat aansluiten makkelijk maakt, maakt ook fout aansluiten makkelijk. De techniek is simpel, het bewaken ervan is het echte werk.
Te ruime rechten
Een server die 'lees en schrijf alles' aanbiedt is zo gebouwd, maar geeft een agent veel meer macht dan een taak nodig heeft. Het uitgangspunt hoort minimaal te zijn: alleen wat deze taak vereist.
Prompt-injectie via toolresultaten
Een agent leest data uit een tool en handelt erop. Staat er in die data een verstopte instructie, dan kan een aanvaller het gedrag sturen. Wat een tool teruggeeft, is niet automatisch te vertrouwen.
Onbekende servers van derden
Een server uit een marketplace klikt zo aan, maar draait code en ziet je data. Zonder te weten wie hem maakt en wat hij doet, laat je een vreemde binnen bij je systemen.
Geen zicht op wat er gebeurt
Als je niet vastlegt welke agent welke tool met welke gegevens aanriep, kun je een incident achteraf niet navertellen. Logging en goedkeuring horen bij de opzet, niet erna.
MCP haalt de moeite uit het koppelen. Daardoor verschuift de moeilijkheid naar de vraag die er altijd al toe deed: wat mag deze agent precies aanraken, en hoe weet je achteraf wat hij deed?
Hier zit het werk dat wij voor klanten doen. Een MCP-server bouwen is een middag. Een opzet waarbij agents alleen de rechten hebben die ze nodig hebben, toolresultaten gewantrouwd worden en elke actie navolgbaar is, dat is de engineering die het verschil maakt tussen een demo en iets waar je je bedrijf op durft te laten draaien.
Wanneer MCP loont
MCP verdient zich terug zodra je meerdere tools of databronnen aan AI wilt koppelen en die koppelingen wilt hergebruiken. Voor een enkel, vast lijntje is het vaak meer dan nodig.
Kies MCP
Je sluit agents aan op meerdere systemen, wilt tools delen tussen toepassingen of meeliften op het groeiende ecosysteem aan bestaande servers. Eén standaard scheelt je een berg losse koppelingen.
MCP is overbodig
Je hebt één toepassing die één API aanroept, vast en voorspelbaar. Dan is een directe koppeling simpeler dan een protocol met een client, een server en een transport eromheen.
Begin ook hier zo simpel mogelijk. Een nette koppeling met krappe rechten brengt je verder dan de langste lijst aangesloten servers. Elke server die je toevoegt, is er ook één die je moet vertrouwen, beperken en in de gaten houden.
Conclusie: één stekker, en daarna de controle
MCP wordt begrijpelijk zodra je het ziet als een universele stekker voor AI. In plaats van voor elke combinatie van toepassing en tool een eigen koppeling te bouwen, spreekt alles hetzelfde protocol. Een tool aansluiten wordt optellen, en het ecosysteem groeit voor je mee.
Eén protocol voor alle tools
Bouw een tool één keer als MCP-server en elke AI-toepassing die MCP spreekt kan ermee overweg. Koppelen wordt optellen in plaats van vermenigvuldigen.
Function calling beslist, MCP verbindt
Het model kiest welke tool het nodig heeft, MCP regelt hoe die tool wordt gevonden en bereikt. Twee lagen die op elkaar leunen.
Controle is waar het op aankomt
Aansluiten is makkelijk geworden, dus de winst zit in krappe rechten, gewantrouwde toolresultaten en navolgbare acties. Daar staat of valt een serieuze opzet.
Begin klein, geef elke agent alleen de tools die hij nodig heeft en leg vast wat hij doet. Dan is MCP precies wat het belooft: de makkelijke manier om AI met je echte systemen te laten werken, zonder dat je het zicht erop kwijtraakt.
Wat is MCP (Model Context Protocol)?
Wie heeft MCP ontwikkeld en is het een open standaard?
Wat is het verschil tussen MCP en function calling?
Wat is een MCP-server?
Is MCP veilig en wat zijn de risico's?
Heb ik MCP nodig?
AI laten praten met je eigen systemen?
Wij koppelen AI-agents via MCP aan je echte tools en data, met krappe rechten, gewantrouwde toolresultaten en navolgbare acties als uitgangspunt. Van eerste opzet tot beheer, zodat je de winst pakt zonder het zicht te verliezen.
