Preskok na glavno vsebino
Slovenščina— Izberite jezik
Meni

Pretakanje: prejemanje odgovorov v realnem času

Lekcija 8 od 22 Posodobljeno 29. julij 2026 Razvijalec
Na tej strani
  1. Pretakanje: prejemanje odgovorov v realnem času
  2. Zakaj uporabljati pretakanje
  3. Tipizirani dogodki, ne nediferenciran tok
  4. Pretakanje in klicanje funkcij
  5. Asinhroni primer
  6. Napake med pretakanjem
  7. Ključne ugotovitve

Pretakanje: prejemanje odgovorov v realnem času

Pretakanje (streaming) ti omogoča prejemanje odgovora žeton za žetonom, namesto da bi čakal na konec celotnega generiranja. To ni le kozmetični dodatek uporabniškemu vmesniku: prav to loči klepetalnega bota, ki deluje okorno, od tistega, ki deluje odzivno, tudi če je zmogljivost strežnika popolnoma enaka.

Zakaj uporabljati pretakanje

Brez pretakanja uporabniki včasih gledajo v prazen zaslon deset do trideset sekund, preden se celoten odgovor prikaže naenkrat. S pretakanjem se prve besede pojavijo v manj kot sekundi, branje pa se začne, medtem ko generiranje še poteka. Skupno trajanje je enako; zaznava pa ne. Omogočitev zahteva le en parameter, stream=True, ki povratno vrednost funkcije create() spremeni v iterator dogodkov.

from openai import OpenAI
client = OpenAI()

# BREZ pretakanja — počakaj na vse
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Prikaže se vse naenkrat po čakanju

# S pretakanjem — žeton za žetonom
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()  # Nova vrstica na koncu

Tipizirani dogodki, ne nediferenciran tok

Tok ne prenaša le besedila. Obvesti te, ko je odgovor ustvarjen, ko je dodan vsak izhodni element, ko prispejo fragmenti in ko pride do zaključka – končni dogodek vključuje metrike uporabe. Filtriraš glede na event.type, da veš, s čim imaš opravka. Ta struktura ti omogoča, da na primer prikažeš indikator nalaganja, takoj ko se sproži response.created, in na koncu sešteješ žetone brez dodatnega klica API-ja.

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

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

V realni aplikaciji boš skoraj vedno želel početi dve stvari hkrati: prikazovati fragmente in rekonstruirati celotno besedilo, da ga lahko arhiviraš ali vrneš klicatelju. Pravilo je preprosto: kopiči med iteracijo, saj toka po porabi ni mogoče prevrniti nazaj.

def stream_and_collect(prompt: str) -> str:
    """Pretakaj odgovor in ga hkrati zbiraj."""
    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()  # Nova vrstica
    return full_text

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

Pretakanje in klicanje funkcij

Tudi klici funkcij so pretočeni, z lastnimi dogodki: argumenti prispejo v fragmentih prek response.function_call_arguments.delta, response.function_call_arguments.done pa signalizira, da je JSON končan. To ima pomembno praktično posledico – nikoli ne poskušaj deserializirati argumentov pred dogodkom done, sicer boš imel le okrnjen 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]")

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

Asinhroni primer

Takoj ko tvoja aplikacija hkrati streže več uporabnikom, preklopi na AsyncOpenAI: sinhroni klient bi blokiral zanko dogodkov za celoten čas generiranja, zaradi česar bi morala druga zahteve čakati. Sintaksa se razlikuje le v dveh ključnih besedah – await ob ustvarjanju in async for pri iteraciji.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asinhrono pretakanje odgovora."""
    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."))

Na spletu je pretakanje neuporabno, če se ustavi na tvojem strežniku: razširiti ga moraš do brskalnika. FastAPI to omogoča z StreamingResponse, ki ga napaja generator, ki posreduje fragmente, ko prispejo.

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

Napake med pretakanjem

Ena podrobnost si zasluži tvojo pozornost: pri pretakanju lahko do napake pride, ko so bili fragmenti že prikazani. Uporabnik tako vidi odgovor, ki se začne, a se nenadoma prekine. Zato ovij samo iteracijo, ne le ustvarjanja toka, da lahko čisto signaliziraš prekinitev, namesto da bi pustil stavek nedokončan.

from openai import APIError

def stream_with_errors(prompt: str):
    """Pretakanje z robustnim ravnanjem z napakami."""
    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.")

Ključne ugotovitve

  • Omogoči pretakanje s stream=True za izkušnjo v realnem času
  • Filtriraj dogodke po event.type, da pravilno obravnavaš vsako vrsto podatkov
  • response.output_text.delta vsebuje fragmente besedila
  • response.completed signalizira konec in vključuje metrike uporabe
  • Uporabi AsyncOpenAI za pretakanje v asinhronih aplikacijah
  • Vedno obravnavaj napake, tudi v načinu pretakanja