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

Βελτιστοποιημένη ροή δεδομένων (Streaming)

Μάθημα 5 / 20 Ενημερώθηκε 28 Ιουλίου 2026 Προχωρημένος
Σε αυτήν τη σελίδα
  1. Τι αλλάζει πραγματικά το streaming
  2. Κατανάλωση της ροής στην πλευρά του πελάτη
  3. Μετάδοση της ροής στον browser
  4. Διατήρηση της σύνδεσης με την πάροδο του χρόνου
  5. Βασικά σημεία

Τι αλλάζει πραγματικά το streaming

Το streaming δεν κάνει το μοντέλο ταχύτερο: κάνει την αναμονή ανεκτή. Για μια απάντηση που χρειάζεται πέντε δευτερόλεπτα για να παραχθεί, ένας χρήστης χωρίς streaming κοιτάζει μια κενή οθόνη για πέντε δευτερόλεπτα πριν λάβει ένα μπλοκ κειμένου. Με το streaming, βλέπει τις πρώτες λέξεις μετά από μερικά εκατοντάδες χιλιοστά του δευτερολέπτου και διαβάζει καθώς το μοντέλο γράφει. Η συνολική διάρκεια είναι ίδια, αλλά η αντίληψη είναι εντελώς διαφορετική. Γι’ αυτό, στην παραγωγή, η παράλειψη του streaming είναι σχεδόν πάντα σχεδιαστικό λάθος και όχι συνειδητή επιλογή.

Ωστόσο, η ροή πρέπει να διαπεράσει ολόκληρη την αλυσίδα σας. Μια ροή που παράγεται σωστά από το API αλλά συσσωρεύεται από τον διακομιστή εφαρμογών σας ή τίθεται σε προσωρινή μνήμη (buffer) από τον αντίστροφο μεσολαβητή (reverse proxy) φτάνει στον χρήστη ως ένα ενιαίο μπλοκ: έχετε πληρώσει το τίμημα της πολυπλοκότητας για το streaming χωρίς να εισπράξετε τα οφέλη. Αυτό το μάθημα ακολουθεί επομένως την πλήρη διαδρομή, από την κλήση API έως τον browser.

Κατανάλωση της ροής στην πλευρά του πελάτη

