Ga naar hoofdinhoud
Nederlands— Kies een taal
Menu

Denkbrokken: de redenering van het model lezen

Les 3 van 12 Bijgewerkt op 2 november 2026 Ontwikkelaar
Op deze pagina
  1. Twee responsvormen
  2. Anatomie van een denkbrok
  3. De respons parseren in Python
  4. Redenering weergeven in een interface
  5. Streamen in drie fasen
  6. Belangrijkste punten

Les herschreven op 2 november 2026 op basis van de sectie Handling thinking chunks uit de Mistral-documentatie. De vorige versie las de redenering uit een text-veld in de denkbrok: dat veld bestaat niet; redenering is een lijst met tekstbrokken.

Twee responsvormen

Met reasoning_effort="high" is het veld message.content van een respons geen string meer, maar een lijst van brokken. Met reasoning_effort="none" is het weer een gewone string, zonder enig spoor van redenering. Robuuste code behandelt altijd beide vormen: dat is de gouden regel van deze les.

Anatomie van een denkbrok

Er verschijnen twee soorten brokken in de lijst:

  • ThinkChunk (type: "thinking") bevat het redeneerspoor. Het veld thinking is zelf een lijst van TextChunk-fragmenten;
  • TextChunk (type: "text") bevat het definitieve antwoord in het veld text.

Hier is de structuur van een Mistral Small 4-respons, overgenomen uit het officiële voorbeeld (teksten ingekort):

{
  "model": "mistral-small-2603",
  "usage": {"prompt_tokens": 77, "completion_tokens": 1114, "total_tokens": 1191},
  "choices": [{
    "finish_reason": "stop",
    "message": {
      "role": "assistant",
      "content": [
        {"type": "thinking", "thinking": [
          {"type": "text", "text": "Okay, let's try to figure out John's age..."}
        ]},
        {"type": "text", "text": "Let's denote the ages of the sisters as follows..."}
      ]
    }
  }]
}

Het objectmodel van de Python SDK volgt deze structuur exact: ThinkChunk.thinking bevat de redeneerbrokken en elke TextChunk stelt zijn inhoud beschikbaar via .text.

De respons parseren in Python

De officiële code onderscheidt brokken met isinstance, nadat het geval van de gewone string is uitgesloten:

from mistralai.client.models import TextChunk, ThinkChunk

content = chat_response.choices[0].message.content

if isinstance(content, str):          # reasoning_effort="none"
    print(content)
else:
    for chunk in content:
        if isinstance(chunk, ThinkChunk):
            print("--- reasoning ---")
            for inner in chunk.thinking:
                if isinstance(inner, TextChunk):
                    print(inner.text)
            print("--- end of reasoning ---")
        elif isinstance(chunk, TextChunk):
            print(chunk.text)

In een applicatie wilt u waarschijnlijk een functie die redenering en antwoord gescheiden retourneert. We noemen deze separate en gebruiken deze later in de cursus opnieuw:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Retourneert (redenering, antwoord) voor content die een string of een lijst brokken is."""
    if isinstance(content, str):
        return "", content
    reasoning, answer = [], []
    for chunk in content or []:
        if isinstance(chunk, ThinkChunk):
            reasoning.extend(i.text for i in chunk.thinking if isinstance(i, TextChunk))
        elif isinstance(chunk, TextChunk):
            answer.append(chunk.text)
    return "".join(reasoning), "".join(answer)

reasoning, answer = separate(chat_response.choices[0].message.content)

Redenering weergeven in een interface

Door de twee delen te scheiden, bepaalt u wat de gebruiker ziet. Drie veelvoorkomende benaderingen:

  • Verbergen van de redenering en alleen het antwoord tonen, voor een op consumenten gerichte assistent;
  • Samenvouwen van de redenering in een blok dat de gebruiker desgewenst kan openen, voor een experttool;
  • Tonen van de volledige redenering, voor een educatieve tutor waarbij het proces even belangrijk is als het resultaat.
def render_html(content, show_reasoning=False):
    reasoning, answer = separate(content)
    html = f"<div class='answer'>{answer}</div>"
    if show_reasoning and reasoning:
        html = (
            "<details><summary>View model reasoning</summary>"
            f"<pre>{reasoning}</pre></details>" + html
        )
    return html

In een echt project moet u de tekst escaperen voordat u deze in HTML invoegt (bijvoorbeeld met html.escape): zowel redenering als antwoord zijn gegenereerde tekst, geen vertrouwd markup.

Streamen in drie fasen

Bij streamen verandert de vorm van delta.content naarmate de respons zich ontvouwt:

  1. Redeneerfase: delta.content is een lijst die een ThinkChunk bevat;
  2. Overgang: een enkele lijst die zowel de afsluitende ThinkChunk als de eerste TextChunk bevat;
  3. Antwoordfase: delta.content is een gewone string.

De volgende code, aangepast van het officiële voorbeeld, toont beide fasen door een statusvlag bij te houden:

import os
from mistralai.client import Mistral
from mistralai.client.models import TextChunk, ThinkChunk

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

for event in client.chat.stream(
    model="mistral-large-4-0",
    messages=[{"role": "user", "content": "What is 17 × 23?"}],
    reasoning_effort="high",
):
    delta = event.data.choices[0].delta.content
    if not delta:
        continue
    if isinstance(delta, str):            # antwoordfase
        if in_reasoning:
            print("\n--- end of reasoning ---")
            in_reasoning = False
        print(delta, end="", flush=True)
        continue
    for chunk in delta:                   # redeneerfase en overgang
        if isinstance(chunk, ThinkChunk):
            if not in_reasoning:
                print("--- reasoning ---")
                in_reasoning = True
            for inner in chunk.thinking:
                if isinstance(inner, TextChunk):
                    print(inner.text, end="", flush=True)
        elif isinstance(chunk, TextChunk):
            if in_reasoning:
                print("\n--- end of reasoning ---")
                in_reasoning = False
            print(chunk.text, end="", flush=True)

Streamen verandert de ervaring: in plaats van te wachten tot een lang redeneerproces is voltooid terwijl het scherm bevroren lijkt, ziet de gebruiker het model aan het werk, of ten minte een activiteitsindicator als u ervoor kiest de redenering te verbergen.

Belangrijkste punten

  • content is een string bij none, een lijst brokken bij high: behandel altijd beide
  • ThinkChunk.thinking is een lijst van TextChunk; het definitieve antwoord staat in een TextChunk op het hoogste niveau
  • Een separate-functie die (redenering, antwoord) retourneert, vereenvoudigt de rest van uw code
  • Bij streamen: redeneerlijst, gemengde overgang, daarna antwoordstrings
  • Escape zowel redenering als antwoord voordat u ze weergeeft