Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Conversatie over meerdere beurten

Les 7 van 14 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Verder dan enkele aanroepen
  2. Het principe: geschiedenis behouden
  3. Volledige conversatielus
  4. Voorbeeld van een conversatie over meerdere beurten
  5. Sequentiële aanroepen ketenen
  6. Geschiedenisgrootte beheren
  7. Belangrijkste punten

Verder dan enkele aanroepen

In een echte applicatie stelt een gebruiker niet één vraag en verdwijnt vervolgens. Gebruikers koppelen verzoeken aan elkaar, komen terug op eerdere onderwerpen en geven hints zoals “hoe zit het met deze?”, die de zin op zich niet kan oplossen. Function calling moet werken binnen deze context van een conversatie over meerdere beurten, waarbij het model bij elke stap van de dialoog functies kan aanroepen zonder ooit uit het oog te verliezen wat eraan voorafging.

Het principe: geschiedenis behouden

Het komt neer op één zin: bewaar alle berichten in een lijst die bij elke uitwisseling groeit. Het model heeft geen eigen geheugen tussen API-aanroepen; de enige context die het heeft, is wat u terugstuurt. Deze volledige geschiedenis stelt het model in staat om impliciete verwijzingen te begrijpen.

import os
import json
from mistralai.client import Mistral
from functools import partial

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])
model = "mistral-large-latest"

# Conversatiegeschiedenis
messages = [
    {
        "role": "system",
        "content": "You are a payment tracking assistant. "
                   "Respond in concise English."
    }
]

Volledige conversatielus

De onderstaande code werkt in twee fasen. process_tool_calls voert alle door het model gevraagde aanroepen uit en start de conversatie opnieuw met de resultaten; chat behandelt een volledige beurt, van de invoer van de gebruiker tot de uiteindelijke tekst.

def process_tool_calls(response, messages, available_functions, tools):
    """Verwerkt tool_calls en retourneert het definitieve antwoord."""
    message = response.choices[0].message
    messages.append(message)

    # Voer elke tool_call uit
    for tool_call in message.tool_calls:
        function_name = tool_call.function.name
        function_params = json.loads(tool_call.function.arguments)

        if function_name in available_functions:
            result = available_functions[function_name](**function_params)
        else:
            result = json.dumps({"error": f"Unknown function {function_name}"})

        messages.append({
            "role": "tool",
            "name": function_name,
            "content": result,
            "tool_call_id": tool_call.id
        })

    # Roep het model opnieuw aan met de resultaten
    return client.chat.complete(
        model=model, messages=messages, tools=tools
    )


def chat(user_input: str, messages: list, tools: list,
         available_functions: dict) -> str:
    """Behandelt een volledige conversatiebeurt."""
    messages.append({"role": "user", "content": user_input})

    response = client.chat.complete(
        model=model, messages=messages, tools=tools
    )

    message = response.choices[0].message

    # Blijf doorgaan zolang het model functies wil aanroepen
    while message.tool_calls and len(message.tool_calls) > 0:
        response = process_tool_calls(
            response, messages, available_functions, tools
        )
        message = response.choices[0].message

    # Het model is klaar: het antwoordt met tekst
    messages.append(message)
    return message.content

De while-lus is het cruciale onderdeel. Na ontvangst van een functieresultaat kan het model best nog een ander verzoek doen: de lus gaat door zolang er tool_calls worden geproduceerd en stopt pas wanneer er uiteindelijk tekst wordt teruggegeven. Een simpele if zou alleen de eerste aanroep afhandelen en vervolgens een leeg antwoord retourneren in elk geval waar twee aanroepen nodig waren.

Voorbeeld van een conversatie over meerdere beurten

Laten we bekijken hoe deze lus eruitziet over vier gekoppelde beurten.

