Zo koppel je een MCP-server aan ChatGPT, Claude en Cursor

Een MCP-server koppelen klinkt als één handeling, maar elk platform doet het compleet anders. In ChatGPT bouw je een agent en hangt er apps aan, in Claude zijn het connectors, in Claude Code tik je een terminalcommando, en in Cursor bewerk je een JSON-bestand. Wie dat niet weet, probeert in het ene programma iets wat alleen in het andere werkt, en concludeert dan ten onrechte dat MCP niet werkt. In mijn werk als AI-consultant zie ik dat patroon bijna wekelijks: de techniek klopt, alleen de koppeling staat op de verkeerde plek. Deze gids loopt elk platform langs, met de exacte stappen en de valkuilen.

MCP is de standaard die je AI-agent verbindt met de tools en data waar 'ie iets mee moet. Eén keer een koppeling bouwen en 'ie werkt in elke app die MCP spreekt. Daarom wordt het vaak de USB-C voor AI-tools genoemd. Maar net als bij een echte stekker geldt: het stopcontact zit op elk apparaat ergens anders. Hieronder zie je eerst het overzicht, daarna per platform de stappen.

Wat is een MCP-server eigenlijk?

Een MCP-server is een brugje dat je AI-agent toegang geeft tot één tool of databron, op een manier die elke AI-app begrijpt. De server biedt drie dingen aan: tools (functies die de AI kan aanroepen, zoals een bestand lezen of een issue aanmaken), resources (data die de AI mag inlezen) en prompts (kant-en-klare opdrachten). De berichten gaan over een vast formaat, JSON-RPC 2.0, zodat dezelfde server werkt of je nu Claude, ChatGPT of Cursor gebruikt.

Het verschil met een gewone plug-in of API-koppeling zit in die uniformiteit. Een API bouw je per integratie en per platform opnieuw. Een MCP-server bouw je één keer, en elke MCP-client kan 'm gebruiken. Volgens de officiële MCP-specificatie (versie 2025-06-18) is dat precies het doel: de wildgroei aan losse koppelingen vervangen door één standaard. Voor jou als gebruiker betekent het dat de kennis die je hier opdoet, overdraagbaar is naar elk platform dat je morgen gebruikt.

Heb je een lokale of een remote server nodig?

Elke MCP-server praat op één van twee manieren met je AI-app: als lokaal programma op je eigen computer, of als dienst op internet. Dat onderscheid bepaalt waar je 'm kunt koppelen, dus check het eerst.

• Lokaal (stdio). De app start de server als programmaatje op je eigen machine. Snel, geen netwerk, en je data blijft op je laptop. Ideaal voor je bestanden, een lokale database of je git-repo. Werkt in Claude Desktop, Claude Code en Cursor, maar niet in ChatGPT.
• Remote (Streamable HTTP). De server draait ergens in de cloud op een vast adres, meestal eindigend op /mcp. Dit is de route voor diensten van leveranciers zoals GitHub, Notion of Sentry, en vereist bijna altijd een inlog via OAuth. Werkt in alle platforms.

Kom je een oudere server tegen die om SSE vraagt? Dat transport is sinds 2025 vervangen door Streamable HTTP en geldt nu als verouderd. Het werkt vaak nog, maar bouw er niets nieuws op. Voor de keuze in de praktijk: lokale tools die je eigen systeem raken doe je via stdio, alles wat bij een externe dienst hoort via http.

Hoe koppel je een MCP-server in ChatGPT?

In ChatGPT koppel je MCP via de Agents: je maakt een agent, beschrijft wat 'ie moet doen, en voegt daarna in de bouwer apps, eigen MCP-servers en skills toe. Dat is precies de route die de meeste mensen zoeken en over het hoofd zien, omdat 'ie niet "MCP" heet. Je klikt links in de zijbalk op Agents (of typt /agent), beschrijft de taak en wat een goed resultaat is, en ChatGPT zet dat om in een werkende agent met stappen en instructies.

Na die eerste opzet zitten de koppelingen gewoon ingebouwd. In de Tools-sectie kies je + Add tool om apps te koppelen, zoals Google Agenda, Drive, Slack of SharePoint, en daar voeg je ook je eigen custom MCP-servers toe. Met Add skill hang je er skills aan: herbruikbare werkwijzes met instructies, voorbeelden en code die je agent een taak consistent laten uitvoeren. Je maakt ze zelf of gebruikt bestaande, en omdat ze op een open skills-standaard draaien, kun je ze ook in andere AI-tools hergebruiken.

