Wat is Model Context Protocol (MCP)?

AI-modellen zijn steeds krachtiger geworden, maar er is een addertje onder het gras: ze hebben alleen toegang tot de informatie die ze tijdens de training hebben geleerd, dus hun kennis en capaciteiten zijn beperkt. Het is alsof je een hele slimme assistent inhuurt die alleen kan werken met wat er al in zijn hoofd zit, en niets kan opzoeken, je bestanden niet kan controleren of daadwerkelijk taken voor je kan uitvoeren.

Large Language Models (LLM's) worden veel krachtiger wanneer ze toegang hebben tot context en actie kunnen ondernemen in andere tools en applicaties. Tot voor kort was er geen uniforme manier voor deze modellen om verbinding te maken met andere apps. Model Context Protocol (MCP), oorspronkelijk ontwikkeld door Anthropic, wordt snel de standaard manier voor AI-agentische systemen om met andere applicaties te interfacen - de "USB-C-connector" voor AI.

Voor meer informatie over hoe Figma MCP ondersteunt, bekijk je onze blogpost waarin we de MCP-server van Figma introduceren. Laten we dieper ingaan op wat MCP is, hoe het werkt en waarom het belangrijk is.

Wat is MCP?

Model Context Protocol (MCP) is een open standaard voor hoe door AI aangedreven systemen verbinding kunnen maken met softwareapplicaties, tools en platforms.

MCP is een tweerichtingscommunicatieprotocol. Aan de ene kant heb je dataproviders en app-ontwikkelaars die willen dat LLM's toegang hebben tot gegevens en actie kunnen ondernemen in hun software. Zij ondersteunen MCP door het bouwen van wat een MCP-server wordt genoemd. Aan de andere kant heb je ontwikkelaars die AI-gestuurde tools of agentische systemen bouwen. Ze implementeren een MCP-client, waarmee hun AI-modellen verbinding kunnen maken met MCP-servers om context op te halen en taken in andere apps te voltooien.

Een AI-coderingstool zoals Cursor kan bijvoorbeeld een MCP-client hebben die verbinding maakt met de MCP-server die wordt aangeboden door Figma en GitHub. Communicatie tussen clients en servers vindt plaats via een standaardprotocol, net zoals HTTP een communicatiestandaard voor het internet definieert. MCP specificeert welke soorten berichten kunnen worden verzonden, hoe ze worden ingedeeld, hoe authenticatie werkt, en meer.

Het probleem: Waarom we MCP nodig hebben

Vluchten boeken voor een aankomende vakantie, analysedata opvragen voor een wekelijkse verkooprapportage, een prototype bouwen van een nieuwe functie - dit soort taken vereisen context die verder gaat dan de trainingsdata van een LLM en zich uitstrekt tot een breed ecosysteem van apps en services. Hoe meer context een AI-assistent heeft, hoe beter hij in staat is om de specifieke nuances van een verzoek te begrijpen en een output van hoge kwaliteit te leveren.

Overweeg het scenario waarin een AI-coderingstool wordt gebruikt om code te genereren vanuit een ontwerpbestand. Als een LLM een screenshot van het bestand bekijkt en zijn trainingsdata gebruikt om de pixels te interpreteren, kan het misschien een ruw prototype maken. Maar om tot een echt nuttig eindproduct te komen, is er meer context nodig, zoals de specifieke variabelen, componenten en stijlen, of zelfs pseudocode die de functionaliteit beschrijft. Dit soort context is van onschatbare waarde voor AI, maar meestal bevindt deze zich diep in andere tools (zoals Figma).

Vóór MCP moest elke ontwikkelaar die aan AI-agentische tools werkte, aangepaste integraties bouwen met externe apps en diensten, wat resulteerde in tragere ontwikkeling en een gefragmenteerd ecosysteem. Aangezien elke app gegevens en functies op een iets andere manier openbaart, zou elke nieuwe integratie een aanzienlijke hoeveelheid voorwerk vereisen.

MCP is een 'één keer schrijven, overal gebruiken'-benadering van het probleem. Een appontwikkelaar kan een enkele MCP-server schrijven voor elk AI-agentisch systeem, waarbij een canonieke reeks tools en gegevens wordt geboden, samen met nuttige functionaliteit zoals foutafhandeling. Evenzo kan een AI-systeem het protocol implementeren en verbinding maken met elke MCP-server die vandaag de dag bestaat of in de toekomst zal bestaan.

De oorsprong van MCP

MCP begon bij Anthropic in de zomer van 2024 om Claude Desktop een gemakkelijkere manier te bieden om met gegevensbronnen zoals het lokale bestandssysteem te werken. De auteurs haalden hun inspiratie uit Language Server Protocol (LSP) van Microsoft, de standaard voor hoe geïntegreerde ontwikkelomgevingen (IDE's) functies zoals contextmarkering of codevoltooiing ondersteunen voor veel verschillende programmeertalen.

Nadat het protocol was ontwikkeld en intern gebruikt, heeft Anthropic MCP in november 2024 als opensource vrijgegeven waarbij de volledige protocolspecificatie samen met documentatie en SDK's (bijv., Python) openbaar werd vrijgegeven.

Sindsdien is de adoptie aanzienlijk toegenomen. In januari en februari 2025 begonnen veel AI IDE's, zoals Cursor en Windsurf, MCP te ondersteunen. In maart voegde OpenAI MCP-ondersteuning toe, en GitHub bracht kort daarna zijn MCP-server uit. Ook volwassen producten nemen MCP over: Microsoft Windows kondigde aan dat het in de komende maanden het protocol zal ondersteunen.

Hoe werkt MCP?

MCP is in wezen een heen-en-weer van verzoeken en antwoorden: het LLM vraagt om gegevens of triggert een actie, en de externe app antwoordt. In netwerktermen volgt MCP een client-server architectuur waarbij de ene kant (de client) een verzoek verzendt en de andere kant (de server) gegevens retourneert of een actie uitvoert.

De MCP-specificatie definieert drie soorten functies die servers aan cliënten aanbieden:

• Hulpbronnen: Gegevens en inhoud die de app aan LLM's biedt, zoals databasegegevens, bestanden, screenshots of codeblokken.
• Tools: Functies die acties uitvoeren in de app; bijvoorbeeld, een PostgreSQL-MCP-server kan een tool beschikbaar stellen om een SQL-query uit te voeren binnen een database.
• Prompten: Vooraf gedefinieerde tekstsjablonen en workflows die AI-systemen kunnen gebruiken, ontworpen om goed samen te werken met de hulpbronnen en tools van de app.

MCP definieert hoe servers op een standaardmanier hulpbronnen, hulpmiddelen en prompts aan clients moeten blootstellen, inclusief:

• Antwoordindeling: Gegevens kunnen als JSON-blobs, SQL-rijen of zelfs ruwe afbeeldingen worden verzonden—de MCP-server zet alles wat hij ontvangt om in een standaardformaat dat MCP-clients verwachten (JSON-RPC 2.0).
• Opdrachtverwerking: De MCP-server fungeert als een vertaler en zet verzoeken van LLM's om in opdrachten waarmee apps kunnen werken, zoals API-aanroepen.
• Foutafhandeling: MCP definieert standaard foutcodes en stuurt fouten terug naar de LLM zodat deze het opnieuw kan proberen of de gebruiker om hulp kan vragen.
• Toolontdekking: MCP-servers bieden een functie die de beschikbare tools op die server opsomt, zodat een AI-systeem snel kan zien welke acties het in een externe app kan uitvoeren.

De architectuur: MCP-hosts, clients en servers

MCP vertrouwt op een architectuurpatroon dat gebruikelijk is in netwerken, met hosts, clients en servers. Het protocol definieert specifieke verantwoordelijkheden voor elke rol.

• MCP-hosts: Hosts beheren de ontdekking, toestemmingen en communicatie tussen clients en servers. Doorgaans is de host het product of platform—zoals Windows OS of Claude Desktop—waar gebruikers toegang hebben tot AI-agents om taken uit te voeren. Wanneer het model toegang nodig heeft tot een externe app, wordt de host gestart en de MCP-server van die app met de bijhorende client verbonden.
• MCP-clients: Clients starten en onderhouden een verbinding met MCP-servers, met één client per server. Clients wisselen verzoeken en antwoorden uit tussen LLM's en MCP-servers.
• MCP-servers: Servers worden direct aangesloten op externe systemen (zoals Figma, Google Drive of Postgres), waardoor LLM's toegang krijgen tot data en functionaliteit. MCP-servers ontvangen verzoeken van MCP-clients en vertalen deze naar opdrachten voor externe apps, zoals API-aanroepen of databasequery's. Zij ontvangen en verwerken ook de app-antwoorden in een standaardformaat. Aangezien app-ontwikkelaars MCP-servers implementeren, kunnen ze bepalen waartoe LLMs toegang hebben, en het protocol biedt richtlijnen met betrekking tot beveiliging en toestemmingen.

Om te zien hoe de onderdelen samenkomen, nemen we een voorbeeldworkflow door met behulp van de MCP-server van Figma:

• Een gebruiker opent Cursor, een AI-coderingstool met MCP ingeschakeld, in de codebibliotheek.
• De gebruiker vraagt de LLM in Cursor om het meest recente Figma-bestand op te halen en te implementeren in de codebase.
• Cursor start zowel de MCP-server van Figma als een bijbehorende MCP-client.
• Het LLM ontvangt de lijst met beschikbare prompts, hulpbronnen en tools van de server (via de client).
• De LLM stuurt vervolgens een bericht naar de server met het hulpmiddel dat het LLM wil aanroepen, samen met eventuele parameters (bijv. de bestands-ID van Figma). De server zet dit om in een API-verzoek en verzendt het verzoek via de API van Figma.
• De server wacht op de bestandgegevens van de API-respons van Figma, formatteert deze in een tekenreeks en stuurt deze terug naar het LLM (via de client).
• Met alle extra context van Figma kan het LLM vervolgens beginnen met het genereren van de relevante code binnen Cursor.

Voordelen van MCP: Waarom het van belang is voor AI-integratie

Ontwikkelaars nemen MCP over omdat dit het verbinden van LLM's met apps vereenvoudigt. Vergeleken met aangepaste integraties heeft MCP verschillende voordelen.

Ten eerste hoeven ontwikkelaars van AI-agentische systemen MCP slechts één keer te integreren en vervolgens kunnen ze elke MCP-server gebruiken. Externe-applicatieontwikkelaars hoeven slechts één MCP-server te maken, waarna elke voor MCP geschikte AI-tool hiermee verbinding kan maken.

Ten tweede, omdat elke MCP-server en MCP-client dezelfde kerninterface moeten bieden, is het wisselen van servers en clients eenvoudig. Dat betekent dat ontwikkelaars en gebruikers eenvoudig kunnen schakelen tussen apps zoals Dropbox en Google Docs, of Slack en Microsoft Teams.

Ten slotte, naarmate AI-producten contextbewuster worden door MCP, worden AI-tools overal beter voor gebruikers. En een standaardprotocol voor het ecosysteem betekent dat ontwikkelaars minder tijd kwijt zijn aan het schrijven van standaard integratiecode en meer tijd hebben om nieuwe functies te ontwikkelen.

MCP versus traditionele API's: Wat is het verschil?

Waarom geen API gebruiken in plaats van MCP? Het is een veelgestelde vraag, aangezien API's toegang bieden tot veel van dezelfde gegevens en acties in apps. In feite gebruiken veel MCP-servers achter de schermen API's om data en acties beschikbaar te maken.

Het korte antwoord is dat MCP AI-assistenten toestaat om één set commando's voor alle API's te gebruiken, wat de integratie enorm vereenvoudigt. Terwijl het direct werken met API's het schrijven van aangepaste code voor verzoeken, antwoorden en herhalingen vereist, kan een ontwikkelaar met MCP dezelfde resultaten bereiken door simpelweg de MCP-server te importeren. Schakelen tussen MCP-servers is eenvoudig, terwijl het wisselen van API's het schrijven van een geheel nieuwe codeset vereist.

MCP is ook beter geoptimaliseerd voor LLM-gebruik. MCP garandeert dat alles wat een LLM nodig heeft om toegang te krijgen tot een systeem goed gedefinieerd en gedocumenteerd is, op een gestructureerde manier. Ad-hoc API-definities kunnen belangrijke beschrijvingen missen of gegevens op een manier beschikbaar stellen die AI's niet kunnen begrijpen of gemakkelijk verkeerd kunnen interpreteren.

Hoe MCP en AI-agents hand in hand gaan

Een AI-agent is elke AI die voor jou in de echte wereld actie onderneemt. MCP maakt het veel gemakkelijker om AI-agents te bouwen. In plaats van API's één voor één te integreren, kan een ontwikkelaar het protocol implementeren om de AI-tool actie te laten ondernemen in elke MCP-compatibele applicatie.

Naarmate het MCP-ecosysteem groeit, worden agents ook krachtiger. AI-agents moeten in staat zijn om te plannen en actie te ondernemen met behulp van meerdere tools in de werkruimte van een gebruiker - hoe meer tools een agent kan gebruiken, hoe nuttiger hij voor gebruikers wordt. Met MCP kunnen agents eenvoudig een groeiend aantal tools vinden en gebruiken voor taakautomatisering.

MCP vs. A2A: Hoe de protocollen elkaar aanvullen

MCP is niet het enige nieuwe LLM-protocol dat er is—onlangs heeft Google het Agent2Agent (A2A) protocol aangekondigd. Maar ontwikkelaars hoeven niet tussen beide te kiezen. Deze protocollen lossen verschillende problemen op en vullen elkaar feitelijk aan.

MCP richt zich op het mogelijk maken voor AI-systemen om meer over de wereld te leren en erin te handelen. A2A richt zich op het helpen van AI-systemen bij het communiceren met elkaar over hun werk en intenties—om samen te werken, werk toe te wijzen, te discussiëren, te delegeren of te onderhandelen.

Twee agents kunnen A2A gebruiken om te beslissen welke van hen wat werk gaat doen en welke van hen het werk gaat superviseren. Dan kunnen ze MCP gebruiken om elkaar instructies te geven over het uit te voeren werk en de gegevens die gebruikt moeten worden.

De toekomst van MCP en AI-integratie

Het MCP-team werkt het protocol voortdurend bij, waarbij nieuwe releases meerdere keren per maand worden vrijgegeven. MCP is ook een open standaard, zodat de bredere AI-gemeenschap kan bijdragen aan het stappenplan. We kunnen verwachten dat er in de komende releases meer aandacht zal zijn voor beveiliging: authenticatie, autorisatie en datafiltering of privacymechanismen voor specifieke domeinen (zoals gezondheidszorg of financiën).

Als MCP breed wordt geaccepteerd, kunnen hele delen van de AI-industrie beginnen met het optimaliseren van hun gebruik van MCP. Modelontwikkelaars kunnen beginnen met het opnemen van MCP-toolgebruik in hun trainingsdata, en LLM-orkestratieframeworks (bijv. LangChain) kunnen MCP als een eersteklas burger in hun use cases ondersteunen.

Na verloop van tijd zou MCP de de facto standaard kunnen worden voor het verbinden van AI met het volledige digitale landschap van tools en diensten. Het integreren van gegevens en acties uit externe systemen in LLM-ervaringen zal steeds meer plug-and-play worden in het AI-ecosysteem. Voor ontwikkelaars betekent dat minder op maat gemaakte wrappers, betere AI-tools en meer tijd om de functies te bouwen die gebruikers echt waarderen. Voor bedrijven die data-rijke apps verzenden, betekent dit directe compatibiliteit met elk MCP-compatibel AI-platform. En voor eindgebruikers ontgrendelt het betere AI-toepassingen en persoonlijke assistenten die eindelijk de juiste context kunnen ophalen, de juiste knoppen kunnen indrukken en echt werk kunnen doen zonder omslachtige tussenkomst.