MCP-server vs. Tools vs. Agentvaardigheid

AI-native ontwikkeling versnelt en steeds meer engineers integreren tools als Claude, Cursor en VS Code AI-extensies in hun workflow. Maar verwarring is gebruikelijk:

• Wat is precies een MCP-server?
• Hoe verschillen MCP-tools van de server?
• Wat bedoelen we met toolgebruik?
• Wat is een Claude Code-vaardigheid, en hoe past dat erin?
• Wanneer moet je welke gebruiken?
• Hoe werken deze lagen samen voor echte engineeringtaken?

Dit artikel geeft een duidelijke, praktische uitleg van de drie concepten, hun grenzen, en hoe ze de volgende generatie softwareontwikkeling vormen.

MCP: Drie componenten, één protocol#

MCP (Model Context Protocol), ontwikkeld door Anthropic, is een gestandaardiseerde manier voor AI-modellen om externe bronnen, API's, tools, databases of interne systemen te benaderen.

Er zijn drie kernelementen:

• MCP-server: Een backend-service die mogelijkheden beschikbaar maakt voor AI-clients
• MCP-tools: De specifieke, aanroepbare acties die door de server worden aangeboden
• MCP-providers: Integraties zoals Claude Desktop, Cursor, VS Code-extensies

En buiten MCP, maar vaak mee verward:

• Claude Code Skill: Claude’s ingebouwde programmeerintelligentie in IDE’s

Een goed begrip van deze lagen helpt je om betere AI-workflows te ontwerpen.

Wat zijn tools? (Algemeen AI-toolgebruik)#

Voor we het over MCP-tools of Claude Code-vaardigheden hebben, is het handig om te begrijpen wat "tools" in de AI-wereld betekenen.

In moderne LLM-systemen zijn tools:

Externe bewerkingen die een AI-model kan aanroepen om iets in de echte wereld te doen, verder dan alleen tekstgeneratie.

Ze geven het model handelingsvermogen. Een tool kan bijna alles zijn:

• een API-endpoint
• een databasequery
• een bestandssysteemactie
• een browserhandeling
• code uitvoeren
• een e-mail sturen
• een gebruiker aanmaken
• interactie met cloudresources
• een LLM-functie aanroepen

Als het model besluit een tool te gebruiken, stapt het buiten pure taal en voert het een actie uit met echte gevolgen.

Waarom tools bestaan#

Tools zijn er omdat modellen die alleen tekst genereren heel snel een limiet bereiken.

Een model kan dingen uitleggen, redeneren over een probleem, of code schrijven, maar het kan je systemen niet daadwerkelijk aanraken. Het weet niet hoe het je database moet bevragen, een bestand aanpassen, een API aanroepen, iets naar de cloud deployen, of een lange operatie met meerdere stappen uitvoeren.

Zodra je het model een set tools geeft, verdwijnen deze beperkingen. Het model krijgt een gecontroleerde manier om te interageren met echte infrastructuur, terwijl jij strikte grenzen stelt aan wat het kan doen en hoe. Tools zorgen voor structuur, veiligheid, en de uitvoeringslaag die tekstmodellen fundamenteel missen.

Het kernidee van toolgebruik#

Een tool is gedefinieerd door een contract:

Wanneer het model deze definitie ziet, kan het:

• begrijpen wat de tool doet
• bepalen wanneer het die moet gebruiken
• het inputobject samenstellen
• de tool aanroepen
• de output verwerken in volgende stappen

Tools maken van een LLM feitelijk een orkestrator.

Belangrijke grenzen#

Tools worden vaak verkeerd begrepen als machtiger dan ze zijn. Ze zijn geen vorm van intelligentie, ze bevatten geen bedrijfsregels, permissies of workflowlogica. Een tool is gewoon een kleine, goed gedefinieerde bewerking die het model kan aanroepen, niet meer dan dat. Het grotere gedrag, zoals meerstaps-workflows of besluitvorming, komt niet uit de tool zelf maar doordat het model meerdere tools met eigen logica aan elkaar rijgt.

Waarom tools belangrijk zijn in agent-ecosystemen#

Moderne agent-frameworks: OpenAI Functions, Claude Tools, MCP, LangChain zijn allemaal gebouwd op hetzelfde principe: een LLM wordt pas echt nuttig als het actie kan ondernemen. Alleen taal is niet genoeg; het model heeft een manier nodig om de echte wereld te bereiken.

Tools zijn de laag die dit mogelijk maken. Ze verbinden de redenering van het model met daadwerkelijke mogelijkheden van je systeem – en dat gebeurt in een gecontroleerde, geautoriseerde omgeving. Met deze brug is AI geen passieve tekstgenerator meer maar lijkt het meer op een operator die data ophaalt, bestanden aanpast, workflows coördineert of backend-processen aanzet.

Daarom is toolgebruik ongemerkt de ruggengraat geworden van bijna elke serieuze AI-toepassing, van IDE-assistenten en backendautomatisering tot DevOps-copiloten, IAM-automatisering, data-agents en bedrijfsworkflow-engines. MCP sluit hier naadloos op aan door een consistent protocol te bieden waarin deze tools beschikbaar zijn en standaardiseert hoe modellen echte systeemmogelijkheden ontdekken en gebruiken.

MCP-server: de backend-mogelijkhedenlaag voor AI#

Zie een MCP-server als een backendservice die zorgvuldig afgebakende mogelijkheden aan AI-assistenten aanbiedt. In plaats van een model onbeperkt toegang tot je systemen te geven, omhul je de delen die je wílt dat het gebruikt: interne API’s, authenticatielogica, databasebewerkingen, bedrijfsworkflows of permissiechecks.