Με το Responses API, η ρύθμιση stream=True μετατρέπει την απάντηση σε μια ακολουθία typed events που διατρέχετε καθώς φτάνουν. Κάθε θραύσμα κειμένου φτάνει σε ένα συμβάν response.output_text.delta· το τέλος της ροής σηματοδοτείται από το response.completed, το οποίο μεταφέρει το πλήρες αντικείμενο απάντησης, χρήσιμο για την ανάκτηση της χρήσης tokens.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Ροή παραγωγής με το Responses API."""
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
        elif event.type == "response.completed":
            print()  # Νέα γραμμή στο τέλος
            return event.response

Η σημαία flush=True δεν είναι καλλωπιστική: χωρίς αυτήν, η Python κάνει buffering στην έξοδο από μόνη της και καταλήγετε με τη συμπεριφορά μπλοκ που προσπαθούσατε να αποφύγετε. Αυτή η λεπτομέρεια επαναλαμβάνεται σε κάθε στρώμα της αλυσίδας και αποτελεί την κύρια δυσκολία του streaming.

Ο μηχανισμός καλύπτει επίσης τις κλήσεις συναρτήσεων. Τα ορίσματα των εργαλείων δομούνται προοδευτικά και μπορείτε να τα εμφανίζετε καθώς παράγονται, για να σηματοδοτήσετε στον χρήστη ότι διαμορφώνεται μια αναζήτηση, αντί να τον αφήνετε να κοιτάζει μια παγωμένη διεπαφή ενώ το μοντέλο προετοιμάζει την κλήση του.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Searches for a product in the catalog.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
            },
            "required": ["query"],
        },
    }
]

def streaming_with_tools(prompt: str):
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        tools=tools,
        stream=True,
    )

    for event in stream:
        match event.type:
            case "response.output_text.delta":
                print(event.delta, end="", flush=True)
            case "response.function_call_arguments.delta":
                # Ορίσματα συνάρτησης που παράγονται αυτή τη στιγμή
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Function call complete]")

Μετάδοση της ροής στον browser

Το frontend σας δεν συνομιλεί απευθείας με το OpenAI API—συνομιλεί με τον διακομιστή σας, ο οποίος πρέπει επομένως να μεταδώσει τη ροή. Τα Server-Sent Events (SSE) είναι η φυσική μορφή για αυτό: μια απόκριση HTTP που παραμένει ανοιχτή, όπου κάθε γραμμή data: μεταφέρει ένα θραύσμα JSON. Το παρακάτω παράδειγμα μεταδίδει το κείμενο καθώς φτάνει και στη συνέχεια εκπέμπει ένα τελικό μήνυμα που περιέχει τον αριθμό των tokens, επιτρέποντάς σας να χρεώσετε ή να καταγράψετε δεδομένα χωρίς δεύτερη κλήση.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import openai
import json

app = FastAPI()
client = openai.OpenAI()

@app.post("/api/chat")
async def chat_streaming(request: dict):
    prompt = request["message"]

    async def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True,
        )

        for event in stream:
            if event.type == "response.output_text.delta":
                data = json.dumps({"text": event.delta})
                yield f"data: {data}\n\n"
            elif event.type == "response.completed":
                usage = event.response.usage
                data = json.dumps({
                    "end": True,
                    "input_tokens": usage.input_tokens,
                    "output_tokens": usage.output_tokens,
                })
                yield f"data: {data}\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",  # Σημαντικό για το nginx
        },
    )

Στη συνέχεια υπάρχει ο αντίστροφος μεσολαβητής, ο συνήθης ύποπτος όταν «το streaming δεν λειτουργεί στην παραγωγή παρόλο που λειτουργούσε τοπικά». Από προεπιλογή, το nginx συσσωρεύει την απόκριση του backend πριν τη μεταδώσει. Η παρακάτω διαμόρφωση απενεργοποιεί αυτή τη συμπεριφορά μόνο για τη συγκεκριμένη διαδρομή.

location /api/chat {
    proxy_pass http://127.0.0.1:8000;
    proxy_buffering off;
    proxy_cache off;
    proxy_set_header Connection "";
    chunked_transfer_encoding on;
}

Διατήρηση της σύνδεσης με την πάροδο του χρόνου

Μια ροή ανοιχτή για αρκετές δεκάδες δευτερόλεπτα είναι πιο εκτεθειμένη από μια σύντομη κλήση: μια διακοπή δικτύου, η επίτευξη ενός ορίου ποσόστωσης και η παραγωγή σταματά στη μέση της πρότασης. Η στρατηγική επανάληψής σας πρέπει να διακρίνει μεταξύ αυτών των δύο περιπτώσεων, καθώς απαιτούν διαφορετικές προσεγγίσεις. Ένα σφάλμα σύνδεσης πρέπει να επαναλαμβάνεται με εκθετική καθυστέρηση (exponential backoff), δίνοντας χρόνο στο δίκτυο να ανακάμψει χωρίς να βομβαρδίζεται το API· μια υπέρβαση ποσόστωσης πρέπει να επαναλαμβάνεται μετά από μια σταθερή αναμονή, καθώς το παράθυρο του ορίου ρυθμού επαναφέρεται σε τακτά χρονικά διαστήματα.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Ροή με διαχείριση σφαλμάτων και επανάληψη."""
    for attempt in range(max_attempts):
        try:
            stream = client.responses.create(
                model="gpt-5.6-terra",
                input=prompt,
                stream=True,
            )

            full_text = ""
            for event in stream:
                if event.type == "response.output_text.delta":
                    full_text += event.delta
                    yield event.delta

            return  # Επιτυχία, έξοδος

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Εκθετική καθυστέρηση
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Σταθερή αναμονή για όριο ρυθμού

Μια τελευταία βελτίωση αυξάνει την άνεση ανάγνωσης. Η εκπομπή κάθε token παράγει ένα «σπασμωδικό» κείμενο, ειδικά αν η διεπαφή σας εφαρμόζει κινούμενα σχέδια ή αν το αποτέλεσμα προορίζεται για μετατροπή κειμένου σε ομιλία (text-to-speech). Η συσσώρευση μέχρι το τέλος μιας πρότασης δίνει έναν ρυθμό πιο κοντά στην ανθρώπινη ανάγνωση, με κόστος μια μικρή επιπλέον καθυστέρηση στο πρώτο θραύσμα.

def streaming_by_sentence(prompt: str):
    """Συσσώρευση και απόδοση ανά ολοκληρωμένη πρόταση."""
    buffer = ""

    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Αναζήτηση τέλους πρότασης
            for separator in [".\n", "!\n", "?\n", ". ", "! ", "? "]:
                if separator in buffer:
                    parts = buffer.split(separator, 1)
                    yield parts[0] + separator.rstrip()
                    buffer = parts[1] if len(parts) > 1 else ""

    if buffer.strip():
        yield buffer.strip()

Σημειώστε το τελικό if buffer.strip(): χωρίς αυτό, μια απάντηση που δεν τελειώνει με ισχυρή στίξη θα έχανε τις τελευταίες λέξεις της. Αυτό το είδος παράβλεψης περνά απαρατήρητο κατά τις δοκιμές και εκδηλώνεται στην παραγωγή σε απαντήσεις που περικόπτονται από το max_output_tokens.

Βασικά σημεία

  • Χρησιμοποιείτε πάντα streaming στην παραγωγή για να μειώσετε την αντιληπτή καθυστέρηση
  • Διαμορφώστε το nginx με proxy_buffering off για SSE
  • Διαχειριστείτε τα σφάλματα με επανάληψη και εκθετική καθυστέρηση
  • Συσσωρεύστε ανά πρόταση για πιο φυσική εμφάνιση