Salt la conținutul principal
Română— Alege o limbă
Meniu

Blocuri de raționament: citirea gândirii modelului

Lecția 3 din 12 Actualizată 2 noiembrie 2026 Dezvoltator
Pe această pagină
  1. Două forme de răspuns
  2. Anatomia unui bloc de gândire
  3. Analiza răspunsului în Python
  4. Afișarea raționamentului într-o interfață
  5. Streaming în trei faze
  6. Puncte cheie

Lecție rescrisă la 2 noiembrie 2026 pe baza secțiunii Handling thinking chunks din documentația Mistral. Versiunea anterioară citea raționamentul dintr-un câmp text în blocul de gândire: acel câmp nu există; raționamentul este o listă de blocuri text.

Două forme de răspuns

Cu reasoning_effort="high", câmpul message.content al unui răspuns nu mai este un șir de caractere, ci o listă de blocuri. Cu reasoning_effort="none", acesta revine la un șir simplu, fără nicio urmă de raționament. Un cod robust gestionează întotdeauna ambele forme: aceasta este regula de aur a acestei lecții.

Anatomia unui bloc de gândire

În listă apar două tipuri de blocuri:

  • ThinkChunk (type: "thinking") poartă urma raționamentului. Câmpul său thinking este el însuși o listă de fragmente TextChunk;
  • TextChunk (type: "text") poartă răspunsul final, în câmpul său text.

Iată structura unui răspuns Mistral Small 4, preluată din exemplul oficial (texte prescurtate):

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

Modelul de obiecte din SDK-ul Python urmează exact această structură: ThinkChunk.thinking conține blocurile de raționament, iar fiecare TextChunk își expune conținutul prin .text.

Analiza răspunsului în Python

Codul oficial distinge blocurile folosind isinstance, după ce exclude cazul șirului simplu:

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)

Într-o aplicație, veți dori o funcție care returnează separat raționamentul și răspunsul. O vom numi separate și o vom reutiliza ulterior în curs:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Returnează (raționament, răspuns) pentru un conținut care este fie un șir, fie o listă de blocuri."""
    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)

Afișarea raționamentului într-o interfață

Separarea celor două părți vă permite să decideți ce vede utilizatorul. Trei abordări comune:

  • Ascundeți raționamentul și afișați doar răspunsul, pentru un asistent orientat către consumator;
  • Restrângeți raționamentul într-un bloc pe care utilizatorul îl poate deschide dacă dorește, pentru un instrument destinat experților;
  • Afișați întregul raționament, pentru un tutore educațional unde procesul contează la fel de mult ca rezultatul.
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

Într-un proiect real, trebuie să scăpați textul înainte de a-l insera în HTML (de exemplu, cu html.escape): atât raționamentul, cât și răspunsul sunt text generat, nu markup de încredere.

Streaming în trei faze

În modul streaming, delta.content își schimbă forma pe măsură ce răspunsul se desfășoară:

  1. Faza de raționament: delta.content este o listă conținând un ThinkChunk;
  2. Tranziția: o singură listă conținând atât ThinkChunk-ul de închidere, cât și primul TextChunk;
  3. Faza de răspuns: delta.content este un șir simplu.

Următorul cod, adaptat din exemplul oficial, afișează ambele faze urmărind un indicator de stare:

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)

Streaming-ul schimbă experiența: în loc să așteptați ca un proces lung de raționament să se termine în fața unui ecran blocat, utilizatorul vede modelul lucrând sau, cel puțin, un indicator de activitate dacă alegeți să ascundeți raționamentul.

Puncte cheie

  • content este un șir cu none, o listă de blocuri cu high: gestionați întotdeauna ambele cazuri
  • ThinkChunk.thinking este o listă de TextChunk; răspunsul final se află într-un TextChunk de nivel superior
  • O funcție separate care returnează (raționament, răspuns) simplifică restul codului dumneavoastră
  • În streaming: listă de raționament, tranziție mixtă, apoi șiruri de răspuns
  • Scăpați atât raționamentul, cât și răspunsul înainte de a le afișa