In de praktijk kan een IAM-platform als Logto acties zichtbaar maken zoals:

• organisaties tonen of aanmaken
• org- of M2M-tokens genereren
• toegang van een gebruiker tot een API inspecteren
• applicatieconfiguratie uitlezen
• veilige backend-snippets genereren op basis van tenant-instellingen

De waarde van een MCP-server zit in de structuur rond deze mogelijkheden.

In plaats van overal losse integraties in verschillende clients, zit alles achter één goed gedefinieerde interface. Dat heeft praktische voordelen:

• meerdere AI-clients kunnen dezelfde backendlogica delen
• veiligheid en permissiegrenzen zijn op één plek geregeld
• je handhaaft een consistent contract voor elke agent
• bedrijfssystemen hebben strakkere controle over wat AI daadwerkelijk kan doen

Daarom passen MCP-servers uitstekend in omgevingen waar juistheid en toegangscontrole belangrijk zijn — identity-systemen, betalingen, CRM, DevOps en interne admin tools.

MCP-tools: atomaire acties die aan AI-modellen worden blootgesteld#

In het voorgaande spraken we over tools: tools zijn geen servers; tools zijn de afzonderlijke acties ín een server.

Voorbeelden van tools:

• create_organization
• invite_member
• list_applications
• generate_backend_snippet
• inspect_user_access

Tools zijn:

• klein
• stateless
• eenvoudig door LLM’s aan te roepen
• de bouwstenen van grotere workflows

Ze behouden geen context en bieden uit zichzelf geen beveiligingsbeleid. Het zijn simpelweg de “functies” die via MCP beschikbaar zijn.

Claude code skill: De intelligentielaag in de IDE#

Claude Code Skills zijn geen onderdeel van MCP.

Het zijn Claude’s ingebouwde mogelijkheden in omgevingen als:

• Cursor
• Claude Desktop
• VS Code / JetBrains editors

Voorbeelden van Code Skills:

• volledige repositories lezen
• edits over meerdere bestanden toepassen
• nieuwe modules genereren
• logs debuggen
• code refactoren
• taken uitvoeren over meerdere bestanden

Wat Claude Code niet kan: Claude Code skills kunnen géén organisatiepermissies beheren, huurderdata benaderen, beveiligde bedrijfsworkflows uitvoeren, direct toegang krijgen tot je interne infrastructuur, of beschermde productiebronnen aanpassen. Precies door deze beperkingen bestaat MCP.

Visualisatie van de samenhang#

Kort gezegd:

• Claude Code Skill = codereasoning
• MCP Tools = acties
• MCP Server = mogelijkheden + beveiliging + bedrijfscontext

Ze vullen elkaar aan, niet vervangen elkaar.

Waarom MCP-servers de toegangspoort van enterprise-AI worden#

MCP-servers lossen een van de fundamentele problemen in AI-ontwikkeling op: een model heeft geen kennis van je interne systemen tenzij je die gericht en veilig beschikbaar maakt. Zonder die laag moet het model gokken, patronen matchen of instructies genereren die het niet kan uitvoeren.

Een MCP-server biedt precies die ontbrekende brug. Je krijgt een gecontroleerde plek om interne functionaliteit bloot te stellen, op jouw voorwaarden, met behoud van beveiliging. Zo krijgt het model toegang tot echte capaciteiten zonder je infrastructuur of rechtenmodel te omzeilen. In de praktijk kun je met een MCP-server:

• backendfuncties veilig beschikbaar maken
• authenticatie en autorisatie toepassen op elke actie
• een enkele, consistente interface behouden voor meerdere AI-agents
• meerstapsworkflows ondersteunen zonder logica in prompts te stoppen
• het model laten handelen met echte macht, maar altijd binnen afgesproken kaders

Daarom sluiten IAM-platforms zoals Logto zo logisch aan bij MCP.

Concepten als permissies, tokens, organisaties, scopes en M2M-flows vertalen zich direct naar de beveiligingsgaranties die een MCP-server afdwingt, waardoor identiteit het fundament wordt van veilige AI-uitvoering.

Wanneer gebruik je MCP-server vs. tools vs. Claude Code-vaardigheid?#

De toekomst: De drie lagen samen#

Het sterkste AI-systeem combineert alle drie:

• Claude Code voor codereasoning en refactoring
• MCP Tools voor atomaire operaties
• MCP Server voor beveiligde backendfunctionaliteit

Samen bieden ze:

1. IDE-intelligentie
2. Uitvoerbare tools
3. Enterprise-capaciteiten

Deze stack maakt van AI meer dan alleen "een behulpzame chatbot":

• een IAM-operator
• een DevOps-assistent
• een backend-automatiserings-engine
• een workflow-uitvoerder

En voor platforms zoals Logto wordt het de natuurlijke distributielaag voor identiteit en autorisatie.

Samenvatting#

MCP Server

Een backend-service die veilige systeemmogelijkheden voor AI ontsluit.

MCP Tools

Atomaire acties van de server. Zie ze als aanroepbare functies.

Claude Code Skill

IDE-intelligentie die code begrijpt en geavanceerde bewerkingen uitvoert — maar kan niet zelfstandig bij beveiligde systemen.

Samen: AI begrijpt je code (Claude Code), voert gerichte acties uit (Tools) en hanteert veilige workflows via je interne systemen (MCP Server).

Dit is de basis van de volgende generatie AI-gedreven ontwikkeling.