Tool Calling vs MCP: verschil en wanneer gebruiken

Tool Calling is een functie van taalmodel-API’s waarbij het model een functieaanroep aanvraagt en je applicatie de code uitvoert. Model Context Protocol (MCP) is een open JSON-RPC-standaard waarmee AI-applicaties tools van externe servers kunnen ontdekken en aanroepen. MCP gebruikt Tool Calling als onderliggende techniek en vervangt het niet.

Ontwikkelaars van AI-agenten of backends met LLM’s komen beide termen vaak tegen in documentatie van aanbieders. Om Tool Calling en MCP te begrijpen, moet je onderscheid maken tussen hoe een model beslist een functie uit te voeren en hoe een applicatie verbinding maakt met het systeem waarin die functie zich bevindt.

Wat is Tool Calling in LLM-API’s?

Tool Calling (ook function calling genoemd) is een functie van model-API’s die een prompt in natuurlijke taal omzet in een gestructureerde functieaanroep. Je geeft functiedefinities met een naam, beschrijving en JSON Schema-parameters mee in je API-verzoek. Het model beslist of het een gestructureerde aanroep met de functienaam en argumenten teruggeeft.

Het model voert de functie niet zelf uit. Tool Calling werkt als een gesprek in meerdere stappen tussen je applicatie en het model:

Tooldeclaraties versturen: je applicatie doet een verzoek aan het model en voegt de JSON Schema-definities toe van de tools die het model kan aanroepen.
Een gestructureerde toolaanroep ontvangen: het model antwoordt met een toolaanroep met de gekozen functienaam en JSON-argumenten (Anthropic geeft bijvoorbeeld een tool_use-stopreden en -blok terug).
Code uitvoeren aan de applicatiekant: je backend valideert de argumenten en voert de lokale functie of het interne API-verzoek uit.
Het toolresultaat teruggeven: je applicatie doet een tweede verzoek aan het model met het resultaat (zoals een tool_result-blok).
Het definitieve antwoord ontvangen: het model gebruikt het resultaat om de gebruiker te antwoorden of vraagt extra toolaanroepen aan.

Een functiedefinitie van OpenAI gebruikt JSON Schema-parameters en ondersteunt strict: true om naleving van het schema af te dwingen:

{
  "type": "function",
  "name": "get_weather",
  "description": "Get the current weather for a given location.",
  "strict": true,
  "parameters": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string"
      }
    },
    "required": ["location"],
    "additionalProperties": false
  }
}

Grote model-API’s bieden gedetailleerde controle over de functieselectie. In de API’s van OpenAI en Google Gemini kun je met tool_choice de selectie op auto laten staan (de standaard), één of meer aanroepen afdwingen (required bij OpenAI, any bij Gemini), tools uitschakelen (none), het model met allowed_tools tot een deelverzameling beperken of de modus validated van Gemini gebruiken om naleving van het functieschema te waarborgen. OpenAI en Gemini ondersteunen allebei parallelle functieaanroepen, zodat een model meerdere functies in één beurt kan aanroepen. Bij OpenAI kun je parallel_tool_calls op false zetten als je maximaal één aanroep per beurt wilt. Gemini ondersteunt ook samengestelde aanroepen voor opeenvolgende uitvoeringen in meerdere stappen.

Anthropic onderscheidt toolgebruik op basis van waar de code draait. Clienttools (waaronder je eigen functies en tools volgens het Anthropic-schema zoals bash en text_editor) draaien in je applicatie. Servertools (zoals web_search, web_fetch, code_execution en tool_search) draaien rechtstreeks op de infrastructuur van Anthropic.

Wat is het Model Context Protocol (MCP)?

Het Model Context Protocol (MCP) is een opensourcestandaard om AI-applicaties via JSON-RPC 2.0 met externe systemen te verbinden. De MCP-specificatie (versie 2026-07-28), geïnspireerd door het Language Server Protocol, werkt als een USB-C-poort voor AI-applicaties: één serverintegratie kan daardoor werken met ChatGPT, Claude, Visual Studio Code, Cursor en eigen agenten.

