Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Het 5-stappenproces

Les 2 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Een duidelijk protocol tussen u en het model
  2. De flow in detail
  3. Flow-patronen
  4. Belangrijkste punten

Een duidelijk protocol tussen u en het model

Mistral function calling volgt een goed gedefinieerd proces van vijf stappen. Wat dit protocol leesbaar maakt, is dat elke stap één eigenaar heeft: u (de ontwikkelaar), het model of de gebruiker. Geen enkele stap wordt gedeeld en niets is ambigu. Neem de tijd om deze verdeling van taken uit uw hoofd te leren voordat u ook maar één regel code schrijft: de meeste fouten bij function calling ontstaan wanneer een ontwikkelaar verwacht dat het model een stap uitvoert die eigenlijk zijn verantwoordelijkheid is.

1

Definieer de functies (Ontwikkelaar)

U beschrijft elke beschikbare functie met een JSON-schema: naam, beschrijving, parameters, typen en verplichte velden. Het model ziet alleen deze specificatie, niet uw code.

2

Gebruiker stelt een vraag (Gebruiker)

De gebruiker stelt zijn vraag in natuurlijke taal. U stuurt dit verzoek samen met de lijst met beschikbare tools naar het Mistral-model.

3

Genereer argumenten (Model)

Het model analyseert het verzoek, selecteert de juiste functie en genereert de argumenten in JSON-formaat. Het voert de functie niet uit; het vertelt u alleen wat u moet aanroepen en met welke parameters.

4

Voer de functie uit (Ontwikkelaar)

Uw code haalt de functienaam en argumenten uit het antwoord van het model, voert de bijbehorende functie uit en haalt het resultaat op.

5

Genereer het eindantwoord (Model)

U stuurt het functieresultaat terug naar het model. Het integreert het resultaat in de conversatiecontext en formuleert een natuurlijk antwoord voor de gebruiker.

De flow in detail

Deze vijf stappen vertalen zich direct naar code. Laten we ze doorlopen aan de hand van één opzettelijk minimaal voorbeeld: een gebruiker wil de status van betaling T1001 weten. We gebruiken ditzelfde voorbeeld als rode draad tot aan het einde van het blok “Python-implementatie”, dus maak uzelf nu vertrouwd met de identifiers.

Stap 1: U definieert de tools

tools = [
    {
        "type": "function",
        "function": {
            "name": "get_payment_status",
            "description": "Retrieves the status of a payment given its transaction ID",
            "parameters": {
                "type": "object",
                "properties": {
                    "transaction_id": {
                        "type": "string",
                        "description": "The unique transaction identifier (e.g., T1001)"
                    }
                },
                "required": ["transaction_id"]
            }
        }
    }
]

Hier staat niets wat uitvoerbare code is: het is een beschrijving. Het model leert dat er een functie genaamd get_payment_status bestaat, wat deze doet en dat deze een transaction_id van het type string vereist. Het leert nooit hoe de functie is geïmplementeerd.

Stap 2: De gebruiker stelt zijn vraag

messages = [
    {"role": "user", "content": "What is the status of payment T1001?"}
]

Stap 3: Het model genereert de argumenten

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")
response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)

# The model returns a tool_call:
# function.name = "get_payment_status"
# function.arguments = '{"transaction_id": "T1001"}'

Het model heeft “T1001” uit de zin gehaald en in het juiste veld geplaatst. Merk op dat arguments als een string binnenkomt, niet als een dictionary: dat detail behandelt u in de volgende stap.

Stap 4: U voert de functie uit

import json

tool_call = response.choices[0].message.tool_calls[0]
args = json.loads(tool_call.function.arguments)
result = get_payment_status(**args)
# → {"status": "paid", "date": "2026-03-15"}

Stap 5: Het model formuleert het antwoord

messages.append(response.choices[0].message)
messages.append({
    "role": "tool",
    "name": "get_payment_status",
    "content": json.dumps(result),
    "tool_call_id": tool_call.id
})

final = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools
)
print(final.choices[0].message.content)
# → "Payment T1001 was made on March 15, 2026."

Er worden twee berichten aan de geschiedenis toegevoegd, nooit slechts één: het assistent-bericht met het oproepverzoek, gevolgd door het bericht met het resultaat. De tool_call_id koppelt deze twee aan elkaar. Laat er één weg en de API wijst het verzoek af, of het model antwoordt langs de weg.

Flow-patronen

Afhankelijk van de complexiteit van het verzoek kan deze flow verschillende vormen aannemen. Het eenvoudigste geval is wanneer er geen functie bij betrokken is: de gebruiker stelt een algemene vraag—“Wat kunt u?”—en het model antwoordt direct zonder ooit de tools aan te raken. Daarna komt de eenvoudige oproep die we zojuist hebben doorgenomen: één functie, één resultaat, één antwoord.

De volgende twee vormen zijn interessanter. Bij een sequentiële keten roept het model eerst een functie aan, leest het resultaat en gebruikt dit om te beslissen over een tweede oproep—meestal om eerst een klant-ID op te halen voordat de facturen worden opgevraagd. Bij een parallelle oproep vraagt het om uitvoering van meerdere functies tegelijk omdat geen van beide van de andere afhangt. We wijden volledige lessen aan deze twee patronen; onthoud voor nu dat beide precies berusten op de bovenstaande vijf stappen, simpelweg herhaald.

Belangrijkste punten

  • Function calling volgt een 5-stappenproces met duidelijke verantwoordelijkheden
  • Het model kan nooit direct een functie uitvoeren—het genereert alleen argumenten
  • Uw code is de poortwachter: deze beslist of de functie wel of niet wordt uitgevoerd
  • Het functieresultaat wordt teruggestuurd naar het model zodat het een natuurlijk antwoord kan formuleren
  • De flow kan eenvoudig zijn (één oproep) of complex (sequentieel, parallel)