Lähe põhisisu juurde
Eesti— Vali keel
Menüü

Mõtlemisplokid: mudeli arutluskäigu lugemine

Õppetund 3 / 12 Värskendatud 2. november 2026 Arendajatele
Sellel lehel
  1. Kaks vastuse kuju
  2. Mõtlemisploki anatoomia
  3. Vastuse parsimine Pythonis
  4. Arutluskäigu kuvamine liideses
  5. Voogedastus kolmes faasis
  6. Peamised punktid

Õppetund kirjutati ümber 2. novembril 2026, tuginedes Mistrali dokumentatsiooni jaotisele Handling thinking chunks. Eelmises versioonis loeti arutluskäiku väljalt text mõtlemisplokis: sellist välja ei eksisteeri; arutluskäik on tekstiplokkide loend.

Kaks vastuse kuju

Kui reasoning_effort="high", ei ole vastuse väli message.content enam string, vaid plokkide loend. Kui reasoning_effort="none", on see taas tavaline string ilma igasuguse arutluskäigu jäljeta. Tugev kood käsitleb alati mõlemat kuju: see on selle tunni kuldreegel.

Mõtlemisploki anatoomia

Loendis ilmnevad kahte tüüpi plokid:

  • ThinkChunk (type: "thinking") kannab arutluskäigu jälge. Selle väli thinking on omakorda loend TextChunk fragmentidest;
  • TextChunk (type: "text") kannab lõplikku vastust oma väljas text.

Siin on Mistral Small 4 vastuse kuju, võetud ametlikust näitest (tekstid lühendatud):

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

Pythoni SDK objektimudel järgib seda struktuuri täpselt: ThinkChunk.thinking hoiab arutlusplokke ja iga TextChunk avaldab oma sisu .text kaudu.

Vastuse parsimine Pythonis

Ametlik kood eristab plokke isinstance abil, pärast seda, kui on välistatud tavalise stringi juhtum:

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)

Rakenduses soovid tõenäoliselt funktsiooni, mis tagastab arutluskäigu ja vastuse eraldi. Kutsume seda separate ja kasutame seda hiljem kursusel uuesti:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Tagasta (arutluskäik, vastus) sisule, mis on kas string või plokkide loend."""
    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)

Arutluskäigu kuvamine liideses

Kahe osa eraldamine võimaldab sul otsustada, mida kasutaja näeb. Kolm levinud lähenemist:

  • Peida arutluskäik ja näita ainult vastust, tarbijale suunatud assistendi puhul;
  • Ahenda arutluskäik plokiks, mida kasutaja saab soovi korral avada, eksperditööriista puhul;
  • Näita kogu arutluskäiku, haridusliku juhendaja puhul, kus protsess on sama oluline kui tulemus.
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

Reaalses projektis pead teksti enne HTML-i sisestamist kodeerima (näiteks html.escape abil): nii arutluskäik kui ka vastus on genereeritud tekst, mitte usaldusväärne märgistus.

Voogedastus kolmes faasis

Voogedastuse korral muudab delta.content kuju vastuse laienedes:

  1. Arutlusfaas: delta.content on loend, mis sisaldab ThinkChunk-i;
  2. Üleminek: üksik loend, mis sisaldab nii sulguvat ThinkChunk-i kui ka esimest TextChunk-i;
  3. Vastusefaas: delta.content on tavaline string.

Järgnev kood, kohandatud ametlikust näitest, kuvab mõlemat faasi, jälgides olekulippu:

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)

Voogedastus muudab kasutajakogemust: pikka arutlusprotsessi oodates ei pea kasutaja vaatama külmutatud ekraani, vaid näeb mudelit töötamas või vähemalt tegevusindikaatorit, kui otsustad arutluskäigu peita.

Peamised punktid

  • content on string väärtusega none ja plokkide loend väärtusega high: käsitle alati mõlemat
  • ThinkChunk.thinking on loend TextChunk-e; lõplik vastus asub ülemise taseme TextChunk-is
  • Funktsioon separate, mis tagastab (arutluskäik, vastus), lihtsustab ülejäänud koodi
  • Voogedastusel: arutlusloend, segatud üleminek, seejärel vastusestringid
  • Kodeeri nii arutluskäik kui ka vastus enne nende kuvamist