Bloki myślowe: odczytywanie rozumowania modelu
Na tej stronie
Lekcja przepisana 2 listopada 2026 r. na podstawie sekcji Handling thinking chunks z dokumentacji Mistral. Poprzednia wersja odczytywała rozumowanie z pola
textw bloku myślowym: takie pole nie istnieje; rozumowanie jest listą fragmentów tekstowych.
Dwa kształty odpowiedzi
Przy ustawieniu reasoning_effort="high", pole message.content odpowiedzi nie jest już ciągiem znaków, lecz listą bloków. Przy reasoning_effort="none" jest to ponownie zwykły ciąg znaków, bez żadnego śladu rozumowania. Solidny kod musi obsługiwać oba kształty: to złota zasada tej lekcji.
Anatomia bloku myślowego
Na liście pojawiają się dwa typy bloków:
ThinkChunk(type: "thinking") przenosi ślad rozumowania. Jego polethinkingjest samo w sobie listą fragmentówTextChunk;TextChunk(type: "text") przenosi ostateczną odpowiedź w swoim polutext.
Oto kształt odpowiedzi modelu Mistral Small 4, zaczerpnięty z oficjalnego przykładu (teksty skrócone):
{
"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..."}
]
}
}]
}
Model obiektowy Python SDK dokładnie odwzorowuje tę strukturę: ThinkChunk.thinking przechowuje bloki rozumowania, a każdy TextChunk udostępnia swoją zawartość poprzez .text.
Parsowanie odpowiedzi w Pythonie
Oficjalny kod rozróżnia bloki za pomocą isinstance, po wykluczeniu przypadku zwykłego ciągu znaków:
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)
W aplikacji będziesz chciał funkcji, która zwraca rozumowanie i odpowiedź oddzielnie. Nazwiemy ją separate i wykorzystamy później w kursie:
from mistralai.client.models import TextChunk, ThinkChunk
def separate(content):
"""Zwraca (rozumowanie, odpowiedź) dla zawartości, która jest ciągiem lub listą bloków."""
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)
Wyświetlanie rozumowania w interfejsie
Rozdzielenie obu części pozwala Ci zdecydować, co zobaczy użytkownik. Trzy powszechne podejścia:
- Ukryj rozumowanie i pokaż tylko odpowiedź, w przypadku asystenta skierowanego do konsumenta;
- Zwiń rozumowanie do bloku, który użytkownik może otworzyć w razie potrzeby, w narzędziu dla ekspertów;
- Pokaż pełne rozumowanie, w przypadku tutora edukacyjnego, gdzie proces jest równie ważny co wynik.
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
W prawdziwym projekcie musisz zabezpieczyć tekst przed wstawieniem go do HTML (na przykład za pomocą html.escape): zarówno rozumowanie, jak i odpowiedź to tekst generowany, a nie zaufany znacznik.
Strumieniowanie w trzech fazach
W trybie strumieniowym kształt delta.content zmienia się w miarę rozwijania odpowiedzi:
- Faza rozumowania:
delta.contentto lista zawierającaThinkChunk; - Przejście: pojedyncza lista zawierająca zarówno zamykający
ThinkChunk, jak i pierwszyTextChunk; - Faza odpowiedzi:
delta.contentto zwykły ciąg znaków.
Poniższy kod, dostosowany z oficjalnego przykładu, wyświetla obie fazy, śledząc flagę stanu:
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): # faza odpowiedzi
if in_reasoning:
print("\n--- end of reasoning ---")
in_reasoning = False
print(delta, end="", flush=True)
continue
for chunk in delta: # faza rozumowania i przejście
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)
Strumieniowanie zmienia doświadczenie: zamiast czekać na zakończenie długiego procesu rozumowania przed zamarzniętym ekranem, użytkownik widzi model przy pracy lub przynajmniej wskaźnik aktywności, jeśli zdecydujesz się ukryć rozumowanie.
Kluczowe wnioski
contentto ciąg znaków przynone, lista bloków przyhigh: zawsze obsługuj oba przypadkiThinkChunk.thinkingto lista obiektówTextChunk; ostateczna odpowiedź znajduje się wTextChunknajwyższego poziomu- Funkcja
separatezwracająca (rozumowanie, odpowiedź) upraszcza resztę kodu - W strumieniowaniu: lista rozumowania, mieszane przejście, następnie ciągi odpowiedzi
- Zabezpiecz zarówno rozumowanie, jak i odpowiedź przed wyświetleniem