Přejít na hlavní obsah
Čeština— Vyberte jazyk
Menu

Bloky uvažování: čtení úvah modelu

Lekce 3 z 12 Aktualizováno 2. listopadu 2026 Vývojář
Na této stránce
  1. Dva tvary odpovědí
  2. Anatomie bloku uvažování
  3. Parsování odpovědi v Pythonu
  4. Zobrazení úvah v rozhraní
  5. Streamování ve třech fázích
  6. Klíčové poznatky

Lekce přepsána 2. listopadu 2026 na základě sekce Handling thinking chunks z dokumentace Mistral. Předchozí verze četla úvahy z pole text v bloku uvažování: toto pole neexistuje; úvahy jsou seznamem textových bloků.

Dva tvary odpovědí

Při nastavení reasoning_effort="high" není pole message.content v odpovědi řetězcem, ale seznamem bloků. Při reasoning_effort="none" je to opět obyčejný řetězec bez jakékoli stopy po úvahách. Robustní kód musí vždy zvládat oba tvary: to je zlaté pravidlo této lekce.

Anatomie bloku uvažování

V seznamu se objevují dva typy bloků:

  • ThinkChunk (type: "thinking") nese stopu úvah. Jeho pole thinking je samo o sobě seznamem fragmentů TextChunk;
  • TextChunk (type: "text") nese konečnou odpověď ve svém poli text.

Zde je tvar odpovědi modelu Mistral Small 4, převzatý z oficiálního příkladu (texty zkráceny):

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

Objektový model Python SDK přesně odpovídá této struktuře: ThinkChunk.thinking obsahuje bloky úvah a každý TextChunk zpřístupňuje svůj obsah přes .text.

Parsování odpovědi v Pythonu

Oficiální kód rozlišuje bloky pomocí isinstance poté, co vyloučí případ obyčejného řetězce:

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)

V aplikaci budeš pravděpodobně chtít funkci, která vrátí úvahy a odpověď odděleně. Nazveme ji separate a později v kurzu ji znovu použijeme:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Vrátí (úvahy, odpověď) pro obsah, který je buď řetězec, nebo seznam bloků."""
    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)

Zobrazení úvah v rozhraní

Oddělení obou částí ti umožňuje rozhodnout, co uživatel uvidí. Tři běžné přístupy:

  • Skrýt úvahy a zobrazit pouze odpověď, vhodné pro asistenta určeného koncovým uživatelům;
  • Sbalit úvahy do bloku, který si uživatel může v případě zájmu rozbalit, vhodné pro expertní nástroje;
  • Zobrazit celé úvahy, vhodné pro vzdělávacího tutora, kde je proces stejně důležitý jako výsledek.
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

V reálném projektu musíš text před vložením do HTML escapovat (například pomocí html.escape): úvahy i odpověď jsou generovaný text, nikoli důvěryhodné markup.

Streamování ve třech fázích

Při streamování mění delta.content svůj tvar, jak odpověď postupně vzniká:

  1. Fáze úvah: delta.content je seznam obsahující ThinkChunk;
  2. Přechod: jediný seznam obsahující jak uzavírající ThinkChunk, tak první TextChunk;
  3. Fáze odpovědi: delta.content je obyčejný řetězec.

Následující kód, upravený z oficiálního příkladu, zobrazuje obě fáze sledováním stavového příznaku:

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):            # answer phase
        if in_reasoning:
            print("\n--- end of reasoning ---")
            in_reasoning = False
        print(delta, end="", flush=True)
        continue
    for chunk in delta:                   # reasoning phase and transition
        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)

Streamování mění zážitek: místo čekání na dokončení dlouhého procesu uvažování před zamrzlou obrazovkou vidí uživatel model při práci, nebo alespoň indikátor aktivity, pokud se rozhodneš úvahy skrýt.

Klíčové poznatky

  • content je řetězec při none, seznam bloků při high: vždy ošetři oba případy
  • ThinkChunk.thinking je seznam objektů TextChunk; konečná odpověď sídlí v TextChunk na nejvyšší úrovni
  • Funkce separate, která vrací (úvahy, odpověď), zjednodušuje zbytek tvého kódu
  • Při streamování: seznam úvah, smíšený přechod, poté řetězce odpovědí
  • Před zobrazením escapuj úvahy i odpověď