Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Het juiste redeneerniveau kiezen

Les 12 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Twee draaiknoppen in plaats van een modellenlijn
  2. De beslissingsmatrix
  3. Bereken voordat u schaalt
  4. Een routeringsarchitectuur
  5. Best practices voor productie
  6. Samenvatting van de cursus
  7. Belangrijkste punten
  8. Test uw kennis

Les herschreven op 2 november 2026. Eerder werd er een onderscheid gemaakt tussen het “aanpasbare” redeneren van Mistral Small en het “native” redeneren van Magistral, maar Magistral is op 31 juli 2026 uit dienst genomen. De keuze ligt nu tussen generalistische modellen en reasoning_effort-niveaus. Bronnen: Reasoning · Small 4 en Large 4 modelkaarten.

Twee draaiknoppen in plaats van een modellenlijn

Het kiezen van een redeneermodel bij Mistral betekende vroeger kiezen tussen twee verschillende lijnen. Vandaag de dag betekent het het afstellen van twee draaiknoppen: het model (Small 4 voor de meeste taken, Large 4 voor de moeilijkste gevallen) en het redeneerniveau (none of high op Small 4; low, medium of high op Large 4). Een enkele applicatie kan, en moet vaak, meerdere combinaties gebruiken.

De beslissingsmatrix

SituatieStartinstellingWaarom
Feitelijke vraag, herformulering, extractieSmall 4, noneNiets om te overwegen: redeneren voegt alleen latentie en tokens toe
Meerstapsberekening, routine debugging, eenvoudige vergelijkingSmall 4, highRedeneren corrigeert ketenfouten tegen een bescheiden kostprijs
Samenvatting of herformulering op Large 4Large 4, lowLarge 4 accepteert geen none; low is het meest economische niveau
Analyse met meerdere criteria, migratieplan, subtiele bugLarge 4, medium vervolgens highTest eerst het tussenliggende niveau; schaal op als de kwaliteit daarom vraagt
Kritieke beslissing (juridisch, financieel, medisch)Large 4, high + verificatieRedeneren vermindert fouten maar elimineert ze niet: een tweede pas of menselijke review blijft noodzakelijk

Deze matrix biedt startpunten, geen absolute waarheden: uw eigen evaluaties bepalen de uiteindelijke keuze. Onthoud ook dat Large 4 vanaf 2 november 2026 in Public Preview is.

Bereken voordat u schaalt

De vermelde tarieven (per miljoen tokens, vastgelegd op 2 november 2026) stellen u in staat de kosten van een instelling te schatten op basis van het veld usage in de antwoorden:

RATES = {  # USD per miljoen tokens: (input, output)
    "mistral-small-2603": (0.15, 0.60),
    "mistral-large-4-0": (0.70, 2.10),
    "mistral-medium-3-5": (1.50, 7.50),   # verouderd, uit dienst op 30 april 2027
}

def cost(response, model):
    """Kosten van een antwoord, inclusief redeneren (exclusief cache-kortingen)."""
    input_rate, output_rate = RATES[model]
    u = response.usage
    return (u.prompt_tokens * input_rate + u.completion_tokens * output_rate) / 1_000_000

Tel deze kosten per verzoektype op over een paar dagen echt verkeer: dat cijfer vertelt u of een gegeneraliseerde high-instelling duurzaam is.

Een routeringsarchitectuur

In een echte applicatie zijn de meeste verzoeken eenvoudig. Betalen voor redeneren hieraan voegt geen waarde toe. De volgende router vraagt eerst aan Small 4, zonder redeneren, om de complexiteit van de vraag in te schatten, en routeert vervolgens de query naar de juiste instelling:

import os
from mistralai.client import Mistral

class ReasoningRouter:
    """Routeert elke vraag naar een model en een redeneerniveau."""

    def __init__(self):
        self.client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    def complexity(self, question):
        r = self.client.chat.complete(
            model="mistral-small-2603",
            messages=[{"role": "user", "content":
                f"Rate the complexity of this question from 0 to 10. Reply with only the number: {question}"}],
            reasoning_effort="none",
        )
        try:
            return min(max(int(str(r.choices[0].message.content).strip()), 0), 10)
        except ValueError:
            return 5  # conservatieve waarde als het antwoord geen getal is

    def respond(self, question, system_prompt=None):
        score = self.complexity(question)
        if score <= 3:
            model, level = "mistral-small-2603", "none"
        elif score <= 7:
            model, level = "mistral-small-2603", "high"
        else:
            model, level = "mistral-large-4-0", "high"
        messages = [{"role": "system", "content": system_prompt}] if system_prompt else []
        messages.append({"role": "user", "content": question})
        return self.client.chat.complete(model=model, messages=messages, reasoning_effort=level)

