MCP: je AI koppelen aan de rest van je wereld

Koppel je AI aan de programma's en bronnen waar je echt mee werkt, en hij kan er niet alleen over práten maar er ook iets ín doen. Dit is les vier van Read: een korte, praktische les over verbinden, met twee proeven: een minispelletje bouwen in Godot zonder enige Godot-kennis, en documentatie aansluiten die altijd klopt.

Zeg wat je ervan vindt. Dit is les vier van de reeks, en ik hoor graag of je er iets aan hebt gehad. Goed of niet goed, allebei even welkom, en je hoeft niet te wachten tot het einde. Twee zinnen zijn genoeg: geef feedback. Anoniem mag; laat je je e-mailadres achter, dan kunnen we er eventueel over sparren. Je feedback wordt nergens publiek getoond.

Wat je hierna kunt

• Uitleggen wat een MCP-server is, in gewone taal, en herkennen wanneer je er een nodig hebt.
• Een applicatie laten aansturen: Claude bouwt een minispelletje in Godot, start het en leest zijn eigen foutmeldingen. Jij drukt op de afspeelknop.
• Actuele documentatie aansluiten, zodat antwoorden uit de bron van vandaag komen in plaats van uit verouderde trainingskennis.
• Servers kiezen en veilig gebruiken: wat je aankoppelt, wat je laat, en hoe je opruimt.

En misschien wel het belangrijkste: je herkent hierna het moment waarop je iets uit een programma naar je AI kopieert (of andersom) en denkt: dit hoort een koppeling te zijn.

Waarom niet gewoon kopiëren en plakken? Dat kan, en voor een eenmalig stukje tekst is het prima. Maar het blijft handwerk, de informatie is verouderd op het moment dat je hem plakt, en het werkt maar één kant op: je kunt een handleiding de chat in kopiëren, maar geen game-engine. Een MCP-server is de vaste stekker: de AI haalt zelf op wat hij nodig heeft, en kan aan de andere kant ook iets terugdóén.

Wat je nodig hebt

• Een Claude-account. Het Godot-voorbeeld heeft Claude Code nodig; het documentatievoorbeeld werkt in Claude Code én in de Claude-apps.
• Voor het Godot-voorbeeld: twee gratis programma's, Godot en Node.js. Het installeren staat stap voor stap in de les, voor Windows en Mac.
• Geen programmeer- of gamekennis. De AI schrijft alle code; jij stuurt aan in gewone taal. Dat is precies het punt van deze les.
• Een uur. Lezen alleen kan in een kwartier, maar de opzet is dat je meteen meedoet, en aan het einde draait er iets op je scherm.

De denkwijze

Het probleem is niet dat je AI het niet kan. Het probleem is dat hij nergens bij kan.

Herken je dit? Je vraagt iets over een programma dat je dagelijks gebruikt, en het antwoord slaat de plank net mis: menu's die inmiddels verplaatst zijn, opties die niet meer bestaan, een versienummer van vorig jaar. Of je wilt dat de AI iets vóór je doet in zo'n programma, en je krijgt een lijstje van twintig stappen terug dat jij vervolgens zelf mag uitvoeren, overtypend uit de chat.

De oplossing: geef je AI een stekker naar dat programma of die bron: een MCP-server. MCP staat voor Model Context Protocol, een open standaard voor de koppeling tussen AI en de rest van je software. Eén afspraak over de stekker, en alles past op alles: daarom bestaat er voor honderden programma's en diensten al zo'n koppelstuk, van game-engines tot boekhoudpakketten.

Wat een MCP-server precies is

Een MCP-server is een klein koppelprogramma dat tussen je AI en een applicatie of dienst in zit. Het biedt de AI een lijstje gereedschappen aan: "ik kan een scène maken in Godot", "ik kan het spel starten", "ik kan de documentatie van tool X opzoeken". Je AI leest dat lijstje en beslist per vraag welk gereedschap helpt, hetzelfde principe als de triggers van je skills uit les 01.

