Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Opties voor tool_choice

Les 9 van 14 Bijgewerkt op 29 juli 2026 Ontwikkelaar
Op deze pagina
  1. Bepalen wie de beslissing neemt
  2. auto — Laat het model oordelen
  3. any — Gestructureerde output afdwingen
  4. none — Tools uitschakelen zonder ze te verwijderen
  5. De instelling aanpassen tijdens het gesprek
  6. Belangrijkste punten

Bepalen wie de beslissing neemt

Het doorgeven van tools aan de API betekent niet dat het model ze verplicht moet gebruiken, of zelfs maar mag gebruiken. Tussen deze twee uitersten fungeert de parameter tool_choice als scheidsrechter. Afhankelijk van de waarde die u toekent, kunt u het model vrij laten oordelen, het dwingen een gestructureerde oproep te genereren, of de toegang tot de zojuist gedeclareerde tools volledig intrekken. Het is een subtiele instelling, maar deze verandert radicaal hoe dezelfde code zich gedraagt wanneer deze met dezelfde vraag wordt geconfronteerd.

WaardeGedragUse Case
autoHet model beslist vrij of het een tool gebruikt of in tekst antwoordt. Dit is de standaardmodus.Conversationele assistenten, algemene chatbots
anyHet model wordt gedwongen ten minste één tool aan te roepen. Het kan niet alleen met tekst antwoorden.Geautomatiseerde pipelines, gestructureerde data-extractie
noneHet model kan geen tools gebruiken, zelfs niet als ze zijn gedefinieerd. Het antwoordt uitsluitend in tekst.Resultaten samenvatten zonder nieuwe oproepen, een antwoord herformuleren
requiredSynoniem voor any. Het model moet ten minste één tool gebruiken.Equivalent aan any, voor compatibiliteit

auto — Laat het model oordelen

Dit is de standaardwaarde, degene die u gebruikt zonder het te beseffen wanneer u de parameter weglaat.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="auto"  # Optioneel, dit is de standaardwaarde
)

Met auto evalueert het model het verzoek voordat het actie onderneemt. Als de vraag externe data vereist waarover het niet beschikt, roept het een functie aan; als de query algemeen of relationeel is, antwoordt het direct in tekst. Deze schakelaar zorgt ervoor dat een assistent natuurlijk aanvoelt: de gebruiker hoeft niet te weten dat er tools achter de schermen draaien.

# Het model roept een functie aan
messages = [{"role": "user", "content": "Status van betaling T1001?"}]
# → tool_call: retrieve_payment_status(transaction_id="T1001")

# Het model antwoordt direct
messages = [{"role": "user", "content": "Hallo, hoe gaat het?"}]
# → content: "Hallo! Ik ben een betalingsassistent. Hoe kan ik u helpen?"

Het tweede voorbeeld verdient aandacht: het afdwingen van een functieoproep bij een simpele begroeting zou een retrieve_payment_status met een verzonnen ID produceren. Dat is precies wat auto voorkomt, en daarom blijft deze modus de meest gebruikte in productieomgevingen.

any — Gestructureerde output afdwingen

Er zijn daarentegen contexten waarin vrije tekst voor u geen waarde heeft. Een ingestie-pipeline die tienduizend documenten verwerkt, verwacht bruikbare JSON, geen beleefde zin. Met any moet het model ten minste één functie aanroepen, zelfs als de vraag dat niet lijkt te vereisen.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="any"
)

Interessant genoeg hergebruikt de meest voorkomende use case function calling voor een ander doel dan oorspronkelijk bedoeld: u declareert geen functie om deze uit te voeren, maar om een outputschema te garanderen. Hier wordt extract_entities nooit aan de serverzijde aangeroepen; het gaat ons om het JSON-contract.

# Gestructureerde extractie: dwing het model om data te extraheren
tools = [{
    "type": "function",
    "function": {
        "name": "extract_entities",
        "description": "Extraheert benoemde entiteiten uit tekst",
        "parameters": {
            "type": "object",
            "properties": {
                "persons": {"type": "array", "items": {"type": "string"}},
                "organizations": {"type": "array", "items": {"type": "string"}},
                "dates": {"type": "array", "items": {"type": "string"}}
            },
            "required": ["persons", "organizations", "dates"]
        }
    }
}]

