Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Streaming af svar i Python

Lektion 6 af 14 Opdateret 2. november 2026 Udvikler
På denne side
  1. Hvilket problem streaming løser
  2. Brug af chat.stream()
  3. Hvad en bid indeholder
  4. Visning og lagring samtidig
  5. Den asynkrone variant
  6. Hvornår du skal streame, og hvornår du skal undlade det
  7. Vigtige pointer

Hvilket problem streaming løser

Med chat.complete() venter du på, at modellen genererer hele sit svar, før du modtager et eneste tegn. Ved korte svar bemærkes denne forsinkelse ikke. Men ved detaljerede analyser, lange kodestykker eller ræsonnementer over flere afsnit stirrer brugeren på en tom skærm i flere sekunder. I en chat-grænseflade kan selv få sekunders stilhed få applikationen til at virke frosset.

Streaming ændrer denne oplevelse: Svaret ankommer inkrementelt, bit for bit, og vises løbende, præcis som du kender det fra chat-grænseflader. Den samlede genereringstid falder ikke med et millisekund, men det første ord vises næsten øjeblikkeligt. Det er denne indledende ventetid, brugeren faktisk mærker.

Brug af chat.stream()

Mistral SDK V2 eksponerer metoden chat.stream(), som returnerer en iterator af bidder i stedet for et enkelt objekt:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {
            "role": "user",
            "content": "Describe the steps to deploy a Flask application on a Linux server."
        }
    ]
)

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        print(content, end="", flush=True)

# Final newline
print()

To detaljer gør hele forskellen i denne løkke. Tjekket if content er afgørende, fordi nogle bidder ankommer uden tekst og ellers ville udskrive None. Og flush=True tvinger Python til at skrive straks til outputtet i stedet for at vente på, at bufferen fyldes. Uden dette ville al teksten dukke op i én blok til sidst, hvilket fuldstændigt ville ophæve den fordel, du søger.

Aspektchat.complete()chat.stream()
ReturværdiKomplet objektIterator af bidder
Oplevet latensHøj (samlet ventetid)Lav (hurtigt første token)
Tekstadgangresponse.choices[0].message.contentchunk.data.choices[0].delta.content
Token-forbrugTilgængeligt i svaretTilgængeligt i sidste bid

Hvad en bid indeholder

Hver bid bærer på en delta, hvilket betyder et fragment af svaret under opbygning. Ved at inspicere den får du adgang til både teksten og metadata for slutningen af strømmen:

for chunk in stream:
    delta = chunk.data.choices[0].delta

    # Text content (can be None for some chunks)
    text = delta.content

    # Stop reason (None except for the last chunk)
    end = chunk.data.choices[0].finish_reason

    if text:
        print(text, end="", flush=True)

    if end:
        print(f"\n[Stream end: {end}]")

Forløbet følger altid samme koreografi: Den første bid indeholder normalt rollen assistant, mellemliggende bidder leverer teksten i små stykker, og den sidste giver finish_reason. Du afgør, om svaret sluttede normalt eller blev afbrudt af max_tokens, ved at tjekke denne sidste bid.

Visning og lagring samtidig

Streaming har en ulempe: Teksten ruller forbi, men du beholder den ikke noget sted. Alligevel har en applikation i den virkelige verden ofte brug for at arkivere svaret i en database til samtalehistorik. Løsningen er at akkumulere fragmenterne, mens de vises:

import os
from mistralai.client import Mistral

client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

stream = client.chat.stream(
    model="mistral-small-latest",
    messages=[
        {"role": "user", "content": "List five Python web frameworks."}
    ]
)

full_response = []

for chunk in stream:
    content = chunk.data.choices[0].delta.content
    if content:
        full_response.append(content)
        print(content, end="", flush=True)

print()

# The reconstituted full response
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")

Bemærk brugen af en liste efterfulgt af et endeligt "".join() i stedet for streng-konkatenering i hver løkke-iteration. Ved lange svar vil sidstnævnte tilgang kopiere al akkumuleret tekst for hvert modtaget fragment, hvilket er ineffektivt.

Den asynkrone variant

I en webserver – FastAPI, aiohttp – blokerer den synkrone version tråden under hele genereringen og fryser andre igangværende forespørgsler. SDK’et tilbyder derfor chat.stream_async():

import asyncio
import os
from mistralai.client import Mistral

async def generate_response():
    client = Mistral(api_key=os.environ["MISTRAL_API_KEY"])

    stream = await client.chat.stream_async(
        model="mistral-small-latest",
        messages=[
            {"role": "user", "content": "Explain the concept of a coroutine in Python."}
        ]
    )

    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            print(content, end="", flush=True)

    print()

asyncio.run(generate_response())

Strukturen er identisk med den synkrone version, bortset fra nøgleordene await og async for. Så snart din kode kører i en webserver, er det denne variant, du skal bruge.

Hvornår du skal streame, og hvornår du skal undlade det

I en chat-grænseflade er streaming altid obligatorisk: Læsekomforten står på spil. På backend-API-siden er det værd at aktivere, så længe din frontend kan konsumere Server-Sent Events. For ethvert svar, der er længere end et par sætninger, berettiger gevinsten i oplevet latens den ekstra kompleksitet. Omvendt, i et batch-script, der behandler tusind dokumenter og skriver resultater til en fil, er der ingen, der kigger på skærmen: chat.complete() forbliver enklere og fuldt ud tilstrækkelig.

Vigtige pointer

  • chat.stream() returnerer en iterator af bidder til progressiv visning
  • Indholdet findes i chunk.data.choices[0].delta.content
  • Brug flush=True i dine print()-kald for visning i realtid
  • Rekonstruer det fulde svar ved at akkumulere bidder, hvis det er nødvendigt
  • Den asynkrone version chat.stream_async() anbefales til webapplikationer