Model Context Protocol: toolbox voor AI-agents of halffabricaat?

MCP (Model Context Protocol) duikt de laatste maanden steeds vaker op in AI-gesprekken. Het idee: een standaardprotocol waarmee AI-agents zelf ontdekken welke tools beschikbaar zijn, hoe ze werken en hoe je ze aanroept. Geen custom code meer per integratie. De agent inspecteert wat er is, kiest wat hij nodig heeft en gaat aan de slag.

Klinkt aantrekkelijk. Minder technische overhead, sneller resultaat. Maar MCP is bedrading, geen platform. De vraag is of het voor jouw situatie al volwassen genoeg is.

Hoe werkt MCP?

MCP zit een laag boven bestaande API’s. Het vervangt ze niet, het wrapt ze. Een REST-API of GraphQL-endpoint blijft gewoon bestaan, maar wordt ontsloten als ‘tool’ met een gestandaardiseerde beschrijving. Die beschrijving (in JSON-schema) vertelt de agent wat de tool doet, welke input hij verwacht en wat hij teruggeeft.

De communicatie verloopt via JSON-RPC 2.0, over stdio, HTTP of WebSocket. Een client (de AI-agent) verbindt met een MCP-server, vraagt welke tools er zijn en roept ze aan. De agent hoeft niet van tevoren te weten welke mogelijkheden er liggen.

Dat is fundamenteel anders dan traditionele API-integraties. Vroeger bouwde je een workflow met vaste stappen: eerst dit endpoint, dan dat endpoint. Als de situatie veranderde, faalde de workflow. Nu kan een agent zijn aanpak aanpassen op basis van wat hij tegenkomt.

Waarom bestaande API’s tekort schieten

REST en GraphQL zijn ontworpen voor voorspelbare consumenten. Een mobiele app weet precies welke endpoints hij moet aanroepen, in welke volgorde. Een AI-agent niet. Die redeneert, plant en beslist onderweg.

Stel: een agent moet data van een CRM ophalen, valideren en doorsturen naar een rapportage-systeem. In een traditionele workflow zijn alle stappen hardcoded. Bij MCP kan de agent zelf besluiten welke validatiestap nodig is, afhankelijk van wat hij in de data tegenkomt. Ontbreekt een veld? Dan zoekt hij een tool die dat veld kan afleiden of aanvullen.

Dat vraagt meer flexibiliteit dan een REST-API biedt. MCP voegt die laag toe.

Wat levert dit op?

Snellere implementatie
Je hoeft geen custom integratielogica te schrijven per agent of per use case. Eenmaal gewrapte tools zijn herbruikbaar. Een ontwikkelaar publiceert een set MCP-tools, en elke agent die toegang heeft kan ze gebruiken. Dat scheelt tijd en onderhoudswerk. Een klein team met beperkte capaciteit ziet sneller resultaat van AI-initiatieven.

Bredere inzetbaarheid
Agents kunnen een groter scala aan taken aan, omdat ze dynamisch toegang krijgen tot meer capabilities. Een agent die voorheen alleen data kon ophalen, kan nu ook pipelines starten, schemas valideren of fouten troubleshooten, mits die functies als MCP-tools zijn blootgesteld.

Minder breekbare workflows
Traditionele integraties breken als een endpoint verandert. Bij MCP kan een agent zelf zoeken naar een alternatief. Dat maakt systemen robuuster, al hangt dat wel af van hoe goed de tool-beschrijvingen zijn en hoe slim de agent kan schakelen.

De keerzijde: dit is geen compleet platform

MCP definieert hoe agents tools ontdekken en aanroepen, maar het regelt niet:

  • Authenticatie en toegangscontrole. De eerste versie van het protocol had helemaal geen ingebouwde authenticatie. De tweede revisie voegde basisondersteuning toe, maar voor enterprise-omgevingen schiet dat tekort. OAuth 2.1, OIDC, federated identity: dat moet er allemaal nog bovenop.
  • Versioning en lifecycle management. Hoe publiceer je een nieuwe versie van een tool? Hoe fasel je een oude uit? MCP zegt daar niets over.
  • Monitoring en logging. Geen standaard voor metrics, geen ingebouwde audit trails. Dat moet je zelf bouwen.
  • Governance en policy enforcement. Welke agent mag welke tool gebruiken? Wat zijn de rate limits? Dat moet een laag eromheen regelen.

