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

Streaming: Λήψη Απαντήσεων σε Πραγματικό Χρόνο

Μάθημα 8 / 22 Ενημερώθηκε 29 Ιουλίου 2026 Για developers
Σε αυτήν τη σελίδα
  1. Streaming: Λήψη Απαντήσεων σε Πραγματικό Χρόνο
  2. Γιατί να χρησιμοποιήσετε Streaming
  3. Τυποποιημένα Συμβάντα, Όχι Ένα Αδιάκριτο Ρεύμα
  4. Streaming και Κλήση Συναρτήσεων
  5. Η Ασύγχρονη Περίπτωση
  6. Σφάλματα Κατά τη Διάρκεια της Ροής
  7. Βασικά σημεία

Streaming: Λήψη Απαντήσεων σε Πραγματικό Χρόνο

Το streaming σάς επιτρέπει να λαμβάνετε την απάντηση token προς token, αντί να περιμένετε να ολοκληρωθεί ολόκληρη η παραγωγή. Αυτό δεν αποτελεί απλώς βελτίωση της διεπαφής χρήστη: είναι ο παράγοντας που ξεχωρίζει ένα chatbot που φαίνεται αργό από ένα που φαίνεται άμεσο, ακόμη και όταν η απόδοση του διακομιστή είναι ίδια.

Γιατί να χρησιμοποιήσετε Streaming

Χωρίς streaming, οι χρήστες μερικές φορές κοιτάζουν μια κενή οθόνη για δέκα έως τριάντα δευτερόλεπτα πριν εμφανιστεί ολόκληρη η απάντηση μονομιάς. Με το streaming, οι πρώτες λέξεις εμφανίζονται σε λιγότερο από ένα δευτερόλεπτο και η ανάγνωση ξεκινά ενώ η παραγωγή συνεχίζεται. Η συνολική διάρκεια είναι η ίδια· η αντίληψη όμως διαφέρει. Η ενεργοποίησή του απαιτεί μόνο μία παράμετρο, την stream=True, η οποία μετατρέπει την τιμή επιστροφής της create() σε έναν επαναλήπτη συμβάντων.

from openai import OpenAI
client = OpenAI()

# ΧΩΡΙΣ streaming — αναμονή για τα πάντα
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Εμφανίζεται μονομιάς μετά την αναμονή

# ΜΕ streaming — token προς token
stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence.",
    stream=True
)

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

Τυποποιημένα Συμβάντα, Όχι Ένα Αδιάκριτο Ρεύμα

Το stream δεν μεταφέρει απλώς κείμενο. Σας ειδοποιεί όταν δημιουργείται η απάντηση, όταν προστίθεται κάθε στοιχείο εξόδου, όταν φτάνουν τα τμήματα και όταν ολοκληρώνεται η διαδικασία· το τελικό συμβάν περιλαμβάνει μετρικές χρήσης. Φιλτράρετε βάσει του event.type για να γνωρίζετε τι διαχειρίζεστε. Αυτή η δομή σάς επιτρέπει, για παράδειγμα, να εμφανίζετε μια ένδειξη φόρτωσης μόλις ενεργοποιηθεί το response.created και να αθροίζετε τα tokens στο τέλος χωρίς δεύτερη κλήση API.

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

for event in stream:
    match event.type:
        case "response.created":
            print(f"[Response created] ID: {event.response.id}")
        case "response.output_item.added":
            print(f"[New output item]")
        case "response.output_text.delta":
            print(f"[Text] {event.delta}", end="")
        case "response.output_text.done":
            print(f"\n[Text complete]")
        case "response.completed":
            print(f"[Done] Tokens: {event.response.usage.total_tokens}")

# Έξοδος:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25

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

def stream_and_collect(prompt: str) -> str:
    """Ροή της απάντησης ενώ συλλέγεται."""
    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
            print(event.delta, end="", flush=True)

    print()  # Νέα γραμμή
    return full_text

result = stream_and_collect("List 3 European capitals.")
print(f"\nCollected text ({len(result)} characters)")

Streaming και Κλήση Συναρτήσεων

