Tänkblokkar: läsa modellens resonemang
På denna sida
Lektionen omskriven den 2 november 2026 baserat på avsnittet Handling thinking chunks i Mistrals dokumentation. Den tidigare versionen läste resonemanget från ett
text-fält i tänkblokken: detta fält finns inte; resonemang är en lista med textblock.
Två svarsformer
Med reasoning_effort="high" är fältet message.content i ett svar inte längre en sträng utan en lista med block. Med reasoning_effort="none" är det återigen en vanlig sträng, utan spår av resonemang. Robust kod hanterar alltid båda formerna: det är den gyllene regeln i denna lektion.
Anatomin hos ett tänkblok
Två blocktyper förekommer i listan:
ThinkChunk(type: "thinking") bär på resonemangsspåret. Dess fältthinkingär i sig en lista medTextChunk-fragment;TextChunk(type: "text") bär på det slutgiltiga svaret, i sitt fälttext.
Här är strukturen för ett svar från Mistral Small 4, hämtat från det officiella exemplet (texter förkortade):
{
"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öljer denna struktur exakt: ThinkChunk.thinking innehåller resonemangsblocken, och varje TextChunk exponerar sitt innehåll via .text.
Parsa svaret i Python
Den officiella koden skiljer på block med isinstance, efter att ha uteslutit fallet med en vanlig sträng:
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 vill du ha en funktion som returnerar resonemang och svar separat. Vi kallar den separate och återanvänder den senare i kursen:
from mistralai.client.models import TextChunk, ThinkChunk
def separate(content):
"""Returnera (resonemang, svar) för innehåll som är antingen en sträng eller en lista med block."""
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)
Visa resonemang i ett gränssnitt
Att separera de två delarna låter dig bestämma vad användaren ser. Tre vanliga tillvägagångssätt:
- Dölj resonemanget och visa endast svaret, för en kundvänd assistent;
- Fäll ihop resonemanget i ett block som användaren kan öppna om hen vill, för ett expertverktyg;
- Visa hela resonemanget, för en pedagogisk handledare där processen är lika viktig 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 ett riktigt projekt måste du escape:a texten innan du infogar den i HTML (till exempel med html.escape): både resonemang och svar är genererad text, inte betrodd markup.
Strömning i tre faser
Vid strömning ändrar delta.content form när svaret byggs upp:
- Resonemangsfas:
delta.contentär en lista som innehåller ettThinkChunk; - Övergång: en enda lista som innehåller både det avslutande
ThinkChunkoch det förstaTextChunk; - Svarsfas:
delta.contentär en vanlig sträng.
Följande kod, anpassad från det officiella exemplet, visar båda faserna genom att spåra en statusflagga:
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): # svarsfas
if in_reasoning:
print("\n--- end of reasoning ---")
in_reasoning = False
print(delta, end="", flush=True)
continue
for chunk in delta: # resonemangsfas och övergång
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)
Strömning förändrar upplevelsen: istället för att vänta på att en lång resonemangsprocess ska avslutas framför en fryst skärm, ser användaren modellen arbeta, eller åtminstone en aktivitetsindikator om du väljer att dölja resonemanget.
Viktiga punkter
contentär en sträng mednone, en lista med block medhigh: hantera alltid bådaThinkChunk.thinkingär en lista medTextChunk; det slutgiltiga svaret finns i ettTextChunkpå toppnivå- En funktion
separatesom returnerar (resonemang, svar) förenklar resten av din kod - Vid strömning: resonemangslista, blandad övergång, sedan svarsträngar
- Escape:a både resonemang och svar innan du visar dem