Μετάβαση στο κύριο περιεχόμενο
Ελληνικά— Επιλέξτε γλώσσα
Μενού

Υλοποίηση ροής δεδομένων (streaming) στην Python

Μάθημα 6 / 16 Ενημερώθηκε 2 Νοεμβρίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Από το πρωτότυπο στην παραγωγή
  2. Το βασικό μοτίβο
  3. Ολοκληρωμένη διαχείριση σφαλμάτων
  4. Ασύγχρονη ροή με asyncio
  5. Ενσωμάτωση με FastAPI
  6. Μέτρηση απόδοσης
  7. Βασικά σημεία

Από το πρωτότυπο στην παραγωγή

Το προηγούμενο μάθημα κάλυψε τις έννοιες της ροής δεδομένων 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