Οι κλήσεις συναρτήσεων μεταδίδονται επίσης μέσω streaming, με τα δικά τους συμβάντα: τα ορίσματα φτάνουν σε τμήματα μέσω του response.function_call_arguments.delta, και το response.function_call_arguments.done σηματοδοτεί ότι το JSON είναι πλήρες. Αυτό έχει μια σημαντική πρακτική συνέπεια: μην προσπαθήσετε ποτέ να αποσυμπιέσετε (deserialize) τα ορίσματα πριν από το συμβάν done, διαφορετικά θα έχετε μόνο περικομμένο JSON.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="What time is it in Tokyo?",
    tools=[{
        "type": "function",
        "name": "get_time",
        "description": "Get the time in a city",
        "parameters": {
            "type": "object",
            "properties": {
                "city": {"type": "string"}
            },
            "required": ["city"]
        }
    }],
    stream=True
)

for event in stream:
    match event.type:
        case "response.output_text.delta":
            print(event.delta, end="")
        case "response.function_call_arguments.delta":
            print(f"[Args] {event.delta}", end="")
        case "response.function_call_arguments.done":
            print(f"\n[Function call complete]")

# Έξοδος:
# [Args] {"city": "Tokyo"}
# [Function call complete]

Η Ασύγχρονη Περίπτωση

Μόλις η εφαρμογή σας εξυπηρετεί πολλούς χρήστες ταυτόχρονα, μεταβείτε στο AsyncOpenAI: ο συγχρονισμένος πελάτης θα μπλοκάριζε τον βρόχο συμβάντων για όλη τη διάρκεια της παραγωγής, αναγκάζοντας τα άλλα αιτήματά σας να περιμένουν. Η σύνταξη διαφέρει μόνο κατά δύο λέξεις-κλειδιά: await κατά τη δημιουργία και async for κατά την επανάληψη.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Ασύγχρονη ροή της απάντησης."""
    stream = await async_client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True
    )

    async for event in stream:
        if event.type == "response.output_text.delta":
            print(event.delta, end="", flush=True)
    print()

asyncio.run(stream_async("Tell a short joke."))

Στον ιστό, το streaming είναι άχρηστο αν σταματά στον διακομιστή σας: πρέπει να το επεκτείνετε μέχρι τον browser. Το FastAPI το επιτρέπει αυτό μέσω του StreamingResponse, τροφοδοτούμενο από μια γεννήτρια που αναμεταδίδει τα τμήματα καθώς φτάνουν.

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

app = FastAPI()
client = OpenAI()

@app.get("/chat")
async def chat(question: str):
    def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=question,
            stream=True
        )
        for event in stream:
            if event.type == "response.output_text.delta":
                yield event.delta

    return StreamingResponse(generate(), media_type="text/plain")

Σφάλματα Κατά τη Διάρκεια της Ροής

Μια λεπτομέρεια αξίζει την προσοχή σας: στο streaming, ένα σφάλμα μπορεί να συμβεί αφού έχουν ήδη εμφανιστεί τμήματα. Ο χρήστης βλέπει τότε μια απάντηση που ξεκινά αλλά διακόπτεται απότομα. Επομένως, περικλείστε την ίδια την επανάληψη σε bloc try/except, και όχι μόνο τη δημιουργία του stream, ώστε να μπορείτε να σηματοδοτήσετε καθαρά τη διακοπή αντί να αφήσετε μια ημιτελή πρόταση.

from openai import APIError

def stream_with_errors(prompt: str):
    """Ροή με ισχυρό χειρισμό σφαλμάτων."""
    try:
        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)
        print()

    except APIError as e:
        print(f"\nAPI error during streaming: {e.message}")
    except Exception as e:
        print(f"\nUnexpected error: {e}")

stream_with_errors("Explain streaming in 2 sentences.")

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

  • Ενεργοποιήστε το streaming με stream=True για εμπειρία πραγματικού χρόνου
  • Φιλτράρετε τα συμβάντα βάσει του event.type για σωστό χειρισμό κάθε τύπου δεδομένων
  • Το response.output_text.delta περιέχει τμήματα κειμένου
  • Το response.completed σηματοδοτεί το τέλος και περιλαμβάνει μετρικές χρήσης
  • Χρησιμοποιήστε το AsyncOpenAI για streaming σε ασύγχρονες εφαρμογές
  • Διαχειρίζεστε πάντα τα σφάλματα, ακόμη και σε λειτουργία streaming