In de Claude-apps heten deze koppelingen connectors: zelfde techniek, maar kant-en-klaar aan te zetten in een keuzemenu, zonder installatie. In Claude Code sluit je servers zelf aan, en daardoor kun je er ook eentje kiezen die niet in het menu staat. Deze les doet allebei.

Skill, subagent, geheugen of MCP?

De vier lessen tot nu toe vullen elkaar aan:

Vuistregel: kan je AI iets niet omdat hij het niet wéét hoe jij het wilt, dan is het een skill. Kan hij er niet bíj, dan is het een MCP-server.

Wanneer je géén server aansluit

• Staat het al in je bestanden? Claude Code kan je bestanden gewoon lezen. Een koppeling is voor wat dáárbuiten ligt.
• Eenmalig stukje informatie? Plakken is prima. Een koppeling loont bij wat terugkomt.
• Koppel wat je gebruikt, in plaats van alles wat er bestaat. Elke aangesloten server geeft de AI meer om uit te kiezen; een handvol goedgekozen koppelingen werkt beter dan twintig. Meer hierover bij de valkuilen.

Voorbeeld 1: een minispelletje in Godot, zonder Godot-kennis

Nergens zie je "aansturen" zo duidelijk als bij een game-engine: binnen een half uur beweegt er iets op je scherm dat jij alleen in gewone taal hebt beschreven. En het recept is overal hetzelfde. Wat we hier met Godot doen, werkt net zo met een 3D-programma als Blender of een clouddienst als Cloudflare: server aansluiten, opdracht geven, resultaat bekijken, bijsturen.

Eerst even eerlijk over de verwachting: het wordt geen console-titel. Het wordt een balletje dat muntjes verzamelt. Maar het is een écht spel, in een écht spelprogramma, en jij hebt er geen regel code voor geschreven.

Stap 1: installeer Godot en Node.js

Twee gratis programma's, allebei eenmalig te installeren. Godot is de game-engine; Node.js is het hulpprogramma waarmee de MCP-server straks draait.

Op Windows

Godot: ga naar godotengine.org, klik op Download en kies Windows. Kies de gewone versie (dus zonder ".NET" in de naam). Je krijgt een zip-bestand; pak het uit en zet de map op een vaste plek, bijvoorbeeld C:\Godot. Het programma erin (Godot_v4... .exe) is meteen te starten, een installatie is er niet.

Node.js: ga naar nodejs.org en klik op de groene knop met de LTS-versie. Doorloop het installatieprogramma met de standaardkeuzes. Controleren kan in PowerShell: typ node --version en druk op Enter; zie je een versienummer, dan staat het goed.

Op een Mac

Godot: ga naar godotengine.org, klik op Download en kies macOS. Open het gedownloade bestand en sleep Godot naar je map Programma's. Start je Godot de eerste keer, klik dan met rechts (of met Control ingedrukt) op het programma en kies Open; dat is eenmalig nodig omdat het buiten de App Store om komt.

Node.js: ga naar nodejs.org en klik op de groene knop met de LTS-versie. Doorloop het installatieprogramma. Controleren kan in Terminal: typ node --version en druk op Enter; zie je een versienummer, dan staat het goed.

Stap 2: sluit de Godot-server aan op Claude Code

We gebruiken een gratis, open source MCP-server voor Godot. Maak eerst een nieuwe, lege map voor je spel (bijvoorbeeld mijn-eerste-spel) en open je terminal in die map. Het aansluiten is één commando, en dat typ je in de terminal zelf, dus vóórdat je Claude Code start.

Op een Mac:

claude mcp add godot -- npx -y @coding-solo/godot-mcp

Op Windows hoort er cmd /c tussen (een technische eigenaardigheid van Windows, verder verandert er niets):

claude mcp add godot -- cmd /c npx -y @coding-solo/godot-mcp