Deze agent-bouwer hoort bij de Agents in ChatGPT; de zakelijke variant heet Workspace Agents en draait op Business- en Enterprise-accounts. Die zijn gratis tot 6 mei 2026, daarna geldt een verbruiksprijs. Beschikbaarheid en prijs verschillen per plan en per regio, dus kijk wat er in jouw account staat.

Wil je een MCP-server koppelen buiten de agent-bouwer om, bijvoorbeeld een server die je zelf host, dan kan dat via developer mode (Instellingen, Apps, Advanced settings), nog gemarkeerd als beta. Eén ding geldt overal in ChatGPT: het praat alleen met remote servers over HTTPS, dus een lokale server zet je eerst met een tunnel online.

Hoe koppel je een connector in Claude?

Claude.ai noemt MCP-integraties connectors, en een eigen server voeg je toe via Instellingen, Connectors, Add custom connector. Je plakt daar de remote-URL van je server (met het /mcp-pad), klikt op Add, en zet de connector per gesprek aan via de plusknop linksonder. Onder Advanced settings vul je eventueel een OAuth Client ID en Secret in.

Eén ding dat veel mensen verrast: bij een custom connector verbindt Claude vanuit de cloud van Anthropic, niet vanaf je laptop. Je server moet dus publiek bereikbaar zijn. Custom connectors werken op alle plannen van Free tot Enterprise, maar op Free zit je vast aan maximaal één, en bij Team en Enterprise voegt alleen een Owner ze toe.

Voor een server die juist lokaal moet draaien, gebruik je Claude Desktop met Extensions. Dat is de moderne, één-klik-manier zonder JSON-gedoe: ga naar Instellingen, Extensions, Browse extensions, en installeer een gereviewde extension. Een eigen extension sleep je als .mcpb-bestand in datzelfde scherm. Dat bestandsformaat heette tot voor kort .dxt en is hernoemd naar .mcpb, maar oude bestanden blijven werken. Handig: Anthropic levert Node.js mee met Claude Desktop, dus je hoeft daar zelf niets voor te installeren. De oude handmatige route via claude_desktop_config.json bestaat nog, maar geldt nu als de geavanceerde variant.

Hoe koppel je MCP in Claude Code?

In Claude Code koppel je een server met één terminalcommando: claude mcp add. Dit is de krachtigste route en meteen de meest verwarrende voor wie van de grafische apps komt, want hier tik je alles in plaats van te klikken. We schreven eerder over hoe je Claude Code met slash commands aanstuurt, en MCP-servers passen in datzelfde patroon. De volledige set commando's staat in de officiële Claude Code-documentatie.

Voor een remote dienst gebruik je het http-transport:

# Notion koppelen (remote, http)
claude mcp add --transport http notion https://mcp.notion.com/mcp

# Met een eigen token erbij
claude mcp add --transport http github https://api.githubcopilot.com/mcp/ \
  --header "Authorization: Bearer JOUW_GITHUB_TOKEN"

Voor een lokale server gebruik je stdio. De dubbele streep scheidt de servernaam van het commando dat de server start:

# Filesystem koppelen (lokaal, alleen de map die je opgeeft)
claude mcp add --transport stdio filesystem \
  -- npx -y @modelcontextprotocol/server-filesystem /pad/naar/map

Let op de volgorde: alle opties (--transport, --env, --scope, --header) zetten je vóór de servernaam, anders worden ze genegeerd. Een tweede ding dat je moet weten zijn de scopes, want die bepalen wie de koppeling ziet:

Zet je een server op project-scope, dan komt 'ie in een .mcp.json-bestand dat je met je team kunt committen. Secrets hardcode je daar nooit in; je leest ze uit je omgeving met ${API_KEY}. Vraagt een remote server om een login, dan tik je in de sessie /mcp en doorloop je de browser-login; Claude Code bewaart het token veilig in je keychain, niet in een bestand. Met claude mcp list zie je alle gekoppelde servers en hun status. Ben je ingelogd met hetzelfde account als op claude.ai, dan verschijnen je connectors van daar trouwens automatisch ook in Claude Code. Dit is precies de laag die het verschil maakt tussen los prompten en echt werk uit handen geven, iets wat we ook lieten zien in onze uitleg over meerdere Claude Code-sessies tegelijk beheren en in onze verzameling Claude-skills.

