Υλοποίηση ροής δεδομένων (streaming) στην Python
Σε αυτήν τη σελίδα
Από το πρωτότυπο στην παραγωγή
Το προηγούμενο μάθημα κάλυψε τις έννοιες της ροής δεδομένων SSE. Το δυσκολότερο κομμάτι απομένει: η μετατροπή ενός βρόχου επίδειξης σε έναν πελάτη που αντέχει υπό φορτίο, επιβιώνει από σφάλματα δικτύου και τροφοδοτεί μια διαδικτυακή διεπαφή. Αυτό το μάθημα ακολουθεί την πραγματική τροχιά ενός έργου—πρώτα ο σκελετός, μετά η διαχείριση σφαλμάτων, έπειτα η ασύγχρονη λειτουργία, στη συνέχεια η έκθεση μέσω HTTP και τελικά η μέτρηση.
Το βασικό μοτίβο
Όλα ξεκινούν με αυτόν τον σκελετό δέκα γραμμών, τον οποίο θα προσαρμόσετε για κάθε έργο. Κάνει δύο πράγματα ταυτόχρονα: εμφανίζει τα tokens καθώς φτάνουν και τα συσσωρεύει για την επιστροφή της συνάρτησης.
from mistralai.client import Mistral
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
def stream_chat(messages: list, model: str = "mistral-large-latest") -> str:
"""Στέλνει ένα αίτημα ροής και εμφανίζει tokens σε πραγματικό χρόνο."""
stream = client.chat.stream(
model=model,
messages=messages
)
full_text = ""
for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
full_text += content
print(content, end="", flush=True)
print() # Νέα γραμμή
return full_text
Αυτή η έκδοση λειτουργεί για ένα τοπικό script. Έχει ένα θανάσιμο ελάττωμα στην παραγωγή: εκτυπώνει στο τερματικό, οπότε δεν μπορεί να κάνει τίποτα άλλο εκτός από εργασία τερματικού.
Ολοκληρωμένη διαχείριση σφαλμάτων
Τα σφάλματα δικτύου, τα χρονικά όρια (timeouts) και τα όρια ρυθμού (rate limits) δεν είναι υποθετικά: είναι βεβαιότητες σε κλίμακα πραγματικής κίνησης. Ο παρακάτω πελάτης αντιμετωπίζει και τα δύο προβλήματα. Επαναλαμβάνει αυτόματα τα σφάλματα 429 με εκθετική καθυστέρηση (exponential backoff) και δεν εκτυπώνει πλέον τίποτα: εκπέμπει τυποποιημένα γεγονότα μέσω yield, αφήνοντας στον καλούντα την απόφαση για το τι θα κάνει με αυτά—να τα εμφανίσει, να τα ωθήσει σε ένα WebSocket ή να τα γράψει σε μια βάση δεδομένων.
from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import time
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
def stream_with_retry(
messages: list,
model: str = "mistral-large-latest",
max_retries: int = 3,
max_tokens: int = 2000
) -> dict:
"""Ροή με αυτόματη επανάληψη και μετρικές."""
for attempt in range(max_retries):
try:
stream = client.chat.stream(
model=model,
messages=messages,
max_tokens=max_tokens
)
full_text = ""
finish_reason = None
chunk_count = 0
for chunk in stream:
delta = chunk.data.choices[0].delta
if delta.content:
full_text += delta.content
chunk_count += 1
yield {"type": "token", "content": delta.content}
if chunk.data.choices[0].finish_reason:
finish_reason = chunk.data.choices[0].finish_reason
yield {
"type": "done",
"full_text": full_text,
"finish_reason": finish_reason,
"chunks": chunk_count
}
return
except SDKError as e:
if e.status_code == 429 and attempt < max_retries - 1:
wait_time = 2 ** attempt # Εκθετική καθυστέρηση
yield {"type": "retry", "wait": wait_time, "attempt": attempt + 1}
time.sleep(wait_time)
else:
yield {"type": "error", "message": str(e), "status": e.status_code}
return
except Exception as e:
yield {"type": "error", "message": str(e), "status": None}
return
Η εκθετική καθυστέρηση 2 ** attempt περιμένει 1 δευτερόλεπτο, μετά 2, μετά 4. Αυτή η πρόοδος δεν είναι διακοσμητική: αν όλοι οι πελάτες σας επαναλάμβαναν την προσπάθεια με τον ίδιο σταθερό ρυθμό, θα χτυπούσαν το API σε συγχρονισμένες bursts και θα παρέτειναν ακριβώς τον κορεσμό από τον οποίο υποφέρουν. Σημειώστε επίσης ότι μόνο το σφάλμα 429 ενεργοποιεί την επανάληψη—η επανάληψη ενός 401 λόγω μη έγκυρου κλειδιού θα καθυστερούσε απλώς τη διάγνωση.
Στην πλευρά του καλούντος, η κατανάλωση γίνεται μια απλή ανάγνωση γεγονότων:
messages = [
{"role": "system", "content": "Είστε ένας τεχνικός βοηθός."},
{"role": "user", "content": "Εξηγήστε τα πρότυπα σχεδιασμού στην Python."}
]
for event in stream_with_retry(messages):
if event["type"] == "token":
print(event["content"], end="", flush=True)
elif event["type"] == "retry":
print(f"\n[Επανάληψη {event['attempt']}, αναμονή {event['wait']}δ...]")
elif event["type"] == "done":
print(f"\n\n--- Ολοκληρώθηκε ({event['chunks']} chunks, {event['finish_reason']})")
elif event["type"] == "error":
print(f"\n[Σφάλμα: {event['message']}]")
Ασύγχρονη ροή με asyncio
Ο συγχρονισμένος πελάτης δεσμεύει το νήμα του για όλη τη διάρκεια της δημιουργίας. Σε έναν διακομιστή web που πρέπει να διαχειριστεί πενήντα ταυτόχρονες συνομιλίες, αυτό σημαίνει ακινητοποίηση πενήντα νημάτων απλώς για να περιμένουν. Ο ασύγχρονος πελάτης άρει αυτόν τον περιορισμό:
from mistralai.client import Mistral
import asyncio
import os
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
async def async_stream_chat(messages: list) -> str:
"""Ασύγχρονη ροή για ταυτόχρονες εφαρμογές."""
stream = await client.chat.stream_async(
model="mistral-large-latest",
messages=messages
)
full_text = ""
async for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
full_text += content
print(content, end="", flush=True)
print()
return full_text
# Εκτέλεση
async def main():
messages = [{"role": "user", "content": "Γεια, συστήσου."}]
result = await async_stream_chat(messages)
print(f"\nΣύνολο: {len(result)} χαρακτήρες")
asyncio.run(main())
Η λογική είναι ίδια με την συγχρονισμένη έκδοση· αλλάζουν μόνο το stream_async, το await στην κλήση και το async for στον βρόχο.
Ενσωμάτωση με FastAPI
Στη συνέχεια, πρέπει να βγάλετε αυτή τη ροή από τη διαδικασία Python σας και να την οδηγήσετε στον browser. Το FastAPI το χειρίζεται αυτό με το StreamingResponse, υπό την προϋπόθεση ότι θα αναδιαμορφώσετε κάθε τμήμα στη μορφή SSE που είδαμε στο προηγούμενο μάθημα:
from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mistralai.client import Mistral
import os
import json
app = FastAPI()
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))
async def generate_stream(prompt: str):
"""Γεννήτρια SSE για FastAPI."""
stream = await client.chat.stream_async(
model="mistral-large-latest",
messages=[{"role": "user", "content": prompt}]
)
async for chunk in stream:
content = chunk.data.choices[0].delta.content
if content:
data = json.dumps({"content": content})
yield f"data: {data}\n\n"
yield "data: [DONE]\n\n"
@app.get("/chat/stream")
async def chat_stream(prompt: str):
return StreamingResponse(
generate_stream(prompt),
media_type="text/event-stream"
)
Δύο λεπτομέρειες καθορίζουν αν αυτό το endpoint λειτουργεί σωστά. Η διπλή νέα γραμμή \n\n που τελειώνει κάθε yield είναι αυτό που διαχωρίζει τα γεγονότα στο πρωτόκολλο SSE: χωρίς αυτή, ο browser περιμένει επ’ αόριστον για ένα γεγονός που θεωρεί ημιτελές. Και το media_type="text/event-stream" είναι αυτό που επιτρέπει στον πελάτη JavaScript να καταναλώσει την απόκριση με ένα EventSource αντί για ένα τυπικό fetch.
Μέτρηση απόδοσης
Μόλις η ροή είναι έτοιμη, θα θέλετε να μάθετε πώς αποδίδει. Δύο μετρικές αρκούν για να οδηγήσουν τη βελτιστοποίηση:
import time
start = time.perf_counter()
first_token_time = None
token_count = 0
stream = client.chat.stream(
model="mistral-large-latest",
messages=[{"role": "user", "content": "Γράψτε μια παράγραφο για το Παρίσι."}]
)
for chunk in stream:
if chunk.data.choices[0].delta.content:
if first_token_time is None:
first_token_time = time.perf_counter() - start
token_count += 1
total_time = time.perf_counter() - start
print(f"Χρόνος έως το πρώτο Token (TTFT): {first_token_time:.3f}s")
print(f"Tokens που δημιουργήθηκαν: {token_count}")
print(f"Συνολικός χρόνος: {total_time:.3f}s")
print(f"Tokens/δευτερόλεπτο: {token_count / total_time:.1f}")
Το TTFT (Time to First Token)—ο χρόνος μεταξύ της αποστολής του αιτήματος και της εμφάνισης του πρώτου χαρακτήρα—είναι η πιο σημαντική μετρική για την εμπειρία χρήστη. Προηγείται του συνολικού χρόνου: μια δημιουργία δεκαπέντε δευτερολέπτων της οποίας η πρώτη λέξη εμφανίζεται σε τρία δέκατα του δευτερολέπτου θα φαίνεται γρήγορη, ενώ μια δημιουργία πέντε δευτερολέπτων που παραδίδεται σε ένα μπλοκ θα φαίνεται αργή. Μετρήστε το στα πραγματικά σας prompts, συμπεριλαμβανομένου του μηνύματος συστήματος—ένα μήνυμα συστήματος δύο σελίδων επιμηκύνει το TTFT πριν καν δημιουργηθεί το πρώτο token.
Βασικά σημεία
- Χρησιμοποιήστε ένα μοτίβο γεννήτριας (
yield) για τη διάδοση των tokens ροής - Υλοποιήστε εκθετική καθυστέρηση (exponential backoff) για σφάλματα 429 (όριο ρυθμού)
- Προτιμήστε το
stream_asyncγια ταυτόχρονες web εφαρμογές - Μετρήστε το TTFT και τα tokens/δευτερόλεπτο για βελτιστοποίηση της απόδοσης
- Με το FastAPI, ο συνδυασμός
StreamingResponse+text/event-streamδιαδίδει το SSE στον browser