MCP verdeelt verantwoordelijkheden over drie rollen:

Hosts: De LLM-applicaties (zoals een IDE of chatinterface) die verbindingen initiëren.
Clients: De protocolconnectors die binnen de hostapplicatie draaien.
Servers: Externe diensten die mogelijkheden en context beschikbaar stellen aan de client.

In de specificatie van 2026-07-28 gebruikt het basisprotocol zelfstandige JSON-RPC 2.0-verzoeken zonder status, waarbij per verzoek over mogelijkheden wordt onderhandeld. MCP definieert twee standaardtransporten: stdio, dat berichten gescheiden door nieuwe regels via de standaardinvoer en -uitvoer van een door de client gestart subproces verstuurt, en Streamable HTTP, waarbij elk bericht een HTTP POST naar één MCP-eindpunt is. Ontwikkelaars kunnen ook eigen transporten implementeren.

Terwijl LLM Tool Calling alleen functies afhandelt, kunnen MCP-servers drie kernfuncties aanbieden:

Tools: Functies die het AI-model kan uitvoeren.
Resources: Context en gegevens die de applicatie kan lezen.
Prompts: Berichtsjablonen en workflows voor gebruikers.

Aan de clientkant ondersteunt MCP Elicitation, waarmee een server extra informatie bij de gebruiker kan opvragen. De specificatie van 2026-07-28 bevat ook optionele, onderhandelde uitbreidingen voor Tasks (asynchrone langlopende bewerkingen), Skills over MCP en MCP Apps (interactieve UI-elementen die inline worden weergegeven).

Voor de uitvoering van tools ontdekt een MCP-client beschikbare tools door tools/list aan te roepen, dat paginering en caching ondersteunt. Servers die de mogelijkheid listChanged declareren, kunnen clients melden wanneer hun beschikbare tools veranderen. Elke MCP-tooldefinitie bevat een hoofdlettergevoelige name (aanbevolen lengte: 1 tot 128 tekens), een optionele title, een description, optionele icons, een inputSchema (standaard JSON Schema 2020-12), een optioneel outputSchema en optionele annotaties.

Wanneer het model besluit een MCP-tool te gebruiken, stuurt de client een tools/call-JSON-RPC-verzoek naar de server:

{
  "jsonrpc": "2.0",
  "id": 1,
  "method": "tools/call",
  "params": {
    "name": "get_weather",
    "arguments": {
      "location": "San Francisco, CA"
    }
  }
}

Als een tool op de server niet kan worden uitgevoerd, geeft MCP de fout binnen het resultaat terug met isError: true, zodat het taalmodel de fout kan lezen en zichzelf kan corrigeren.

Tool Calling vs MCP: vergelijking

Een directe vergelijking van LLM Tool Calling en MCP laat zien dat ze op verschillende lagen van de stack werken. In november 2026 verschillen native Tool Calling en het Model Context Protocol op zeven architectuurpunten:

Aspect	Tool Calling (Function Calling)	Model Context Protocol (MCP)
Wat het is	Functie van een model-API waarbij een LLM gestructureerde functieargumenten produceert	Open JSON-RPC 2.0-protocol dat AI-hosts en clients met externe servers verbindt
Wie tools definieert	Je applicatiecode (of servertools van de aanbieder) in het model-API-verzoek	Een MCP-server die Tools, Resources en Prompts aanbiedt
Waar code draait	De backend van je applicatie (of de cloud van de LLM-aanbieder voor servertools)	Een lokaal subproces (`stdio`) of een externe dienst (Streamable HTTP)
Detectie	Statisch per API-verzoek; je code legt schema’s vast of selecteert ze vóór de modelaanroep	Dynamisch tijdens runtime via `tools/list` en `listChanged`-meldingen
Transport	HTTPS-API van de aanbieder (OpenAI, Anthropic, Google Gemini)	`stdio`, Streamable HTTP of eigen transporten
Overdraagbaarheid tussen clients	Gebonden aan je app en de schema-indeling van de specifieke LLM-aanbieder	Overdraagbaar tussen alle MCP-compatibele hosts (Claude, ChatGPT, VS Code, Cursor, eigen apps)
Kosten	Inputtokens voor tooldefinities, outputtokens voor aanroepen en extra kosten voor servertools van de aanbieder	Inputtokens voor elk geladen toolschema en infrastructuur om de MCP-server te hosten of uit te voeren

