Tankeblokke: læs modellens ræsonnement
På denne side
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. Detsthinking-felt er selv en liste overTextChunk-fragmenter;TextChunk(type: "text") bærer det endelige svar i sittext-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:
- Ræsonnementsfase:
delta.contenter en liste, der indeholder enThinkChunk; - Overgang: en enkelt liste, der indeholder både den afsluttende
ThinkChunkog den førsteTextChunk; - Svarfase:
delta.contenter 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
contenter en streng mednone, en liste over blokke medhigh: håndter altid beggeThinkChunk.thinkinger en liste overTextChunk; det endelige svar findes i enTextChunkpå ø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