Gestreamde antwoorden in Python
Op deze pagina
Het probleem dat streaming oplost
Met chat.complete() wacht u totdat het model zijn volledige antwoord heeft gegenereerd voordat u ook maar één teken ontvangt. Bij een kort antwoord valt deze vertraging nauwelijks op. Maar bij een gedetailleerde analyse, een lang codefragment of redeneringen die meerdere alinea’s beslaan, staart de gebruiker enkele seconden naar een leeg scherm. In een chatinterface kan zelfs een paar seconden stilte de indruk wekken dat de applicatie is vastgelopen.
Streaming verandert deze perceptie: het antwoord komt stapsgewijs binnen, chunk voor chunk, en wordt progressief weergegeven, net zoals u gewend bent van chatinterfaces. De totale generatietijd neemt geen milliseconde af, maar het eerste woord verschijnt bijna onmiddellijk. Die initiële vertraging is wat de gebruiker daadwerkelijk voelt.
Gebruikmaken van chat.stream()
De Mistral SDK V2 biedt de methode chat.stream(), die een iterator van chunks retourneert in plaats van één enkel object:
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()
Twee details maken in deze lus het verschil. De controle if content is essentieel omdat sommige chunks zonder tekst aankomen en anders None zouden afdrukken. En flush=True dwingt Python om direct naar de uitvoer te schrijven in plaats van te wachten tot de buffer vol is. Zonder dit zou alle tekst pas aan het einde in één blok verschijnen, waardoor het beoogde voordeel volledig teniet wordt gedaan.
| Aspect | chat.complete() | chat.stream() |
|---|---|---|
| Retourwaarde | Volledig object | Iterator van chunks |
| Waargenomen latentie | Hoog (totale wachttijd) | Laag (snel eerste token) |
| Teksttoegang | response.choices[0].message.content | chunk.data.choices[0].delta.content |
| Tokengebruik | Beschikbaar in antwoord | Beschikbaar in laatste chunk |
Wat een chunk bevat
Elke chunk bevat een delta, oftewel een fragment van het antwoord dat nog wordt opgebouwd. Door deze te inspecteren, krijgt u toegang tot zowel de tekst als de metadata voor het einde van de stream:
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}]")
De flow volgt altijd dezelfde choreografie: de eerste chunk bevat meestal de rol assistant, tussentijdse chunks leveren de tekst in kleine stukjes, en de laatste bevat de finish_reason. U bepaalt of het antwoord normaal is geëindigd of werd afgebroken door max_tokens door deze laatste chunk te controleren.
Gelijktijdig weergeven en opslaan
Streaming heeft een nadeel: de tekst rolt voorbij, maar u bewaart deze nergens. Toch heeft een real-world applicatie vaak behoefte om het antwoord in een database te archiveren voor conversatiegeschiedenis. De oplossing is fragmenten te accumuleren terwijl u ze weergeeft:
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")
Let op het gebruik van een lijst gevolgd door een uiteindelijke "".join() in plaats van stringconcatenatie in elke lusiteratie. Bij een lang antwoord kopieert die laatste aanpak bij elk ontvangen fragment alle reeds verzamelde tekst, wat inefficiënt is.
De asynchrone variant
In een webserver—FastAPI, aiohttp—blokkeert de synchrone versie de thread tijdens de volledige generatie, waardoor andere lopende verzoeken bevriezen. De SDK biedt daarom 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())
De structuur is identiek aan de synchrone versie, afgezien van de trefwoorden await en async for. Zodra uw code in een webserver draait, is dit de variant die u moet gebruiken.
Wanneer wel streamen en wanneer niet
In een chatinterface is streaming altijd verplicht: het leescomfort staat op het spel. Aan de kant van de backend-API loont het de moeite om dit in te schakelen zolang uw frontend Server-Sent Events kan verwerken. Voor elk antwoord dat langer is dan een paar zinnen, rechtvaardigt de winst in waargenomen latentie de extra complexiteit. Omgekeerd, in een batchscript dat duizenden documenten verwerkt en resultaten naar een bestand schrijft, kijkt niemand naar het scherm: chat.complete() blijft eenvoudiger en volkomen adequaat.
Belangrijkste punten
chat.stream()retourneert een iterator van chunks voor progressieve weergave- Inhoud bevindt zich in
chunk.data.choices[0].delta.content - Gebruik
flush=Truein uwprint()-aanroepen voor weergave in real-time - Reconstrueer het volledige antwoord door chunks te accumuleren indien nodig
- De asynchrone versie
chat.stream_async()wordt aanbevolen voor webapplicaties