Vervangt MCP Function Calling?

MCP vervangt Function Calling niet, omdat het taalmodel nog steeds Tool Calling gebruikt om elke MCP-tool te selecteren en aan te roepen. Tool Calling en MCP zijn aanvullende lagen in dezelfde levenscyclus van een verzoek.

Wanneer een AI-applicatie verbinding maakt met een MCP-server, combineert de workflow beide systemen:

Detectie via MCP: de MCP-client van de hostapplicatie stuurt een tools/list-verzoek naar de MCP-server en ontvangt de toolnamen, beschrijvingen en JSON Schema-inputSchema-objecten van de server.
Opmaak voor het LLM: de host vertaalt die MCP-tooldefinities naar de native tools-array van de LLM-aanbieder en verstuurt ze samen met de prompt van de gebruiker.
Selectie via Tool Calling: het taalmodel beoordeelt de prompt en geeft een standaard toolaanroep met de gekozen toolnaam en argumenten terug.
Uitvoering via MCP: de host vangt de toolaanroep van het model af, vertaalt die naar een MCP-tools/call-verzoek en verstuurt het via stdio of Streamable HTTP naar de MCP-server.
Afronding: de MCP-server geeft het resultaat terug (met isError: true als de uitvoering mislukte), de host geeft dat als toolresultaat door aan het model en het model genereert zijn definitieve antwoord.

Zonder Tool Calling in de model-API zou het LLM geen mechanisme hebben om een MCP-tool te activeren. Zonder MCP moet je applicatie elk toolschema en elke uitvoeringshandler handmatig koppelen.

Hoe ondersteunen OpenAI, Anthropic en Google MCP rechtstreeks?

OpenAI, Anthropic en Google laten je nu externe MCP-servers rechtstreeks als ingebouwd tooltype aan hun model-API’s doorgeven. In plaats van zelf een MCP-clientlus te schrijven die tools/list en tools/call verbindt, maakt de API van de modelaanbieder namens jou verbinding met de MCP-server.

In november 2026 implementeert elke aanbieder rechtstreekse verbindingen met MCP-servers met eigen mogelijkheden en gedocumenteerde beperkingen:

OpenAI Responses API

In de OpenAI Responses API kun je een MCP-server aansluiten door "type": "mcp" samen met server_label en server_url in je tools-array op te geven. OpenAI biedt twee belangrijke instellingen voor productieomgevingen:

allowed_tools: importeert alleen een specifieke selectie tools van de MCP-server, zodat de modelcontext niet overbelast raakt.
require_approval: bepaalt of toolaanroepen automatisch worden uitgevoerd of wachten op expliciete menselijke goedkeuring.

Voor lokale of privéservices biedt OpenAI een Secure MCP Tunnel, zodat je interne MCP-servers kunt verbinden zonder ze publiekelijk op internet beschikbaar te maken.

Anthropic MCP Connector

Anthropic biedt een MCP connector in bèta in de Messages API (mcp_servers en mcp_toolset) die verbinding maakt met externe MCP-servers zonder afzonderlijke clientimplementatie. Houd rekening met vier gedocumenteerde beperkingen:

