Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Architectuur van function calling in de Responses API

Les 1 van 20 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Architectuur van function calling in de Responses API
  2. Het fundamentele principe
  3. Anatomie van een antwoord
  4. De volledige lus
  5. Belangrijkste verschillen met Chat Completions
  6. Wanneer roept het model een functie aan?
  7. Belangrijkste punten

Bijgewerkt op 2 november 2026 op basis van de OpenAI-documentatie: de Code Interpreter-tool vereist nu een container-parameter (toegevoegd aan alle voorbeelden), invoertekstonderdelen gebruiken het type input_text, en webzoekopdrachten gebruiken de web_search-tool (web_search_preview is nu een verouderde tool zonder domeinfilters). Gegenereerde bestanden worden opgehaald met de functies fichiers_generes en telecharger uit Les 10. Bronnen: Code Interpreter · Web search.

Architectuur van function calling in de Responses API

Function calling is het kernmechanisme waarmee OpenAI-modellen interactie aangaan met de buitenwereld. In de Responses API is dit mechanisme opnieuw ontworpen om robuuster, voorspelbaarder en native geïntegreerd te zijn met ingebouwde tools zoals Web Search en Code Interpreter.

Het fundamentele principe

Het model doet nooit iets direct. Het zendt gestructureerde intenties uit die uw code onderschept en uitvoert. Zo geformuleerd klinkt het misschien als een technische beperking; in werkelijkheid is het de ontwerpkeuze die alles andere mogelijk maakt.

Denk eens aan het alternatief. Als het model zelf acties zou uitvoeren, zou u uw database-inloggegevens, API-sleutels en schrijfrechten moeten overhandigen – en zou u geen enkel moment hebben om iets te verifiëren. Door de ontkoppeling passeert elke intentie uw code: u valideert argumenten, handhaaft bedrijfsregels en weigert indien nodig. Het model stelt voor, uw code beschikt, en die grens is wat u in staat stelt function calling in productie te brengen zonder de controle te verliezen.

from openai import OpenAI

client = OpenAI()

# Declare a custom tool
tools = [{
    "type": "function",
    "name": "rechercher_client",
    "description": "Search for a client in the CRM by name or email",
    "parameters": {
        "type": "object",
        "properties": {
            "terme": {
                "type": "string",
                "description": "Client name, email, or ID"
            },
            "champ": {
                "type": "string",
                "enum": ["nom", "email", "id"],
                "description": "Field to search in"
            }
        },
        "required": ["terme"]
    }
}]

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Find the client Jean Dupont",
    tools=tools
)

Anatomie van een antwoord

Een antwoord bevat niet ofwel tekst ofwel tool-aanroepen: output is een heterogene lijst die beide kan mengen. De gewoonte die u vanaf uw eerste regel code moet opbouwen, is itereren over deze lijst in plaats van output[0] te lezen. Een model dat zijn redenering uitlegt voordat het een functie aanroept, produceert precies dat geval, en code die het eerste element leest, zal falen op de dag dat het commentaar begint toe te voegen.

for item in response.output:
    if item.type == "function_call":
        print(f"Call ID  : {item.call_id}")
        print(f"Function : {item.name}")
        print(f"Args     : {item.arguments}")

De call_id is essentieel: deze koppelt de aanroep aan het resultaat wanneer u het antwoord terugstuurt naar het model. Bij een enkele aanroep merkt u het nauwelijks op; bij drie parallelle aanroepen is het het enige dat voorkomt dat u het weer in Lyon toeschrijft aan de aanvraag over Marseille. Retourneer het resultaat altijd met de call_id die u hebt ontvangen, nooit met een ID die u zelf reconstrueert.

De volledige lus

Deze cyclus van vier stappen is invariant: deze geldt voor één functie of twintig, voor een eenvoudige aanroep of een agent die tien tools koppelt. Alle complexiteit die u later tegenkomt – parallelisme, fouten, fallbacks – bestaat uit het instrumenteren van deze lus, nooit uit het vervangen ervan.

import json

# 1. First call with declared tools
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What is the balance for client [email protected]?",
    tools=tools
)

# 2. Detect and execute function calls
resultats = []
for item in response.output:
    if item.type == "function_call":
        if item.name == "rechercher_client":
            args = json.loads(item.arguments)
            resultat = votre_crm.rechercher(args["terme"])
            resultats.append({
                "type": "function_call_output",
                "call_id": item.call_id,
                "output": json.dumps(resultat)
            })

# 3. Send results back to the model
response_finale = client.responses.create(
    model="gpt-5.6-terra",
    input=response.output + resultats,
    tools=tools
)

# 4. The model formulates its natural response
print(response_finale.output_text)

Belangrijkste verschillen met Chat Completions

De Responses API biedt verschillende architecturale verbeteringen.

Native afhandeling van ingebouwde tools

Ingebouwde tools worden precies zoals uw functies gedeclareerd, maar ze worden aan de kant van OpenAI uitgevoerd. Het praktische gevolg is aangenaam: u schrijft er geen lus voor. Het model roept aan, krijgt het resultaat en gaat verder, allemaal in één round trip. De hierboven beschreven lus betreft alleen uw functies – diegene die op uw machine draaien.

# Mix built-in and custom tools
tools = [
    {"type": "web_search"},
    {"type": "code_interpreter", "container": {"type": "auto"}},
    {
        "type": "function",
        "name": "ma_fonction",
        "description": "My custom function",
        "parameters": {"type": "object", "properties": {}}
    }
]

Stabiele aanroep-identificatoren

Elke functieaanroep ontvangt een unieke call_id waarmee u precies kunt traceren welk resultaat bij welke aanroep hoort, zelfs bij parallelle aanroepen.

Vereenvoudigde flow

Het is niet nodig om de rollen assistant en tool in berichten handmatig te beheren. Het veld input accepteert direct het concateneren van eerdere outputs met functieresultaten.

Wanneer roept het model een functie aan?

Het model besluit een functie aan te roepen wanneer het verzoek van de gebruiker informatie vereist die het niet heeft, wanneer de beschrijving van de functie overeenkomt met de geïdentificeerde behoefte, en wanneer de vereiste parameters uit de context kunnen worden afgeleid.

Er moeten dus drie voorwaarden gelijktijdig worden vervuld, en dat is handig voor debugging: wanneer een functie niet wordt aangeroepen terwijl dat wel zou moeten, ligt de oorzaak bijna altijd bij de tweede voorwaarde – een beschrijving die niet dekt hoe de gebruiker zijn verzoek heeft geformuleerd. De parameter tool_choice stelt u in staat gedrag af te dwingen wanneer de beschrijving niet volstaat:

# Let the model decide
tool_choice = "auto"

# Force a call to a specific function
tool_choice = {"type": "function", "name": "rechercher_client"}

# Prohibit all function calls
tool_choice = "none"

# Require at least one call without specifying which
tool_choice = "required"

Belangrijkste punten

  • Function calling is een intentieprotocol, geen uitvoeringsprotocol
  • De lus van aanroepen-uitvoeren-terugkeren is het fundamentele patroon
  • Ingebouwde en aangepaste tools coëxisteren in dezelfde tools-array
  • call_id zorgt voor traceerbaarheid voor elke aanroep
  • tool_choice stelt u in staat het gedrag van het model nauwkeurig te sturen