Start daarna Claude Code in dezelfde map en typ /mcp. Staat de server erbij en is hij verbonden, dan ben je klaar voor de opdracht. De server zoekt zelf naar Godot op je computer; vindt hij hem niet, vertel Claude dan in het gesprek waar Godot staat (bijvoorbeeld C:\Godot of de map Programma's), dan komt het alsnog goed.

Stap 3: geef de opdracht

Nu het leukste deel. Beschrijf het spel zoals je het tegen een collega zou zeggen:

"Maak in deze map een compleet Godot 4-project: een minispel op één scherm waarin ik met de pijltjestoetsen een blauw balletje bestuur en vijf gele muntjes verzamel. Laat een teller meelopen en toon 'Gehaald!' zodra alle muntjes binnen zijn. Start het spel daarna via de Godot-koppeling, zodat ik meteen kan testen."

Je ziet Claude aan het werk gaan: hij maakt het project, schrijft de code, zet de scène in elkaar en start het spel via de koppeling. Er verschijnt een spelvenster. Pijltjestoetsen, muntjes pakken, teller loopt. Dat is alles: jouw beschrijving erin, een draaiend spel eruit.

Gaat er iets mis, dan is dat geen ramp maar een demonstratie: vraag "los de fout op" en kijk mee. Via de koppeling leest Claude de foutmeldingen van Godot zelf, dus je hoeft niets over te typen of te begrijpen.

Stap 4: druk zelf op de afspeelknop

Open nu Godot zelf. In het openingsscherm (de projectmanager) kies je Importeren, wijs je je spelmap aan en open je het project. Daar staat je spel: de scène, het balletje, de code. Rechtsboven zit de afspeelknop (▶); één klik en het spel start opnieuw, nu vanuit Godot zelf. Vanaf hier kun je het project altijd openen en spelen, ook zonder Claude erbij.

Stap 5: stuur bij alsof het een collega is

Het echte werk begint na de eerste versie, en gaat in gewone taal: "maak de muntjes groter", "het balletje beweegt te snel", "voeg een tweede level toe met meer muntjes", "laat een geluidje horen bij elk muntje". Elke aanpassing is dezelfde lus: vragen, laten bouwen, spelen, bijsturen. Precies zoals je met een mensencollega zou werken, alleen zijn de rondes een stuk korter.

Het verschil dat je mag verwachten:

Zonder koppeling: een keurige handleiding. "Open Godot, maak een nieuwe scène, voeg een CharacterBody2D toe, schrijf dit script…" Twintig stappen voor jou, in een programma dat je niet kent, met de fouten voor jouw rekening.

Met koppeling: de AI voert die twintig stappen zelf uit, start het spel en leest zijn eigen foutmeldingen. Jij beschrijft, speelt en stuurt bij.

Voorbeeld 2: documentatie die altijd klopt

Het tweede voorbeeld is minder spectaculair en waarschijnlijk waardevoller voor je dagelijkse werk. AI-kennis komt uit training, en training heeft een einddatum. Vraag iets over de nieuwste versie van een tool, en je krijgt het antwoord van maanden geleden, zelfverzekerd gebracht. De oplossing is dezelfde stekker: koppel de bron aan, in plaats van te hopen dat het hoofd van de AI actueel is.

We gebruiken Context7, een dienst die actuele documentatie van duizenden tools en programmabibliotheken doorzoekbaar maakt. Werk je met andere software, kijk dan ook even bij je eigen leverancier: steeds meer diensten (Cloudflare bijvoorbeeld) hebben een eigen documentatie-server klaarstaan, en het recept is identiek.

Aansluiten in Claude Code

Ook dit is één commando in de terminal, en het is op Windows en Mac hetzelfde omdat deze server op internet draait in plaats van op jouw computer:

claude mcp add --transport http context7 https://mcp.context7.com/mcp

Zonder account kun je een beperkt aantal vragen per dag stellen; genoeg om te proeven. Een gratis sleutel via context7.com geeft meer ruimte.

Aansluiten in de Claude-apps

In de Claude-apps heet dit een connector: ga naar Instellingen → Connectors, kies voor het toevoegen van een aangepaste connector en plak https://mcp.context7.com/mcp. Kijk in hetzelfde menu ook even rond: daar staan tientallen kant-en-klare connectors voor diensten die je misschien al gebruikt. Menu's verschuiven weleens; zoek anders op "connectors" in de instellingen.

De proef: mét en zónder

Kies een tool die je zelf gebruikt en die af en toe verandert, en stel twee keer dezelfde vraag: één keer gewoon, en één keer met de toevoeging "use context7" (dat zinnetje is het duwtje waarmee je de koppeling er zeker bij betrekt):

"Wat is de nieuwste versie van jouw tool, en wat is daarin veranderd? use context7"

Het verschil dat je mag verwachten:

Zonder koppeling: een antwoord uit trainingskennis: een versienummer van maanden terug, met als het meezit de eerlijke disclaimer dat de informatie verouderd kan zijn.

Met koppeling: de AI raadpleegt de documentatie van vandaag. Het antwoord noemt de huidige versie, en de stappen kloppen met de huidige handleiding in plaats van met die van vorig jaar.

Na een paar dagen merk je dat het duwtje steeds minder nodig is: bij vragen over tools pakt de AI de koppeling zelf. En jij stopt met het controleren van versienummers.

Zelf doen: kieswijzer en drie starters

Hetzelfde recept werkt voor elke koppeling. De kieswijzer, in vier vragen:

1. Welk programma of welke bron gebruik je vaak naast je AI-chat? Waar kopieer je nu handmatig tussen? Dat is je kandidaat.
2. Bestaat er een koppeling? Kijk eerst in het connectors-menu van de Claude-apps, en zoek anders op de naam van het programma plus "MCP server". Kies bij voorkeur de server van de maker zelf, of een open source server die je kunt inzien.
3. Lees wat de server mag. Alleen lezen (documentatie opzoeken) is iets anders dan schrijven en veranderen (bestanden aanpassen, instellingen wijzigen). Weet wat je aansluit; hierover meer bij de gouden regels.
4. Sluit aan en doe eerst een leesproef. Stel een vraag waarvan je het antwoord kunt controleren. Klopt het, dan pas verder.

Starter 1: de documentatie van jouw gereedschap

Wanneer: je stelt regelmatig vragen over tools of software, en betrapt je AI op verouderde antwoorden. Koppeling: Context7 uit voorbeeld 2, of de eigen documentatie-server van je leverancier. Winst: antwoorden uit de bron van vandaag, en de controle-reflex op versienummers kan uit.

Starter 2: de connector-catalogus in de Claude-apps

Wanneer: je werkt veel in de Claude-apps en gebruikt diensten als agenda's, notitie-apps of ontwerptools. Koppeling: open Instellingen → Connectors en loop het aanbod langs; aanzetten is een kwestie van klikken en inloggen bij de dienst. Winst: je AI kan bij de informatie waar je gesprekken toch al over gaan, zonder plakwerk.

Starter 3: één applicatie aansturen, in een oefenproject

Wanneer: je wilt voelen wat aansturen is, zonder risico. Koppeling: de Godot-server uit voorbeeld 1, of een vergelijkbare server voor een programma uit jouw wereld. Winst: je leert de lus (beschrijven, laten bouwen, bekijken, bijsturen) in een omgeving waar niets kapot kan. Daarna herken je precies waar diezelfde lus in je echte werk past.

Vier lessen, één geheel

Met deze les is het kwartet compleet. Skills leggen vast hóé je werkt (les 01), subagents voeren het uit (les 02), het projectgeheugen onthoudt wát er in dit project geldt (les 03), en MCP-servers bepalen wáár je AI bij kan (deze les). In het spelvoorbeeld komt alles samen: leg in een skill vast hoe jij spelcode gedocumenteerd wilt hebben, zet het projectgeheugen in voor de spelregels en beslissingen van jouw game, en laat het bouwen via de Godot-koppeling lopen. Elk deel doet zijn eigen werk.

Valkuilen en gouden regels

Vijf dingen die ik bij anderen zie misgaan, plus de twee regels die je nooit loslaat.

1. Alles aankoppelen wat je tegenkomt. Twintig servers voelt als twintig superkrachten, maar elke server voegt gereedschappen toe waar je AI per vraag uit moet kiezen, en de spoeling wordt dun. Koppel wat je deze periode echt gebruikt; de rest kan altijd nog.
2. Een koppeling behandelen als werkwijze. Een MCP-server geeft toegang, geen smaak: hij weet niet hóé jij het wilt. Combineer: de server levert het gereedschap, je skill (les 01) de werkwijze. De Godot-koppeling bouwt het spel; jouw skill bepaalt hoe de code eruitziet.
3. Verwachten dat de AI de koppeling vanzelf pakt. Meestal gaat dat goed, soms blijft de server onbenut liggen. Benoem hem dan gewoon in je vraag ("use context7", "start het spel via de Godot-koppeling"); na een paar keer weet je precies wanneer het duwtje nodig is.
4. Blind varen omdat "de bron is aangesloten". Een koppeling verkleint de kans op verouderde antwoorden, en houdt de noodzaak van controleren in stand: de server kan de verkeerde bron matchen of een stuk documentatie missen. Steekproef bij alles waar een beslissing op rust.
5. Installeren en nooit opruimen. Neem je koppelingen mee in hetzelfde onderhoudsmoment als je skills, rollen en geheugens (eerste maandag van de maand is populair): typ /mcp en loop de lijst langs. Een server die je niet meer gebruikt, gooi je weg; in de apps zet je de connector uit. Opruimen mag.

⚠️ Twee gouden regels. Eén: installeer alleen servers van makers die je vertrouwt, en lees wat ze mogen. Een MCP-server is een programma dat namens jou mag handelen, en wat je vraagt (soms met je gegevens erbij) gaat naar de dienst erachter. Kies de server van de maker zelf of een open source server die je kunt inzien, en weet of hij alleen leest of ook mag veranderen. Hetzelfde principe als bij skills en agents: lees wat je in huis haalt, ook als het van mij komt. Twee: oefen los van wat er echt toe doet. Begin met koppelingen die alleen lezen, en laat een server die dingen kan veranderen eerst werken in een oefenomgeving, zoals de lege spelmap uit voorbeeld 1. Pas als je precies weet wat er gebeurt, koppel je iets aan waar je werk in zit. Een AI met echte gereedschappen verdient dezelfde zorg als een nieuwe collega met echte toegangspassen.

Je volgende stap

Verbinden is de vierde stap naar herhaalbaar werken met AI, na vastleggen, verdelen en onthouden. Op het AI-groeipad hoort dit bij de sprong van fase 2 naar fase 3: de AI staat niet langer los van je gereedschap, maar zit ertussen, met afspraken over wat hij mag. Dat is het punt waarop AI-werk ophoudt met kopiëren en plakken.

Doe deze week één ding: sluit Context7 (of de documentatie-server van jouw leverancier) aan en doe de proef mét en zónder. Trek je er een avond voor uit, bouw dan ook het spelletje: er gaat weinig boven de eerste keer dat je eigen beschrijving beweegt op je scherm.

Daarna volgt in deze reeks: les 05 · Ontwerpen (UX-afspraken vastleggen en Claude Design gericht inzetten).

Benieuwd welke koppelingen in jouw werk het meest opleveren? Een uurtje praten of een korte quickscan van je processen maakt dat meestal snel helder. Plan een kennismaking: een half uur, eerlijke aanbeveling, ook als die "gewoon zelf beginnen" is.

Wat vond je ervan?

Je bent er doorheen. Vertel me wat werkte, wat je miste en wat onduidelijk bleef. Twee zinnen zijn genoeg, en elke reactie maakt les vijf beter: geef feedback. Anoniem mag; laat je je e-mailadres achter, dan kunnen we er eventueel over sparren. Je feedback wordt nergens publiek getoond.