Alleen tools: de connector ondersteunt alleen toolaanroepen uit de MCP-specificatie (geen MCP Resources of Prompts).
Openbare HTTP vereist: de MCP-server moet publiekelijk bereikbaar zijn via HTTP (met ondersteuning voor Streamable HTTP en SSE).
Geen directe lokale stdio: lokale stdio-servers kunnen niet rechtstreeks met de Messages API verbinden, al bieden de SDK’s van Anthropic clienthulpmiddelen voor lokale servers.
Uitsluitingen voor compliance: de MCP connector in bèta komt niet in aanmerking voor Zero Data Retention (ZDR) of HIPAA-workloads.

Google Gemini Interactions API

De Gemini Interactions API van Google accepteert externe MCP-servers via de declaratie "type": "mcp_server", geconfigureerd met name, url, headers en allowed_tools. Google stelt twee strikte regels voor deze integratie:

Alleen Streamable HTTP: de Gemini Interactions API ondersteunt Streamable HTTP-servers en geen SSE-transporten.
Naamgeving: servernamen moeten snake_case gebruiken en mogen geen koppeltekens bevatten.

Wanneer gebruik je Tool Calling of MCP?

De keuze tussen MCP en Tool Calling hangt af van wie de integraties onderhoudt en hoeveel applicaties ze moeten delen. Bekijk de beperkingen van je project aan de hand van drie veelvoorkomende patronen.

Wanneer eenvoudig Tool Calling volstaat

Gebruik native LLM Tool Calling als je tools in de backend van één applicatie zitten en geen externe client ze hoeft aan te roepen. Als ik een webapp bouw met vijf interne databasequery’s en een Stripe-betaalactie, voegt het schrijven van een MCP-server een onnodige netwerkstap of een onnodig subproces toe.

Eenvoudig Tool Calling past beter wanneer:

Je maar een klein aantal functies hebt die je eigen database of interne microservices bevragen.
Je de volledige codebase beheert en lage latency en directe validatie binnen het proces wilt.
Geen andere AI-assistent, IDE of ander team deze functies hoeft te ontdekken of hergebruiken.

Wanneer een MCP-server loont

Bouw of gebruik een MCP-server wanneer dezelfde tools met meerdere AI-clients moeten werken of wanneer een ander team verantwoordelijk is voor het onderliggende systeem. Als je ontwikkelplatform issue-tracking en deploymentlogs via MCP aanbiedt, kunnen ontwikkelaars precies dezelfde server aansluiten op Claude, ChatGPT, Visual Studio Code, Cursor en je interne agent zonder schema’s te herschrijven.

MCP loont wanneer:

Je één keer wilt schrijven en de oplossing tussen meerdere AI-hosts en ontwikkel-IDE’s wilt kunnen overdragen.
Een externe aanbieder of een afzonderlijk intern team de integratie onderhoudt.
Je agent afhankelijk is van dynamische tooldetectie (tools/list en listChanged) wanneer mogelijkheden tijdens runtime veranderen.
Je workflow naast functie-uitvoering MCP Resources, promptsjablonen voor gebruikers of informatieverzoeken aan gebruikers nodig heeft.

De hybride opzet

Een veelvoorkomend patroon voor teams die AI-agenten van pilot naar productie brengen, is beide benaderingen combineren. Een typische applicatie definieert enkele latencygevoelige native functietools in code en sluit daarnaast één of twee externe MCP-servers aan voor SaaS-integraties van derden, met allowed_tools om onnodige eindpunten uit te filteren.

Afwegingen voor beveiliging, latency en tokenkosten

Tools toevoegen aan een LLM-applicatie, via native declaraties of MCP-servers, brengt tokenkosten, aandachtspunten voor caching en beveiligingsgrenzen met zich mee die je zorgvuldig moet beheren.

Kosten voor inputtokens en promptcaching

Elke tooldefinitie die je aan een model-API doorgeeft, telt mee als inputtokens. Anthropic vermeldt dat tooldefinities in de parameter tools als inputtokens tellen. OpenAI merkt op dat sommige MCP-servers tientallen tools tegelijk aanbieden en dat veel aangeboden tools zowel de kosten als de latency kunnen verhogen.