messages = [{"role": "user", "content": "Sophia Yang van Mistral presenteerde "
            "function calling op 15 maart 2026."}]

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="any"  # Forceer extractie
)

# → extract_entities(persons=["Sophia Yang"],
#                     organizations=["Mistral"],
#                     dates=["15 maart 2026"])

Let terloops op required: dit is een synoniem voor any, opgenomen voor compatibiliteit met code die voor andere API’s is geschreven. Beide waarden leveren hetzelfde gedrag op; kies degene die uw code het meest leesbaar maakt en houd daar bij.

none — Tools uitschakelen zonder ze te verwijderen

De derde waarde speelt in op een minder voor de hand liggende behoefte. U heeft uw data al opgehaald via meerdere tool_calls en nu wilt u dat het model deze synthetiseert. Als u het gesprek in auto-modus voortzet, staat niets het model in de weg om opnieuw een functie aan te roepen “om even te controleren”, wat de latentie verhoogt en een oneindige lus kan triggeren. none verbiedt nieuwe oproepen terwijl de tool-definities in de context blijven, waardoor het model nauwkeurig kan spreken over de data die het al heeft.

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="none"
)

Drie use cases komen constant terug: een samenvatting vragen na een reeks functieoproepen, een antwoord herformuleren zonder nieuwe oproepen te triggeren, en tijdens ontwikkeling testen hoe het model zich gedraagt wanneer het van zijn tools wordt beroofd, wat snel aan het licht brengt welke vragen het denkt uit het geheugen te kunnen beantwoorden.

# Na het ophalen van data via tool_calls...
# Vraag een samenvatting zonder nieuwe oproepen
messages.append({
    "role": "user",
    "content": "Vat de informatie uit alle gevonden betalingen samen."
})

response = client.chat.complete(
    model="mistral-large-latest",
    messages=messages,
    tools=tools,
    tool_choice="none"  # Het model vat samen met wat het al heeft
)

De instelling aanpassen tijdens het gesprek

U hoeft tool_choice niet eenmalig bij de start in te stellen. In productie is het gebruikelijk deze bij elke beurt te berekenen op basis van de context: het eerste bericht van het gesprek, de gedetecteerde intentie in het verzoek, of het aantal reeds verbruikte oproepen. De onderstaande functie illustreert deze logica in zijn eenvoudigste vorm: het model blijft standaard vrij, behalve wanneer de gebruiker expliciet om een samenvatting vraagt.

def get_tool_choice(user_input: str, turn_count: int) -> str:
    """Bepaalt tool_choice op basis van context."""

    # Eerste beurt: laat het model beslissen
    if turn_count == 0:
        return "auto"

    # Als de gebruiker expliciet om een samenvatting vraagt
    if any(word in user_input.lower() for word in ["summarize", "recap", "synthesis"]):
        return "none"

    # Standaard
    return "auto"

Houd in de praktijk auto als uw basisinstelling: dit is het meest natuurlijk en flexibel. Reserveer any voor pipelines voor gestructureerde data-extractie, en none voor momenten waarop u oneindige tool_call-lussen moet voorkomen. Eén beperking is absoluut: wijzig tool_choice nooit midden in de verwerking van een tool_call. Rond eerst de cyclus af door alle verwachte tool-berichten terug te sturen, en pas de parameter pas in de volgende beurt aan; anders wordt de geschiedenis inconsistent en wijst de API het verzoek af.

Belangrijkste punten

  • tool_choice bepaalt wanneer het model functies gebruikt
  • auto = het model beslist vrij (standaard, aanbevolen voor chatbots)
  • any = het model wordt gedwongen een tool aan te roepen (pipelines, gestructureerde extractie)
  • none = tools zijn uitgeschakeld (samenvattingen, herformuleringen)
  • Pas tool_choice dynamisch aan op basis van de gesprekscontext