Streaming af svar i Python
På denne side
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.
| Aspekt | chat.complete() | chat.stream() |
|---|---|---|
| Returværdi | Komplet objekt | Iterator af bidder |
| Oplevet latens | Høj (samlet ventetid) | Lav (hurtigt første token) |
| Tekstadgang | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Token-forbrug | Tilgængeligt i svaret | Tilgæ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=Truei dineprint()-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