# Beurt 1
reponse = chat("What is the status of payment T1001?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 status: paid."

# Beurt 2 — vervolgvraag
reponse = chat("When was it made?",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1001 was made on March 15, 2026."

# Beurt 3 — nieuwe transactie
reponse = chat("Compare with payment T1003.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "Payment T1003 is pending, unlike T1001 which is paid."

# Beurt 4 — vraag zonder functie
reponse = chat("Thanks, that's all for today.",
               messages, tools, available_functions)
print(f"Assistant : {reponse}")
# → "You're welcome! Feel free to ask if you have other questions."

Beurt 2 is degene die u nauwkeurig moet bekijken. “When was it made?” bevat geen identificatiecode; de geschiedenis is wat het model in staat stelt te begrijpen dat dit nog steeds verwijst naar T1001 en om retrieve_payment_date aan te roepen met het juiste argument. Verwijder de berichten van Beurt 1 en deze zin wordt onoplosbaar. In Beurt 3 kan het model beslissen meerdere functies aan te roepen—status en datum voor T1003—om de vergelijking op te bouwen met resultaten die al voor T1001 zijn verkregen. Beurt 4 activeert helemaal geen aanroepen: het model weet ook wanneer het zich moet inhouden.

Sequentiële aanroepen ketenen

Sommige verzoeken vereisen dat het model wacht op één resultaat voordat het weet wat het vervolgens moet vragen. De while-lus in chat() behandelt dit geval zonder ook maar één extra regel code.

# Gebruiker vraagt om iets waarvoor 2 sequentiële aanroepen nodig zijn
reponse = chat(
    "Show me the status and date of payment T1002.",
    messages, tools, available_functions
)
# Het model kan:
# 1. retrieve_payment_status(T1002) aanroepen
# 2. Het resultaat ontvangen
# 3. retrieve_payment_date(T1002) aanroepen
# 4. Het resultaat ontvangen
# 5. Het definitieve antwoord formuleren met beide informatiefragmenten

Vanuit het perspectief van de berichtengeschiedenis ziet de sequentiële stroom er als volgt uit:

user → assistant(tool_call_1) → tool(result_1) → assistant(tool_call_2) → tool(result_2) → assistant(response)

Tel de assistant-beurten mee: drie, wat betekent dat drie verzoeken aan de API worden gefactureerd. Dat is de kostprijs van sequentiële uitvoering, en de reden waarom de volgende les zich richt op parallelle aanroepen.

Geschiedenisgrootte beheren

In productie wordt een langdurige conversatie duur: elke beurt stuurt de volledige set eerdere berichten terug, en de tokenrekening groeit kwadratisch. Een eenvoudige strategie is om alleen het systeembericht en de meest recente uitwisselingen te bewaren.

def trim_messages(messages: list, max_messages: int = 20) -> list:
    """Behoudt het systeembericht en de laatste N berichten."""
    system_messages = [m for m in messages if hasattr(m, "role")
                       and m.get("role") == "system"
                       or (isinstance(m, dict) and m.get("role") == "system")]

    non_system = [m for m in messages if m not in system_messages]

    if len(non_system) > max_messages:
        non_system = non_system[-max_messages:]

    return system_messages + non_system

Eén voorzorgsmaatregel voordat u deze functie implementeert: knip nooit een tool_call af zonder het bijbehorende tool-bericht. Als de afkapping tussen de twee valt, ontvangt de API een onbeantwoord aanroepverzoek en wijst het de query af. Pas het afkappunt aan om complete paren te behouden in plaats van blindelings berichten te tellen.

Belangrijkste punten

  • Onderhoud een volledige geschiedenis van berichten zodat het model de context begrijpt
  • Gebruik een while-lus om sequentiële functieaanroepen af te handelen
  • Het model begrijpt impliciete verwijzingen (“die”, “de vorige”) dankzij de context
  • Beperk in productie de grootte van de geschiedenis terwijl u tool_call/tool-paren intact houdt
  • De hier getoonde chat()-functie is een herbruikbaar patroon voor elke applicatie met function calling