Przejdź do głównej treści
Polski— Wybierz język
Menu

Streaming: odbieraj odpowiedzi w czasie rzeczywistym

Lekcja 8 z 22 Zaktualizowano 29 lipca 2026 Programista
Na tej stronie
  1. Streaming: odbieraj odpowiedzi w czasie rzeczywistym
  2. Dlaczego używać streamingu?
  3. Typowane zdarzenia, a nie bezkształtny strumień
  4. Streaming a wywoływanie funkcji
  5. Przypadek asynchroniczny
  6. Błędy w trakcie streamingu
  7. Kluczowe wnioski

Streaming: odbieraj odpowiedzi w czasie rzeczywistym

Dzięki streamingowi otrzymujesz odpowiedź token po tokenie, zamiast czekać na zakończenie całego procesu generowania. To nie tylko kwestia estetyki interfejsu: to właśnie odróżnia chatbota, który wydaje się ociężały, od takiego, który reaguje błyskawicznie, nawet przy identycznej wydajności serwera.

Dlaczego używać streamingu?

Bez streamingu użytkownicy czasem wpatrują się w pusty ekran przez dziesięć do trzydziestu sekund, zanim cała odpowiedź pojawi się naraz. Ze streamingiem pierwsze słowa widoczne są w mniej niż sekundę, a czytanie zaczyna się w trakcie trwania generowania. Całkowity czas trwania jest taki sam, ale odczucie użytkownika – zupełnie inne. Włączenie tej funkcji wymaga tylko jednego parametru: stream=True, który zmienia wartość zwracaną przez create() w iterator zdarzeń.

from openai import OpenAI
client = OpenAI()

# BEZ streamingu — czekaj na wszystko
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Pojawia się wszystko naraz po oczekiwaniu

# ZE streamingiem — token po tokenie
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()  # Nowa linia na końcu

Typowane zdarzenia, a nie bezkształtny strumień

Strumień nie przenosi samego tekstu. Powiadamia cię, gdy odpowiedź zostanie utworzona, gdy dodawany jest każdy element wyjściowy, gdy docierają fragmenty i gdy następuje zakończenie – ostatnie zdarzenie zawiera metryki zużycia tokenów. Filtrujesz dane według event.type, aby wiedzieć, z czym masz do czynienia. Taka struktura pozwala np. wyświetlić wskaźnik ładowania natychmiast po wystąpieniu response.created i podsumować liczbę tokenów na końcu bez konieczności wykonywania drugiego wywołania 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}")

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

W prawdziwej aplikacji prawie zawsze będziesz chciał robić dwie rzeczy jednocześnie: wyświetlać fragmenty na bieżąco i rekonstruować pełny tekst, aby móc go zarchiwizować lub zwrócić wywołującemu. Zasada jest prosta: akumuluj dane podczas iteracji, ponieważ po skonsumowaniu strumienia nie można go cofnąć.

def stream_and_collect(prompt: str) -> str:
    """Strumieniuj odpowiedź, jednocześnie ją zbierając."""
    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()  # Nowa linia
    return full_text

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

Streaming a wywoływanie funkcji

Wywołania funkcji również są strumieniowane i mają własne zdarzenia: argumenty docierają w fragmentach przez response.function_call_arguments.delta, a response.function_call_arguments.done sygnalizuje, że JSON jest kompletny. Ma to istotne konsekwencje praktyczne – nigdy nie próbuj deserializować argumentów przed zdarzeniem done, inaczej otrzymasz tylko ucięty 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]")

# Wyjście:
# [Args] {"city": "Tokyo"}
# [Function call complete]

Przypadek asynchroniczny

Gdy tylko twoja aplikacja obsługuje wielu użytkowników jednocześnie, przełącz się na AsyncOpenAI: klient synchroniczny zablokowałby pętlę zdarzeń na cały czas generowania, zmuszając inne żądania do oczekiwania. Składnia różni się tylko dwoma słowami kluczowymi: await przy tworzeniu i async for podczas iteracji.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Asynchroniczne strumieniowanie odpowiedzi."""
    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."))

W aplikacjach webowych streaming jest bezużyteczny, jeśli zatrzymuje się na twoim serwerze: musisz rozszerzyć go aż do przeglądarki. FastAPI umożliwia to dzięki StreamingResponse, zasilanemu przez generator, który przekazuje fragmenty w miarę ich pojawiania się.

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

Błędy w trakcie streamingu

Jeden szczegół zasługuje na szczególną uwagę: w trybie streamingu błąd może wystąpić już po wyświetleniu niektórych fragmentów. Użytkownik widzi wtedy odpowiedź, która zaczęła się, ale została urwana. Dlatego opakuj w blok obsługi wyjątków samą iterację, a nie tylko tworzenie strumienia, abyś mógł czysto sygnalizować przerwanie, zamiast zostawiać niedokończone zdanie.

from openai import APIError

def stream_with_errors(prompt: str):
    """Strumieniowanie z odporną obsługą błędów."""
    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.")

Kluczowe wnioski

  • Włącz streaming za pomocą stream=True, aby uzyskać doświadczenie w czasie rzeczywistym
  • Filtruj zdarzenia według event.type, aby poprawnie obsługiwać każdy typ danych
  • response.output_text.delta zawiera fragmenty tekstu
  • response.completed sygnalizuje koniec i zawiera metryki zużycia
  • Używaj AsyncOpenAI do streamingu w aplikacjach asynchronicznych
  • Zawsze obsługuj błędy, nawet w trybie streamingu