Om de tokenkosten voorspelbaar te houden:

Filter de geïmporteerde tools: OpenAI en Google gebruiken allowed_tools, terwijl je met de MCP connector van Anthropic afzonderlijke tools in mcp_toolset kunt toestaan, blokkeren of configureren.
Houd de volgorde van de toollijst deterministisch. De MCP-specificatie vermeldt dat een deterministische volgorde in tools/list clients helpt de toollijst te cachen en de hitratio van promptcaching voor LLM’s verbetert wanneer tooldefinities in de modelcontext staan.

Vertrouwensgrenzen en menselijke goedkeuring

Tools betekenen uitvoering van willekeurige code. Dat is nog zorgelijker als je ook AI-agenten voor computergebruik inzet die met volledige besturingssystemen werken. Als je een MCP-server van een derde verbindt, passeer je een vertrouwensgrens waarbij onbetrouwbare toolbeschrijvingen of serverantwoorden een ingang voor promptinjectie kunnen vormen.

De MCP-specificatie waarschuwt expliciet dat toolannotaties als onbetrouwbaar moeten worden behandeld, tenzij ze van een vertrouwde server komen. Omdat MCP veiligheid niet op het niveau van het communicatieprotocol kan afdwingen, stelt de specificatie dat hostapplicaties vóór elke toolaanroep expliciete toestemming van de gebruiker moeten verkrijgen en altijd een mens betrokken zouden moeten houden die aanroepen kan weigeren. Schakel bij directe API-integraties zoals de Responses API van OpenAI require_approval in voor gevoelige tools, zodat een mens argumenten vóór uitvoering kan beoordelen.

FAQ

Is MCP hetzelfde als Function Calling?

Nee. Function Calling (Tool Calling) is het mechanisme van een model-API waarbij een LLM een gestructureerd JSON-verzoek produceert om een benoemde functie te draaien. Het Model Context Protocol (MCP) is een open communicatiestandaard waarmee AI-applicaties Tools, Resources en Prompts op externe servers kunnen ontdekken en aanroepen.

Kun je MCP zonder Tool Calling gebruiken?

Je kunt MCP Resources en promptsjablonen zonder Tool Calling van het model gebruiken, omdat de hostapplicatie of gebruiker deze functies leest of activeert. Maar wanneer een AI-model zelfstandig een MCP-tool via tools/call aanroept, gebruikt het zijn native Tool Calling om die tool te selecteren.

Kost MCP meer tokens dan native Tool Calling?

Een afzonderlijke tooldefinitie kost evenveel inputtokens of je app die nu uit lokale code of van een MCP-server laadt. MCP-opstellingen verbruiken in de praktijk vaak meer tokens omdat één MCP-server tientallen tools tegelijk kan aanbieden, tenzij je de lijst met allowed_tools filtert.

Welke LLM-aanbieders ondersteunen MCP-servers native in hun API’s?

In november 2026 accepteren OpenAI, Anthropic en Google allemaal rechtstreeks externe MCP-servers in hun API’s. OpenAI ondersteunt "type": "mcp" in de Responses API, Anthropic biedt de MCP connector in bèta (mcp_servers en mcp_toolset) in de Messages API en Google ondersteunt "type": "mcp_server" in de Gemini Interactions API.

Kan de API van Anthropic rechtstreeks verbinden met een lokale stdio MCP-server?

Nee. De MCP connector in bèta van Anthropic in de Messages API verbindt alleen met externe MCP-servers die openbaar via HTTP bereikbaar zijn (Streamable HTTP en SSE). Om een lokale stdio MCP-server met Claude te gebruiken, moet je de verbinding aan de clientkant uitvoeren met de SDK-hulpmiddelen van Anthropic.

Tool Calling vs MCP: verschil en wanneer gebruiken

Wat is Tool Calling in LLM-API’s?

Wat is het Model Context Protocol (MCP)?

Tool Calling vs MCP: vergelijking

Vervangt MCP Function Calling?