Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Gondolati blokkok: a modell érvelésének olvasása

3. lecke 12 közül Frissítve 2026. november 2. Fejlesztő
Ezen az oldalon
  1. Két válaszforma
  2. Egy gondolati blokk felépítése
  3. A válasz feldolgozása Pythonban
  4. Az érvelés megjelenítése a felületen
  5. Streamelés három fázisban
  6. Főbb megállapítások

A leckét 2026. november 2-án írtuk át a Mistral dokumentáció Handling thinking chunks szakasza alapján. A korábbi verzió a gondolati blokk text mezőjéből olvasta az érvelést: ez a mező nem létezik; az érvelés szövegblokkok listája.

Két válaszforma

Ha reasoning_effort="high", a válasz message.content mezője már nem sztring, hanem blokkok listája. Ha reasoning_effort="none", ismét egyszerű sztringről van szó, az érvelés nyoma nélkül. A robusztus kód mindig mindkét formátumot kezeli: ez ennek a leckének az aranyszabálya.

Egy gondolati blokk felépítése

Kétféle blokk jelenik meg a listában:

  • A ThinkChunk (type: "thinking") hordozza az érvelési nyomvonalat. A thinking mezője maga is TextChunk fragmentumok listája;
  • A TextChunk (type: "text") hordozza a végső választ a text mezőjében.

Íme egy Mistral Small 4 válasz felépítése, a hivatalos példából véve (a szövegek rövidítve):

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

A Python SDK objektummodellje pontosan ezt a struktúrát követi: a ThinkChunk.thinking tartalmazza az érvelési blokkokat, míg minden TextChunk a .text attribútumán keresztül teszi elérhetővé a tartalmát.

A válasz feldolgozása Pythonban

A hivatalos kód az isinstance segítségével különbözteti meg a blokkokat, miután kizárta az egyszerű sztring esetét:

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)

Egy alkalmazásban érdemes olyan függvényt írnod, amely különválasztva adja vissza az érvelést és a választ. Ezt separate-nek nevezzük el, és később újra felhasználjuk a tanfolyamon:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Visszaadja az (érvelés, válasz) párost olyan tartalom esetén, amely vagy sztring, vagy blokkok listája."""
    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)

Az érvelés megjelenítése a felületen

A két rész szétválasztása lehetővé teszi, hogy eldöntsd, mit lát a felhasználó. Három gyakori megközelítés létezik:

  • Elrejteni az érvelést, és csak a választ megjeleníteni, egy fogyasztóknak szánt asszisztens esetén;
  • Összecsukható blokkba helyezni az érvelést, amelyet a felhasználó igény szerint kibonthat, szakmai eszközök esetében;
  • Teljes egészében megjeleníteni az érvelést, olyan oktató tutoroknál, ahol a folyamat ugyanolyan fontos, mint az eredmény.
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

Valós projektekben mindig végezz el escape-elést a szövegen, mielőtt HTML-be illesztenéd (például a html.escape használatával): mind az érvelés, mind a válasz generált szöveg, nem megbízható markup.

Streamelés három fázisban

Streamelés közben a delta.content alakja a válasz kibontakozása során változik:

  1. Érvelési fázis: a delta.content egy lista, amely egy ThinkChunk elemet tartalmaz;
  2. Átmenet: egyetlen lista, amely egyszerre tartalmazza a lezáró ThinkChunk-ot és az első TextChunk-ot;
  3. Válasz fázis: a delta.content egyszerű sztring.

Az alábbi kód, amely a hivatalos példán alapul, egy állapotjelző követésével jeleníti meg mindkét fázist:

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)

A streamelés megváltoztatja a felhasználói élményt: ahelyett, hogy a felhasználó egy befagyott képernyő előtt várna a hosszú érvelési folyamat végére, láthatja, ahogy a modell dolgozik, vagy legalábbis egy aktivitásjelzőt, ha úgy döntesz, hogy elrejted az érvelést.

Főbb megállapítások

  • A content sztring, ha none, és blokkok listája, ha high: mindig kezeld mindkettőt
  • A ThinkChunk.thinking egy TextChunk-okból álló lista; a végső válasz egy felső szintű TextChunk-ban található
  • Egy separate függvény, amely visszaadja az (érvelés, válasz) párost, leegyszerűsíti a kód többi részét
  • Streamelésnél: érvelési lista, vegyes átmenet, majd válasz sztringek
  • Mind az érvelést, mind a választ végezd el escape-eléssel, mielőtt megjeleníted őket