Przejdź do głównej treści
Polski— Wybierz język
Menu

Bloki myślowe: odczytywanie rozumowania modelu

Lekcja 3 z 12 Zaktualizowano 2 listopada 2026 Programista
Na tej stronie
  1. Dwa kształty odpowiedzi
  2. Anatomia bloku myślowego
  3. Parsowanie odpowiedzi w Pythonie
  4. Wyświetlanie rozumowania w interfejsie
  5. Strumieniowanie w trzech fazach
  6. Kluczowe wnioski

Lekcja przepisana 2 listopada 2026 r. na podstawie sekcji Handling thinking chunks z dokumentacji Mistral. Poprzednia wersja odczytywała rozumowanie z pola text w 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 pole thinking jest samo w sobie listą fragmentów TextChunk;
  • TextChunk (type: "text") przenosi ostateczną odpowiedź w swoim polu text.

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:

  1. Faza rozumowania: delta.content to lista zawierająca ThinkChunk;
  2. Przejście: pojedyncza lista zawierająca zarówno zamykający ThinkChunk, jak i pierwszy TextChunk;
  3. Faza odpowiedzi: delta.content to 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

  • content to ciąg znaków przy none, lista bloków przy high: zawsze obsługuj oba przypadki
  • ThinkChunk.thinking to lista obiektów TextChunk; ostateczna odpowiedź znajduje się w TextChunk najwyższego poziomu
  • Funkcja separate zwracają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