Ugrás a főtartalomra
Magyar— Nyelv kiválasztása
Menü

Streaming: válaszok fogadása valós időben

8. lecke 22 közül Frissítve 2026. július 29. Fejlesztő
Ezen az oldalon
  1. Streaming: válaszok fogadása valós időben
  2. Miért használj streaminget?
  3. Típusos események, nem pedig formázatlan adatfolyam
  4. Streaming és függvényhívás
  5. Aszinkron eset
  6. Hibák streamelés közben
  7. Főbb megállapítások

Streaming: válaszok fogadása valós időben

A streaming lehetővé teszi, hogy tokenről tokenre kapd meg a választ ahelyett, hogy megvárnád a teljes generálás befejeződését. Ez nem csupán felületi csinosítás: ez választja el a lassúnak ható chatbotot attól, amely fürge, még akkor is, ha a szerver teljesítménye azonos.

Miért használj streaminget?

Streaming nélkül a felhasználók néha tíz-harminc másodpercig bámulnak egy üres képernyőt, mire a teljes válasz egyszerre megjelenik. Streaminggel az első szavak egy másodpercen belül láthatóvá válnak, és az olvasás már a generálás folytatódása közben megkezdődhet. A teljes időtartam ugyanaz marad; az érzékelés viszont nem. A bekapcsolásához mindössze egyetlen paraméterre van szükség: stream=True, ami az create() visszatérési értékét esemény-iterátorrá alakítja.

from openai import OpenAI
client = OpenAI()

# Streaming NÉLKÜL – várakozás mindenre
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # A várakozás után egyszerre jelenik meg

# StreamingGEL – tokenről tokenre
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()  # Új sor a végén

Típusos események, nem pedig formázatlan adatfolyam

A stream nem csupán szöveget szállít. Értesít, amikor a válasz létrejön, amikor minden egyes kimeneti elem hozzáadódik, amikor töredékek érkeznek, és amikor a folyamat befejeződik – a záró esemény tartalmazza a felhasználási statisztikákat is. Az event.type alapján szűrhetsz, hogy tudd, mit kezelsz. Ez a struktúra lehetővé teszi például, hogy betöltésjelzőt jeleníts meg, amint a response.created lefut, és a végén összesítsd a tokeneket egy újabb API-hívás nélkül.

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}")

# Kimenet:
# [Response created] ID: resp_abc123
# [New output item]
# [Text] Hello[Text] ! [Text] How[Text] can[Text] I...
# [Text complete]
# [Done] Tokens: 25

Egy valós alkalmazásban szinte mindig két dolgot kell egyszerre csinálnod: megjeleníteni a töredékeket, és újraösszeállítani a teljes szöveget, hogy archiválhasd vagy visszaadhasd a hívónak. A szabály egyszerű: gyűjtsd össze az iterálás során, mert ha a streamet egyszer elfogyasztottad, nem tekerhető vissza.

def stream_and_collect(prompt: str) -> str:
    """Válasz streamelése közbeni összegyűjtéssel."""
    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()  # Új sor
    return full_text

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

Streaming és függvényhívás

A függvényhívások is streamelhetők, saját eseményeikkel: az argumentumok töredékesen érkeznek a response.function_call_arguments.delta eseményen keresztül, a response.function_call_arguments.done pedig jelzi, hogy a JSON teljes. Ennek fontos gyakorlati következménye van: soha ne próbáld meg deszerializálni az argumentumokat a done esemény előtt, különben csak csonka JSON-t kapsz.

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]")

# Kimenet:
# [Args] {"city": "Tokyo"}
# [Function call complete]

Aszinkron eset

Amint az alkalmazásod egyszerre több felhasználót is kiszolgál, válts az AsyncOpenAI használatára: a szinkron kliens blokkolná az eseményhurkot a teljes generálás idejére, ami miatt a többi kérésednek várakoznia kellene. A szintaxis mindössze két kulcsszóban tér el: await a létrehozáskor és async for az iteráláskor.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """A válasz aszinkron streamelése."""
    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."))

A weben a streaming haszontalan, ha a szerverednél megáll: ki kell terjesztened a böngésző felé is. A FastAPI ezt a StreamingResponse segítségével teszi lehetővé, amelyet egy generátor táplál, ami továbbítja a beérkező töredékeket.

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")

Hibák streamelés közben

Egy részlet külön figyelmet érdemel: streaming esetén hiba történhet már akkor is, amikor töredékek már megjelentek. A felhasználó így olyan választ lát, amely elindul, de megszakad. Ezért magát az iterációt burkold be try-except blokkba, nem csupán a stream létrehozását, hogy tisztán jelezhesd a megszakítást, ahelyett, hogy félbehagyott mondatot hagynál.

from openai import APIError

def stream_with_errors(prompt: str):
    """Streaming robusztus hibakezeléssel."""
    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.")

Főbb megállapítások

  • Engedélyezd a streaminget a stream=True paraméterrel a valós idejű élmény érdekében
  • Szűrd az eseményeket az event.type alapján, hogy helyesen kezeld az egyes adattípusokat
  • A response.output_text.delta tartalmazza a szövegtöredékeket
  • A response.completed jelzi a végét, és tartalmazza a felhasználási statisztikákat
  • Használd az AsyncOpenAI klienst aszinkron alkalmazásokban történő streaminghez
  • Mindig kezeld a hibákat, még streaming módban is