Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Tänkblokkar: läsa modellens resonemang

Lektion 3 av 12 Uppdaterad 2 november 2026 Utvecklare
På denna sida
  1. Två svarsformer
  2. Anatomin hos ett tänkblok
  3. Parsa svaret i Python
  4. Visa resonemang i ett gränssnitt
  5. Strömning i tre faser
  6. Viktiga punkter

Lektionen omskriven den 2 november 2026 baserat på avsnittet Handling thinking chunks i Mistrals dokumentation. Den tidigare versionen läste resonemanget från ett text-fält i tänkblokken: detta fält finns inte; resonemang är en lista med textblock.

Två svarsformer

Med reasoning_effort="high" är fältet message.content i ett svar inte längre en sträng utan en lista med block. Med reasoning_effort="none" är det återigen en vanlig sträng, utan spår av resonemang. Robust kod hanterar alltid båda formerna: det är den gyllene regeln i denna lektion.

Anatomin hos ett tänkblok

Två blocktyper förekommer i listan:

  • ThinkChunk (type: "thinking") bär på resonemangsspåret. Dess fält thinking är i sig en lista med TextChunk-fragment;
  • TextChunk (type: "text") bär på det slutgiltiga svaret, i sitt fält text.

Här är strukturen för ett svar från Mistral Small 4, hämtat från det officiella exemplet (texter förkortade):

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

Objektmodellen i Python SDK följer denna struktur exakt: ThinkChunk.thinking innehåller resonemangsblocken, och varje TextChunk exponerar sitt innehåll via .text.

Parsa svaret i Python

Den officiella koden skiljer på block med isinstance, efter att ha uteslutit fallet med en vanlig sträng:

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)

I en applikation vill du ha en funktion som returnerar resonemang och svar separat. Vi kallar den separate och återanvänder den senare i kursen:

from mistralai.client.models import TextChunk, ThinkChunk

def separate(content):
    """Returnera (resonemang, svar) för innehåll som är antingen en sträng eller en lista med block."""
    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)

Visa resonemang i ett gränssnitt

Att separera de två delarna låter dig bestämma vad användaren ser. Tre vanliga tillvägagångssätt:

  • Dölj resonemanget och visa endast svaret, för en kundvänd assistent;
  • Fäll ihop resonemanget i ett block som användaren kan öppna om hen vill, för ett expertverktyg;
  • Visa hela resonemanget, för en pedagogisk handledare där processen är lika viktig som resultatet.
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

I ett riktigt projekt måste du escape:a texten innan du infogar den i HTML (till exempel med html.escape): både resonemang och svar är genererad text, inte betrodd markup.

Strömning i tre faser

Vid strömning ändrar delta.content form när svaret byggs upp:

  1. Resonemangsfas: delta.content är en lista som innehåller ett ThinkChunk;
  2. Övergång: en enda lista som innehåller både det avslutande ThinkChunk och det första TextChunk;
  3. Svarsfas: delta.content är en vanlig sträng.

Följande kod, anpassad från det officiella exemplet, visar båda faserna genom att spåra en statusflagga:

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):            # svarsfas
        if in_reasoning:
            print("\n--- end of reasoning ---")
            in_reasoning = False
        print(delta, end="", flush=True)
        continue
    for chunk in delta:                   # resonemangsfas och övergång
        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)

Strömning förändrar upplevelsen: istället för att vänta på att en lång resonemangsprocess ska avslutas framför en fryst skärm, ser användaren modellen arbeta, eller åtminstone en aktivitetsindikator om du väljer att dölja resonemanget.

Viktiga punkter

  • content är en sträng med none, en lista med block med high: hantera alltid båda
  • ThinkChunk.thinking är en lista med TextChunk; det slutgiltiga svaret finns i ett TextChunk på toppnivå
  • En funktion separate som returnerar (resonemang, svar) förenklar resten av din kod
  • Vid strömning: resonemangslista, blandad övergång, sedan svarsträngar
  • Escape:a både resonemang och svar innan du visar dem