Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Tankeblokke: læs modellens ræsonnement

Lektion 3 af 12 Opdateret 2. november 2026 Udvikler
På denne side
  1. To responsformer
  2. Anatomien af en tankeblok
  3. Parsning af svaret i Python
  4. Visning af ræsonnement i en grænseflade
  5. Streaming i tre faser
  6. Vigtige pointer

Lektionen er omskrevet den 2. november 2026 baseret på afsnittet Handling thinking chunks i Mistral-dokumentationen. Den tidligere version læste ræsonnementet fra et text-felt i tankeblokken: dette felt eksisterer ikke; ræsonnement er en liste over tekstblokke.

To responsformer

Med reasoning_effort="high" er feltet message.content i et svar ikke længere en streng, men en liste over blokke. Med reasoning_effort="none" er det igen en almindelig streng uden spor af ræsonnement. Robust kode håndterer altid begge former: det er guldreglen i denne lektion.

Anatomien af en tankeblok

To bloktyper optræder i listen:

  • ThinkChunk (type: "thinking") bærer sporet af ræsonnementet. Dets thinking-felt er selv en liste over TextChunk-fragmenter;
  • TextChunk (type: "text") bærer det endelige svar i sit text-felt.

Her er strukturen af et svar fra Mistral Small 4, hentet fra det officielle eksempel (tekster er forkortet):

{
  "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..."}
      ]
    }
  }]
}

Objektmodellen i Python SDK følger nøjagtigt denne struktur: ThinkChunk.thinking indeholder ræsonnementsblokkene, og hver TextChunk eksponerer sit indhold via .text.

Parsning af svaret i Python

Den officielle kode skelner mellem blokke med isinstance, efter at have udelukket tilfældet med en almindelig streng:

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)

I en applikation vil du have en funktion, der returnerer ræsonnement og svar separat. Vi kalder den separate og genbruger den senere i kurset:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Returner (ræsonnement, svar) for indhold, der enten er en streng eller en liste over blokke."""
    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)

Visning af ræsonnement i en grænseflade

Adskillelsen af de to dele giver dig mulighed for at beslutte, hvad brugeren ser. Tre almindelige tilgange:

  • Skjul ræsonnementet og vis kun svaret, til en kundeorienteret assistent;
  • Fold ræsonnementet sammen i en blok, som brugeren kan åbne, hvis de ønsker det, til et ekspertværktøj;
  • Vis hele ræsonnementet, til en undervisningsmæssig tutor, hvor processen er lige så vigtig som resultatet.
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

I et rigtigt projekt skal du escape teksten, før du indsætter den i HTML (for eksempel med html.escape): både ræsonnement og svar er genereret tekst, ikke betroet markup.

Streaming i tre faser

Ved streaming ændrer delta.content form, efterhånden som svaret udfoldes:

  1. Ræsonnementsfase: delta.content er en liste, der indeholder en ThinkChunk;
  2. Overgang: en enkelt liste, der indeholder både den afsluttende ThinkChunk og den første TextChunk;
  3. Svarfase: delta.content er en almindelig streng.

Følgende kode, tilpasset fra det officielle eksempel, viser begge faser ved at spore et statusflag:

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):            # svarfase
        if in_reasoning:
            print("\n--- end of reasoning ---")
            in_reasoning = False
        print(delta, end="", flush=True)
        continue
    for chunk in delta:                   # ræsonnementsfase og 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)

Streaming ændrer oplevelsen: i stedet for at vente på, at en lang ræsonnementsproces bliver færdig foran en frossen skærm, ser brugeren modellen arbejde, eller i det mindste en aktivitetsindikator, hvis du vælger at skjule ræsonnementet.

Vigtige pointer

  • content er en streng med none, en liste over blokke med high: håndter altid begge
  • ThinkChunk.thinking er en liste over TextChunk; det endelige svar findes i en TextChunk på øverste niveau
  • En separate-funktion, der returnerer (ræsonnement, svar), forenkler resten af din kode
  • Ved streaming: ræsonnementsliste, blandet overgang, derefter svar-strenge
  • Escape både ræsonnement og svar, før du viser dem