Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

De parameter reasoning_effort

Les 2 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. De diepte van het denkproces instellen
  2. Geaccepteerde waarden, per model
  3. Implementatie in Python
  4. Het niveau kiezen per taak
  5. De kosten meten
  6. Routeren op complexiteit
  7. Beperkingen om te kennen
  8. Belangrijkste punten

Les herschreven op 2 november 2026. De vorige versie stelde dat reasoning_effort slechts twee waarden accepteerde en alleen bestond op Mistral Small. In werkelijkheid hangen de geaccepteerde waarden af van het model, en Mistral Large 4 biedt er drie. Bron: Reasoning (Mistral-documentatie).

De diepte van het denkproces instellen

Aanpasbaar redeneren rust op een eenvoudig principe: u beslist, per verzoek, hoeveel het model moet nadenken voordat het antwoordt. De hendel hiervoor heet reasoning_effort. U geeft deze mee in de API-aanroep op hetzelfde niveau als het model en de berichten, zonder dat verdere configuratie nodig is.

Geaccepteerde waarden, per model

Dit is de meest voorkomende valkuil: geaccepteerde waarden hangen af van het model.

ModelGedocumenteerde waardenOfficiële aanbeveling
Mistral Small 4 (mistral-small-2603)high, none—
Mistral Medium 3.5 (mistral-medium-3-5)high, nonehigh voor agentische workflows en code
Mistral Large 4 (mistral-large-4-0)low, medium, highBegin met high, schakel vervolgens over op medium of low als tokens of latentie belangrijker zijn

Op Small 4 en Medium 3.5 produceert high een volledig redeneerfragment voordat het antwoord komt, ten koste van een hoger tokenverbruik; none reduceert het redeneren tot het minimum en laat dit weg uit het antwoord. Op Large 4 kent de schaal drie niveaus: low voor eenvoudige taken, medium om kwaliteit, tokens en latentie in balans te brengen, en high voor complexe taken. Large 4 accepteert geen none: de documentatie specificeert dat het niveau dat voorheen none heette in de preview-versie, nu low heet.

Een laatste nuance: het type ReasoningEffort in de SDK’s somt ook minimal, xhigh en max op, omdat de opsomming elk model op het platform bestrijkt (max wordt bijvoorbeeld gebruikt door het externe model zai-glm-5-3). Het feit dat een waarde in de opsomming staat, betekent niet dat uw model deze accepteert.

Implementatie in Python

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

# Mistral Small 4, diep redeneren
response_high = client.chat.complete(
    model="mistral-small-2603",
    messages=[{"role": "user", "content": "Solve x^3 - 6x^2 + 11x - 6 = 0 and verify each root."}],
    reasoning_effort="high",
)

# Mistral Small 4, direct antwoord
response_none = client.chat.complete(
    model="mistral-small-2603",
    messages=[{"role": "user", "content": "What is the capital of Portugal?"}],
    reasoning_effort="none",
)

# Mistral Large 4, intermediair niveau
response_medium = client.chat.complete(
    model="mistral-large-4-0",
    messages=[{"role": "user", "content": "Compare two caching strategies for a high-traffic API."}],
    reasoning_effort="medium",
)

De structuur van het antwoord verandert met de instelling. Bij high is message.content een lijst die begint met een redeneerfragment; bij none is het een eenvoudige string. Uw code moet daarom beide vormen kunnen verwerken, zoals de volgende les laat zien.

In TypeScript volgt de parameter de JavaScript-casing en wordt deze geschreven als reasoningEffort:

import { Mistral } from '@mistralai/mistralai';

const client = new Mistral({ apiKey: process.env.MISTRAL_API_KEY });

const response = await client.chat.complete({
  model: 'mistral-small-2603',
  messages: [{ role: 'user', content: 'Solve x^3 - 6x^2 + 11x - 6 = 0.' }],
  reasoningEffort: 'high',
});

Het niveau kiezen per taak

Reserveer diep redeneren voor wiskundeproblemen met meerdere stappen, complexe code-debugging, vergelijkende analyses, planning, logische puzzels en risicobeoordeling. Deze delen een gemeenschappelijk kenmerk: er zijn meerdere paden mogelijk en het kiezen van het verkeerde pad is kostbaar.

Schakel het uit (of ga naar het laagste niveau) voor eenvoudige feitelijke vragen, vertaling, herformulering, directe informatie-extractie en alledaagse conversatie. Het model heeft hier niets af te wegen: het haalt informatie op of transformeert deze, en een redeneerfase zou alleen maar latentie toevoegen.

De kosten meten

Redeneren kost output-tokens. Het voorbeeld in de officiële documentatie geeft een idee van de schaal: een raadsel over leeftijd dat naar Mistral Small 4 wordt gestuurd met high, verbruikt 77 input-tokens en 1.114 output-tokens. Aan het vermelde tarief van Small 4 van $0,15 per miljoen input-tokens en $0,60 per miljoen output-tokens, kost het verzoek ongeveer $0,0007. Dat is verwaarloosbaar per eenheid, maar over een miljoen vergelijkbare verzoeken vertegenwoordigt alleen het redeneren al enkele honderden dollars, zonder winst als de helft van de vragen het niet nodig had.

Het veld usage in elk antwoord geeft u de exacte maatstaf: houd completion_tokens bij per type verzoek voordat u een instelling generaliseert.

Routeren op complexiteit

Een eenvoudige workaround is het niveau te kiezen op basis van de vraag, gebruikmakend van een tabel per model om ervoor te zorgen dat u nooit een afgewezen waarde verstuurt:

LEVELS = {
    "mistral-small-2603": {"simple": "none", "complex": "high"},
    "mistral-large-4-0": {"simple": "low", "complex": "high"},
}

COMPLEX_WORDS = ("calculate", "prove", "compare", "analyze", "optimize", "debug", "why")

def query(client, question, model="mistral-small-2603", level=None):
    """Kiest reasoning_effort op basis van de vraag, of past een geforceerd niveau toe."""
    if level is None:
        is_complex = any(word in question.lower() for word in COMPLEX_WORDS)
        level = LEVELS[model]["complex" if is_complex else "simple"]
    return client.chat.complete(
        model=model,
        messages=[{"role": "user", "content": question}],
        reasoning_effort=level,
    )

Heuristiek op basis van trefwoorden blijft grof; het volstaat om redeneren te reserveren voor verzoeken die er baat bij hebben, en het argument level stelt u in staat een instelling te forceren. Les 12 stelt een completere routeringsarchitectuur voor.

Beperkingen om te kennen

Redeneren verhoogt de kans op een correct antwoord; het garandeert er geen: verifieer kritieke resultaten (Les 9). Het verhoogt ook de latentie, wat van belang is in een conversationele interface. Tot slot moet de doorgegeven waarde overeenkomen met het aangeroepen model: plan een tabel zoals hierboven in plaats van strings door uw code te verspreiden.

Belangrijkste punten

  • reasoning_effort stuurt het redeneren per verzoek aan, zonder andere configuratie
  • Small 4 en Medium 3.5 accepteren high en none; Large 4 accepteert low, medium en high, niet none
  • SDK-opsommingen bevatten waarden die niet door alle modellen worden geaccepteerd
  • Bij high is content een lijst met fragmenten; bij none een string
  • Meet de kosten met usage.completion_tokens en routeer op complexiteit