We draaien AI-applicaties in containers bij klanten en hebben een uptime van 99,98% over de hele linie. Maar zelfs met die infrastructuur heb je bij MCP aanvullende tooling nodig om veiligheid en controle te garanderen.

Waar zie je dit al?

Ontwikkelomgevingen zoals Replit en Sourcegraph gebruiken MCP voor context-aware code navigatie. Een agent kan door een codebase navigeren, dependencies opzoeken en wijzigingen doorvoeren, allemaal via MCP-tools die de structuur en mogelijkheden van de omgeving ontsluiten.

Organisaties als Anthropic, OpenAI, Microsoft en Salesforce experimenteren ermee. Dat zijn vooral proof-of-concepts en interne projecten, geen grootschalige productie-rollouts.

Voor bedrijven zonder dedicated AI-teams is de vraag of dit al praktisch is. Je hebt tijd nodig om bestaande API’s als MCP-tools te wrappen, je moet zelf authenticatie en monitoring regelen, en je moet ontdekken welke use cases genoeg opleveren om die investering te rechtvaardigen.

Wat heb je nodig om dit zinvol in te zetten?

MCP alleen is niet genoeg. Dit zijn de voorwaarden:

  • Toegankelijke, hoogwaardige data. Agents hebben structured data nodig waar ze over kunnen redeneren. Zonder goede metadata, constraints en lineage blijft een agent gissen.
  • Betrouwbare tools met goede documentatie. Een tool die onduidelijk beschreven is of onvoorspelbaar gedrag vertoont, is waardeloos voor een agent.
  • Identity en access control. Je moet kunnen regelen wie wat mag, op tool-niveau.
  • Observability. Log wat agents doen, zodat je fouten kunt debuggen en audits kunt uitvoeren.
  • Governance-infrastructuur. Policies, rate limits, versioning: dat moet je zelf optuigen of inkopen.

Ontbreekt een van deze elementen, dan levert MCP frustratie op in plaats van efficiëntie.

Moet je hier nu mee aan de slag?

Dat hangt af van je situatie.

Begin met experimenteren als:

  • Je al een solide API-landschap hebt dat je kunt wrappen.
  • Je een use case hebt waar flexibiliteit écht verschil maakt: denk aan dynamische workflows die nu te rigide zijn.
  • Je capaciteit hebt om zelf authenticatie, logging en governance te bouwen.

Wacht nog even als:

  • Je verwacht dat MCP out-of-the-box security en monitoring meelevert.
  • Je organisatie compliance-eisen heeft waar geen ruimte is voor experimentele protocollen zonder first-class identity management.
  • Je hoopt dat vendors snel platforms leveren met geïntegreerde governance. Die zijn in ontwikkeling, maar nog niet breed beschikbaar.

Een praktische aanpak: wrap één of twee interne API’s als MCP-tools, laat een agent ermee spelen in een gecontroleerde omgeving en kijk of het oplevert wat je verwacht. Begin klein, meet resultaat, schaal pas op als het bewezen waarde heeft.

Potentie aanwezig, volwassenheid volgt nog

MCP lost een echt probleem op: het toegankelijk maken van API’s voor AI-agents zonder per use case custom code te schrijven. Dat is winst.

Maar het is halffabricaat. Security, governance, monitoring: dat moet je zelf regelen. Voor een klein bedrijf zonder dedicated IT-afdeling is dat een drempel. Voor een organisatie met sterke engineering-capaciteit en duidelijke use cases kan het nu al zinvol zijn.

De verwachting is dat er platforms komen die MCP als kern gebruiken en de ontbrekende stukken eromheen bouwen. Tot die tijd is het iets voor early adopters met technische slagkracht.

Wil je dit verkennen? Pak een interne API, schrijf een simpele MCP-wrapper en laat een agent ermee spelen. Dat geeft je binnen een paar uur een gevoel of dit jouw integratie-uitdagingen aanpakt of alleen een extra abstractielaag toevoegt.


AI Generated