En in Cursor en andere editors?

Cursor, Windsurf en VS Code koppelen MCP via een JSON-bestand met een mcpServers-object. In Cursor bewerk je daarvoor ~/.cursor/mcp.json (globaal) of een .cursor/mcp.json in je project, of je klikt simpelweg op een Add to Cursor-knop op de documentatie van een server. Via Cursor Settings, Tools en MCP voeg je er ook één toe met de knop New MCP Server.

{
  "mcpServers": {
    "filesystem": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-filesystem", "/pad"],
      "env": { "API_KEY": "value" }
    }
  }
}

Datzelfde blok werkt grotendeels één-op-één in Windsurf. VS Code is de uitzondering: daar heet de bovenste sleutel servers in plaats van mcpServers, en staat de config in .vscode/mcp.json. Wissel je tussen editors, dan hoef je je servers dus niet opnieuw uit te zoeken, alleen het bestand op de juiste plek te zetten.

Welke MCP-servers kun je vertrouwen?

Gebruik MCP-servers van de leverancier zelf of uit de officiële registry, en behandel een onbekende server als code die je niet kent. Want dat is het ook: een MCP-server is geen onschuldige plug-in, maar uitvoerbare code of een netwerk-endpoint met toegang tot je tools en sleutels. Een onbekende server installeren is dus dichter bij het draaien van een onbekend programma dan bij het aanzetten van een browser-extensie.

Goed nieuws: de betrouwbare bronnen zijn makkelijk te vinden. De officiële reference-servers zijn teruggebracht tot een kleine, gecontroleerde set van zeven (waaronder Filesystem, Git, Fetch en Memory). Veel bekende namen zoals GitHub, Slack en Sentry zijn uit die lijst gehaald en draaien nu als first-party server van de leverancier zelf, wat juist veiliger is. Daarnaast is er de officiële MCP-registry voor het ontdekken van servers, en voor Claude een gereviewde directory. Vuistregel: een vendor-server (GitHub voor GitHub, Notion voor Notion) is bijna altijd de juiste keuze boven een naamloze kopie.

Hoe houd je een MCP-koppeling veilig?

De twee grootste risico's bij MCP zijn prompt injection via tool-output en servers die te veel rechten krijgen. Een kwaadaardige instructie kan verstopt zitten in data die een tool teruggeeft, bijvoorbeeld de tekst van een webpagina of een issue, en je agent zo kapen. Behandel daarom elke uitvoer van een tool als niet per se te vertrouwen, en houd de bevestigingsvensters voor schrijfacties aan. De MCP-spec schrijft niet voor niets voor dat er altijd een mens moet zijn die een tool-aanroep kan weigeren.

Verder gelden een paar gewoontes die je veel ellende besparen. Geef elke server zo min mogelijk rechten: een filesystem-server alleen de map die nodig is, een database-server een read-only login. Hardcode nooit een API-sleutel in je config, maar lees 'm uit je omgeving. En denk aan de Nederlandse context: koppel je een server aan je CRM, je mailbox of je klantenadministratie, dan stromen er persoonsgegevens doorheen en geldt gewoon de AVG. Zet je zo'n agent in bij werving of kredietbeoordeling, dan kom je bovendien in de hoog-risico-categorie van de AI Act, met extra verplichtingen voor uitlegbaarheid en controle. Voor een mkb-er is de praktische les simpel: begin met een read-only koppeling op niet-gevoelige data en breid pas uit als de governance staat.

Welke koppeling maak je als eerste?

Begin met één read-only server die meteen iets oplevert, niet met de meest indrukwekkende. Een filesystem-server die alleen je projectmap mag lezen, of een GitHub-koppeling die je issues kan opzoeken, geeft je in vijf minuten een gevoel voor wat MCP doet, zonder dat er iets stuk kan. Pas als dat went, koppel je de tools die echt schrijven of betalen, met de bevestigingen aan. De meeste mensen die denken dat MCP ingewikkeld is, hebben gewoon de eerste, simpele koppeling overgeslagen. Wil je eerst een gevoel krijgen voor agents zelf, begin dan met onze tutorial waarin je in een middag je eerste AI-agent bouwt, en pak deze gids erbij zodra je 'm aan je eigen tools wilt hangen. Nieuwe ontwikkelingen rond Claude, agents en tooling houden we elke werkdag bij in onze gratis AI-nieuwsbrief.