Function calling: hoe een model een tool aanroept

Je denkt waarschijnlijk dat het model bij function calling zelf de weer-API belt, de som uitrekent of iets op je systeem draait. Dat doet het niet, geen enkele keer.

Kijk wat er wél gebeurt. Je vraagt: wat is het weer in Amsterdam? Je hebt het model één tool gegeven, get_weather(stad), met een schema dat zegt: deze functie bestaat, en er gaat een stad in. In plaats van een temperatuur te gokken, schrijft het model een gestructureerd verzoek: get_weather met stad Amsterdam. Daar stopt het. Jouw code ziet dat verzoek, belt de echte weer-API, krijgt 18 graden terug, en stuurt dat resultaat naar het model. Pas dán schrijft het model: het is 18 graden in Amsterdam. De API is nooit door het model aangeroepen. Het vroeg jou om het te doen.

Nu de definitie, want nu heb je de flow al zien draaien. Function calling, ook tool use genoemd, is de manier waarop een taalmodel verder reikt dan tekst. Je geeft het model een lijst tools met hun schema: de naam van de functie en welke argumenten erin gaan. Op je vraag kiest het model een tool en schrijft een gestructureerd verzoek, meestal als JSON, met de functienaam en de argumenten. Jouw applicatie voert die functie uit en stuurt het resultaat terug. Pas dan antwoordt het model. Het beslist wát er moet gebeuren, het doet het nooit zelf.

Waarom vraagt het model het aan jou, in plaats van het te doen?

Omdat het model helemaal niets kán uitvoeren. Het is en blijft een tekstvoorspeller. Kiest het een tool, dan is dat nog steeds gewoon het volgende token voorspellen, alleen nu in een vast, machine-leesbaar formaat in plaats van vrije zinnen. De tools en hun schema komen mee in wat het model bij je vraag te zien krijgt; het hoeft de API niet te kennen, alleen dat de tool bestaat en welke argumenten erin gaan.

Dat is precies waarom function calling bestaat: zo kan een model actuele data ophalen, rekenen of een actie uitvoeren, dingen die het uit zichzelf niet kan of niet actueel weet. En de twee helften wisselen strak af. OpenAI beschrijft de cyclus in vijf stappen: je vraag met de tools erbij, een tool-aanroep terug, jouw code voert die uit, het resultaat terug, en dan het antwoord. Bij Claude komt zo'n verzoek terug met stop_reason tool_use en een of meer tool_use-blokken; jouw code voert ze uit en stuurt het resultaat als een tool_result terug, en die lus draait door zolang de stop_reason tool_use blijft. Elk resultaat gaat als tokens terug de context in, het werkgeheugen van het gesprek.

Snap je deze ene aanroep, dan vallen twee grotere dingen op hun plek. MCP standaardiseert alleen wáár die tools vandaan komen, de stekkerdoos, zodat je ze niet per app opnieuw bouwt, maar kiezen doet nog steeds het model. En een AI-agent is niets anders dan deze lus, herhaald richting een doel: kiezen, uitvoeren, resultaat bekijken, opnieuw. Function calling is de atoom onder allebei.

Wat als het model de verkeerde tool kiest?

Dat kan, en het gebeurt. Het model kiest de tool en verzint de argumenten met dezelfde kans op onzin als een gewone hallucinatie: een stad die niet bestaat, een bedrag met een extra nul, de verkeerde functie voor de vraag. Het verschil is dat er nu een actie aan hangt.

Daarom telt de volgorde: jouw code voert uit, dus jij zit aan de knoppen. Valideer de argumenten voor je ze gebruikt, en vraag om toestemming bij alles wat geld kost, data verandert of niet terug te draaien is. Een tool die alleen mág opzoeken is ongevaarlijker dan een die mág afschrijven. Het model levert het verzoek; of het echt gebeurt, bepaal jij.

Zodra je function calling ziet als een gast die een bonnetje schrijft terwijl jouw keuken kookt, verdwijnt de magie. De vraag is niet meer of de AI slim genoeg is om je systemen te bedienen. Het is een ontwerpvraag: welke tools geef je het model in handen, welke argumenten vertrouw je blind, en waar zet je de controle. En die vraag beantwoord jij, niet het model.