Strömmande svar i Python
På denna sida
Problemet som strömning löser
Med chat.complete() väntar du på att modellen ska generera hela sitt svar innan du får ta del av ett enda tecken. För ett kort svar märks denna fördröjning knappt. Men vid en detaljerad analys, ett långt kodavsnitt eller resonemang över flera stycken får användaren stirra på en tom skärm i flera sekunder. I ett chattgränssnitt kan till och med några sekunders tystnad få applikationen att verka frusen.
Strömning ändar denna upplevelse: svaret anländer inkrementellt, bit för bit, och visas progressivt precis som i de chattgränssnitt du redan känner till. Den totala genereringstiden minskar inte med en millisekund, men det första ordet dyker upp nästan omedelbart. Det är denna initiala fördröjning som användaren faktiskt upplever.
Använda chat.stream()
Mistral SDK V2 exponerar metoden chat.stream(), som returnerar en iterator av bitar istället för ett enskilt 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()
Två detaljer gör hela skillnaden i denna loop. Kontrollen if content är avgörande eftersom vissa bitar anländer utan text och annars skulle skriva ut None. Och flush=True tvingar Python att skriva direkt till utmatningen istället för att vänta på att bufferten fylls. Utan detta skulle all text dyka upp i ett enda block på slutet, vilket helt skulle motverka fördelen du eftersträvar.
| Aspekt | chat.complete() | chat.stream() |
|---|---|---|
| Returvärde | Komplett objekt | Iterator av bitar |
| Upplevd latens | Hög (total väntetid) | Låg (snabbt första token) |
| Textåtkomst | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Tokenanvändning | Tillgänglig i svar | Tillgänglig i sista biten |
Vad en bit innehåller
Varje bit bär på en delta, det vill säga en fragmenterad del av svaret under uppbyggnad. Genom att inspektera den får du tillgång till både texten och metadata för slutet av strömmen:
for chunk in stream:
delta = chunk.data.choices[0].delta
# Textinnehåll (kan vara None för vissa bitar)
text = delta.content
# Stopporsak (None förutom för den sista biten)
end = chunk.data.choices[0].finish_reason
if text:
print(text, end="", flush=True)
if end:
print(f"\n[Stream end: {end}]")
Flödet följer alltid samma koreografi: den första biten innehåller oftast rollen assistant, mellanliggande bitar levererar texten i små portioner, och den sista tillhandahåller finish_reason. Du avgör om svaret avslutades normalt eller kapades av max_tokens genom att kontrollera denna sista bit.
Visa och spara samtidigt
Strömning har en nackdel: texten rullar förbi, men du behåller den inte någonstans. Ändå behöver en verklig applikation ofta arkivera svaret i en databas för konversationshistorik. Lösningen är att ackumulera fragmenten medan du visar dem:
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()
# Det återskapade fullständiga svaret
final_text = "".join(full_response)
print(f"\nTotal length: {len(final_text)} characters")
Notera användningen av en lista följt av en slutgiltig "".join() istället för stringsammanslagning i varje loop-iteration. För ett långt svar kopierar den senare metoden all ackumulerad text för varje mottaget fragment, vilket är ineffektivt.
Den asynkrona varianten
I en webbserver – FastAPI, aiohttp – blockerar den synkrona versionen tråden under hela genereringen och fryser andra pågående förfrågningar. SDK:t tillhandahåller därför 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 är identisk med den synkrona versionen, förutom nyckelorden await och async for. Så snart din kod körs i en webbserver är det denna variant du måste använda.
När du ska strömma och när du ska hoppa över det
I ett chattgränssnitt är strömning alltid obligatorisk: läskomforten står på spel. På backend-API-sidan är det värt att aktivera det så länge ditt frontend kan konsumera Server-Sent Events. För alla svar längre än några få meningar motiverar vinsten i upplevd latens den ökade komplexiteten. Omvänt, i ett batch-skript som bearbetar tusen dokument och skriver resultat till en fil, är det ingen som tittar på skärmen: chat.complete() förblir enklare och fullt tillräckligt.
Viktiga punkter
chat.stream()returnerar en iterator av bitar för progressiv visning- Innehållet finns i
chunk.data.choices[0].delta.content - Använd
flush=Truei dinaprint()-anrop för visning i realtid - Återskapa hela svaret genom att ackumulera bitar vid behov
- Den asynkrona versionen
chat.stream_async()rekommenderas för webbapplikationer