De classificatie-oproep kost weinig: een paar dozijn tokens op het goedkoopste model, zonder redeneren. Pas de drempelwaarden aan na observatie, waarbij u de kwaliteit en kosten van elke tak vergelijkt.

Best practices voor productie

Log het gebruik per tak. Sla voor elk antwoord het model, het niveau, usage.prompt_tokens, usage.completion_tokens en de bovenstaande berekende kosten op. Zonder deze cijfers kunt u niet bepalen of redeneren zijn vruchten afwerpt.

Gebruik gedateerde identificatoren. Gebruik in productie mistral-small-2603 in plaats van mistral-small-latest: een alias kan overschakelen naar een nieuwe versie zonder dat uw code wijzigt. Centraliseer deze identificatoren in één configuratie.

MODELS = {
    "fast": ("mistral-small-2603", "none"),
    "reasoning": ("mistral-small-2603", "high"),
    "deep": ("mistral-large-4-0", "high"),
}

Plan een fallback. Omdat Large 4 in Public Preview is, beschermt een fallback naar Small 4 in high-modus uw service als de oproep mislukt. Alle SDK HTTP-fouten erven van MistralError:

from mistralai.client import errors

def query_with_fallback(client, messages):
    try:
        return client.chat.complete(model="mistral-large-4-0", messages=messages, reasoning_effort="high")
    except errors.MistralError:
        return client.chat.complete(model="mistral-small-2603", messages=messages, reasoning_effort="high")

Let op veroudering. De Mistral modellenpagina toont data voor veroudering en uitdienstneming. Medium 3.5 wordt op 30 april 2027 uit dienst genomen: als u dit gebruikt, staat de deadline al vast.

Samenvatting van de cursus

Redeneren geeft het model de ruimte om na te denken voordat het antwoordt; bij Mistral configureert u dit per verzoek met reasoning_effort, waarvan de waarden afhankelijk zijn van het model. Het antwoord komt dan binnen als fragmenten—denken en vervolgens antwoord—die u moet kunnen lezen, ook in streaming-modus, en volledig moet kunnen afspelen voor gesprekken met meerdere beurten. Agents en de Conversations API dragen dezelfde instelling over in completion_args. Magistral is uit dienst: Small 4 en Large 4 nemen het over, waarbij Medium 3.5 alleen dient als overgangsstap. Tot slot is redeneren gerechtvaardigd waar paden te verkennen zijn en fouten te vangen (wiskunde, code, beslissingen), en het moet altijd gemeten worden: kwaliteit, tokens, latentie.

Belangrijkste punten

  • Twee draaiknoppen: het model (Small 4, Large 4) en het reasoning_effort-niveau
  • Small 4 in none voor eenvoudige taken, in high voor meerstaps; Large 4 voor de moeilijkste gevallen
  • Bereken elke instelling op basis van usage en officiële tarieven voordat u schaalt
  • Een router reserveert redeneren voor queries die er baat bij hebben
  • In productie: gedateerde identificatoren, gebruikslogging, fallback van Large 4 naar Small 4

Test uw kennis

Vijf vragen om de essentie van de cursus te valideren.

1. Welke reasoning_effort-waarden accepteert Mistral Large 4, en welke wijst het af?

Antwoord: low, medium en high (documentatie raadt high aan als startpunt). Het wijst none af: het niveau dat voorheen zo heette in de preview, heet nu low.

2. Waar bevindt de denktekst zich in een antwoord met redeneren?

Antwoord: In een ThinkChunk (type thinking) binnen de lijst message.content. Het veld thinking is zelf een lijst van TextChunk-objecten, waaruit u het veld text leest. Het definitieve antwoord staat in een TextChunk op het hoogste niveau.

3. Wat moet u terugplaatsen in de geschiedenis van een gesprek met meerdere beurten in Chat Completions?

Antwoord: Het volledige bericht van de assistent, inclusief denkfragmenten. Het verwijderen van het denken bespaart tokens, maar verslechtert de kwaliteit van daaropvolgende beurten aanzienlijk.

4. Uw code roept nog steeds magistral-medium-latest aan: wat moet u doen?

Antwoord: Migreer onmiddellijk, aangezien Magistral op 31 juli 2026 uit dienst is genomen. Richt u op Small 4 als de kwaliteit volstaat, anders Large 4 met reasoning_effort="high"; Medium 3.5, de aangewezen vervanger, is zelf verouderd tot 30 april 2027. Verwijder prompt_mode en de denksjabloon uit systeemprompts.

5. Hoe stelt u reasoning_effort in bij een Mistral-agent?

Antwoord: In het veld completion_args van de agent, bijvoorbeeld completion_args={"reasoning_effort": "high"}. Gebruik bij de Conversations API hetzelfde veld bij elke start of append.