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

Optimalizált adatfolyam

5. lecke 20 közül Frissítve 2026. július 28. Haladó
Ezen az oldalon
  1. Mit is változtat valójában az adatfolyam?
  2. Az adatfolyam fogyasztása a kliens oldalon
  3. Az adatfolyam továbbítása a böngésző felé
  4. A kapcsolat fenntartása időben
  5. Főbb megállapítások

Mit is változtat valójában az adatfolyam?

Az adatfolyam (streaming) nem teszi gyorsabbá a modellt: csupán elviselhetővé teszi a várakozást. Egy öt másodpercig generálódó válasz esetén a streaming nélkül a felhasználó öt másodpercig egy üres képernyőt bámul, mielőtt megkapná a szövegblokkot. Streaminggel már néhány száz milliszekundum után látja az első szavakat, és olvashatja a szöveget, ahogy a modell írja. A teljes időtartam ugyanaz marad, de az érzékelés teljesen más. Éppen ezért a production környezetben a streaming kihagyása szinte mindig tervezési hiba, nem pedig tudatos döntés.

Azonban az adatfolyamnak végig kell haladnia az egész láncodon. Ha az API helyesen generálja a streamet, de az alkalmazásszervered felhalmozza, vagy a reverse proxy-d puffereli, a felhasználó végül egyetlen blokkban kapja meg az adatot: kifizetted a streaming komplexitási árát anélkül, hogy élveznéd az előnyeit. Ez a lecke ezért végigköveti a teljes utat, az API-hívástól a böngészőig.

Az adatfolyam fogyasztása a kliens oldalon

A Responses API használatakor a stream=True beállítás az választ események típusozott sorozatává alakítja, amelyeket beérkezésük során iterálsz végig. Minden szövegrészlet egy response.output_text.delta eseményben érkezik; az adatfolyam végét a response.completed jelzi, amely a teljes válaszobjektumot tartalmazza – ez hasznos a tokenfelhasználás lekéréséhez.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Streaming generálás a Responses API-val."""
    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()  # Új sor a végén
            return event.response

A flush=True flag nem csupán kozmetikai: nélküle a Python saját maga puffereli a kimenetet, és végül azt a blokkos viselkedést kapod, amit el akartál kerülni. Ez a részlet a lánc minden rétegében megismétlődik, és ez jelenti a streaming fő nehézségét.

A mechanizmus a függvényhívásokat is lefedi. Az eszközök argumentumai fokozatosan épülnek fel, és megjelenítheted őket generálás közben, hogy jelezd a felhasználónak: egy keresés van folyamatban, ahelyett, hogy fagyott felületet bámulna, miközben a modell előkészíti a hívást.

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":
                # Jelenleg generálódó függvényargumentumok
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Függvényhívás befejezve]")

Az adatfolyam továbbítása a böngésző felé

A frontended nem közvetlenül az OpenAI API-val kommunikál, hanem a szervereddel, amelynek ezért továbbítania kell az adatfolyamot. Erre a Server-Sent Events (SSE) a természetes formátum: egy nyitva maradó HTTP-válasz, ahol minden data: sor egy JSON-részletet szállít. Az alábbi példa továbbítja a szöveget beérkezés közben, majd kibocsát egy záró üzenetet a tokenszámlálóval, így számlázhatsz vagy naplózhatsz anélkül, hogy második hívásra lenne szükség.

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",  # Fontos az nginx számára
        },
    )

Aztán ott van a reverse proxy, a szokásos gyanúsított, amikor „productionben nem működik a streaming, pedig lokálisan igen“. Alapértelmezés szerint az nginx felhalmozza a backend válaszát, mielőtt továbbítaná. Az alábbi konfiguráció kikapcsolja ezt a viselkedést kizárólag az adott útvonalon.

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;
}

A kapcsolat fenntartása időben

Egy több tíz másodpercig nyitva tartott adatfolyam jobban ki van téve a hibáknak, mint egy rövid hívás: egy hálózati kimaradás, egy kvóta túllépése, és a generálás mondat közben megszakad. A retry stratégiádnak különbséget kell tennie e két eset között, mert eltérő megközelítést igényelnek. Kapcsolati hiba esetén exponenciális visszalépéssel (exponential backoff) kell újrapróbálkozni, időt adva a hálózatnak a helyreállásra anélkül, hogy az API-t terhelnéd; kvóta túllépés esetén fix várakozási idő után érdemes újrapróbálkozni, mivel a sebességkorlátozási ablak rendszeres időközönként resetelődik.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Streaming hibakezeléssel és újrapróbálkozással."""
    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  # Sikeres, kilépés

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Exponenciális visszalépés
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Fix várakozás sebességkorlátozás esetén

Egy utolsó finomhangolás javítja az olvasási élményt. Minden token egyesével történő kibocsátása rángatózó szöveget eredményez, különösen, ha a felületed animációt alkalmaz, vagy ha az eredmény szöveg-beszéd (TTS) konverzióra kerül. A mondat végéig történő felhalmozás az emberi olvasáshoz közelebb álló ritmust biztosít, az első részletnél fellépő csekély plusz késleltetés árán.

def streaming_by_sentence(prompt: str):
    """Felhalmozás és kibocsátás teljes mondatonként."""
    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
            # Mondatvég keresése
            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()

Figyeld meg a záró if buffer.strip() feltételt: enélkül egy olyan válasz, amely nem erős írásjellel végződik, elveszítené az utolsó szavait. Az ilyen figyelmetlenség a tesztelés során észrevétlen marad, és productionben csak akkor mutatkozik meg, amikor a válaszokat a max_output_tokens levágja.

Főbb megállapítások

  • Mindig használj streaminget productionben a észlelt késleltetés csökkentése érdekében
  • Konfiguráld az nginxet a proxy_buffering off beállítással SSE esetén
  • Kezeld a hibákat újrapróbálkozással és exponenciális visszalépéssel
  • Halmozz fel mondatonként a természetesebb megjelenítés érdekében