Preskoči na glavni sadržaj
Hrvatski— Odaberite jezik
Izbornik

Streaming: Primanje odgovora u stvarnom vremenu

Lekcija 8 od 22 Ažurirano 29. srpnja 2026. Programer
Na ovoj stranici
  1. Streaming: Primanje odgovora u stvarnom vremenu
  2. Zašto koristiti streaming
  3. Tipizirani događaji, a ne nediferencirani tok
  4. Streaming i pozivanje funkcija
  5. Asinkroni slučaj
  6. Greške usred streama
  7. Ključne točke

Streaming: Primanje odgovora u stvarnom vremenu

Streaming ti omogućuje primanje odgovora token po token umjesto čekanja da se cijelo generiranje završi. To nije samo estetski detalj sučelja: upravo to razlikuje chatbota koji djeluje tromo od onoga koji djeluje brzo, čak i kada su performanse poslužitelja identične.

Zašto koristiti streaming

Bez streaminga, korisnici ponekad gledaju u prazan ekran deset do trideset sekundi prije nego što se cijeli odgovor odjednom pojavi. Uz streaming, prve se riječi pojavljuju u manje od sekunde, a čitanje počinje dok generiranje još traje. Ukupno trajanje je isto; percepcija nije. Omogućivanje zahtijeva samo jedan parametar, stream=True, koji povratnu vrijednost funkcije create() pretvara u iterator događaja.

from openai import OpenAI
client = OpenAI()

# BEZ streaminga — čekaj sve
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Pojavljuje se odjednom nakon čekanja

# SA streamingom — token po 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()  # Novi red na kraju

Tipizirani događaji, a ne nediferencirani tok

Stream ne prenosi samo tekst. Obavještava te kada je odgovor stvoren, kada se dodaje svaka stavka izlaza, kada stižu fragmenti i kada se generiranje završava – konačni događaj uključuje metrike potrošnje. Filtriraš prema event.type kako bi znao s čim rukuješ. Ova struktura ti omogućuje, na primjer, prikazivanje indikatora učitavanja čim se okine response.created i zbrajanje tokena na kraju bez dodatnog API poziva.

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

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

U stvarnoj aplikaciji gotovo ćeš uvijek htjeti raditi dvije stvari istovremeno: prikazivati fragmente i rekonstruirati puni tekst kako bi ga mogao arhivirati ili vratiti pozivatelju. Pravilo je jednostavno: akumuliraj dok iteriraš, jer se stream, jednom potrošen, ne može premotati unatrag.

def stream_and_collect(prompt: str) -> str:
    """Streamaj odgovor dok ga prikupljaš."""
    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()  # Novi red
    return full_text

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

Streaming i pozivanje funkcija

Pozivi funkcija također se streamaju, sa svojim vlastitim događajima: argumenti stižu u fragmentima putem response.function_call_arguments.delta, a response.function_call_arguments.done signalizira da je JSON kompletan. To ima važnu praktičnu posljedicu – nikada ne pokušavaj deserializirati argumente prije događaja done, inače ćeš imati samo odsječeni 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]")

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

Asinkroni slučaj

Čim tvoja aplikacija opslužuje više korisnika istovremeno, prebaci se na AsyncOpenAI: sinkroni klijent bi blokirao petlju događaja tijekom cijelog generiranja, uzrokujući čekanje tvojih ostalih zahtjeva. Sintaksa se razlikuje samo u dvije ključne riječi – await pri stvaranju i async for pri iteraciji.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asinkrono streamanje 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 webu je streaming beskoristan ako se zaustavi na tvojem poslužitelju: moraš ga proširiti do preglednika. FastAPI to omogućuje pomoću StreamingResponse, napajanog generatorom koji prosljeđuje fragmente kako stižu.

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

Greške usred streama

Jedan detalj zaslužuje tvoju pozornost: kod streaminga greška se može dogoditi nakon što su fragmenti već prikazani. Korisnik tada vidi odgovor koji je započeo, ali je prekinut. Stoga omotaj samu iteraciju, a ne samo stvaranje streama, kako bi mogao uredno signalizirati prekid umjesto ostavljanja rečenice nedovršenom.

from openai import APIError

def stream_with_errors(prompt: str):
    """Streaming s robusnim rukovanjem greškama."""
    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 točke

  • Omogući streaming s stream=True za iskustvo u stvarnom vremenu
  • Filtriraj događaje prema event.type kako bi ispravno rukovao svakom vrstom podataka
  • response.output_text.delta sadrži fragmente teksta
  • response.completed signalizira kraj i uključuje metrike potrošnje
  • Koristi AsyncOpenAI za streaming u asinkronim aplikacijama
  • Uvijek rukuj greškama, čak i u načinu streaminga