Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Straumēšana: saņem atbildes reāllaikā

Nodarbība 8 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Straumēšana: saņem atbildes reāllaikā
  2. Kāpēc straumēt
  3. Tipizēti notikumi, nevis nediferencēta plūsma
  4. Straumēšana un funkciju izsaukumi
  5. Asinhronais gadījums
  6. Kļūdas straumēšanas laikā
  7. Galvenās atziņas

Straumēšana: saņem atbildes reāllaikā

Straumēšana ļauj saņemt atbildi pa vienam tokenim, negaidot, kamēr ģenerēšana ir pilnībā pabeigta. Tas nav tikai lietotāja saskarnes uzlabojums: tieši tas atšķir lēnu čatbotu no ātra, pat ja servera veiktspēja ir identiska.

Kāpēc straumēt

Bez straumēšanas lietotāji dažkārt skatās tukšā ekrānā desmit līdz trīsdesmit sekundes, pirms visa atbilde parādās vienlaikus. Ar straumēšanu pirmie vārdi parādās mazāk nekā sekundes laikā, un lasīšana sākas, kamēr ģenerēšana turpinās. Kopējais ilgums ir tāds pats, bet uztvere – nē. Lai to aktivizētu, pietiek ar vienu parametru stream=True, kas pārvērš create() atgriezto vērtību notikumu iteratorā.

from openai import OpenAI
client = OpenAI()

# BEZ straumēšanas — gaidi visu
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Parādās viss vienlaikus pēc gaidīšanas

# AR straumēšanu — pa tokenim
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()  # Jauna rinda beigās

Tipizēti notikumi, nevis nediferencēta plūsma

Plūsma nesatur tikai tekstu. Tā paziņo, kad atbilde ir izveidota, kad tiek pievienots katrs izvades elements, kad ierodas fragmenti un kad notiek pabeigšana – pēdējais notikums ietver lietojuma metrikas datus. Filtrē pēc event.type, lai zinātu, ar ko strādā. Šī struktūra ļauj, piemēram, parādīt ielādes indikatoru tiklīdz tiek aktivizēts response.created un beigās saskaitīt tokenus, neveicot otru API izsaukumu.

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"[Atbilde izveidota] ID: {event.response.id}")
        case "response.output_item.added":
            print(f"[Jauns izvades elements]")
        case "response.output_text.delta":
            print(f"[Teksts] {event.delta}", end="")
        case "response.output_text.done":
            print(f"\n[Teksts pabeigts]")
        case "response.completed":
            print(f"[Pabeigts] Tokeni: {event.response.usage.total_tokens}")

# Izvade:
# [Atbilde izveidota] ID: resp_abc123
# [Jauns izvades elements]
# [Teksts] Sveiki[Teksts] ! [Teksts] Kā[Teksts] es[Teksts] varu...
# [Teksts pabeigts]
# [Pabeigts] Tokeni: 25

Reālā lietotnē gandrīz vienmēr vēlēsies darīt divas lietas vienlaikus: rādīt fragmentus un rekonstruēt pilno tekstu, lai to arhivētu vai atgrieztu izsaukumam. Noteikums ir vienkāršs: uzkrāj iterācijas laikā, jo tiklīdz plūsma ir izlietota, to nevar atgriezt atpakaļ.

def stream_and_collect(prompt: str) -> str:
    """Straumē atbildi, vienlaikus to uzkrājot."""
    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()  # Jauna rinda
    return full_text

result = stream_and_collect("Uzskaiti 3 Eiropas galvaspilsētas.")
print(f"\nSavāktais teksts ({len(result)} rakstzīmes)")

Straumēšana un funkciju izsaukumi

Arī funkciju izsaukumi tiek straumēti, izmantojot savus notikumus: argumenti ierodas fragmentos caur response.function_call_arguments.delta, bet response.function_call_arguments.done signalizē, ka JSON ir pabeigts. Tam ir svarīga praktiska sekas – nekad nemēģini deserializēt argumentus pirms done notikuma, citādi tev būs tikai saīsināts JSON.

stream = client.responses.create(
    model="gpt-5.6-terra",
    input="Cik ir pulkstenis Tokijā?",
    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"[Arg] {event.delta}", end="")
        case "response.function_call_arguments.done":
            print(f"\n[Funkcijas izsaukums pabeigts]")

# Izvade:
# [Arg] {"city": "Tokyo"}
# [Funkcijas izsaukums pabeigts]

Asinhronais gadījums

Tiklīdz tava lietotne apkalpo vairākus lietotājus vienlaicīgi, pārej uz AsyncOpenAI: sinhronais klients bloķētu notikumu cilpu visas ģenerēšanas laikā, liekot pārējiem pieprasījumiem gaidīt. Sintakse atšķiras tikai ar diviem atslēgvārdiem – await izveides brīdī un async for iterācijas laikā.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Atbildes asinhronā straumēšana."""
    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("Izstāsti īsu joku."))

Tīmeklī straumēšana ir bezjēdzīga, ja tā apstājas pie tava servera: tev tā ir jāpagarina līdz pārlūkprogrammai. FastAPI to ļauj izdarīt ar StreamingResponse, ko baro ģenerators, kas tālāk nodod fragmentus, tiklīdz tie ierodas.

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

Kļūdas straumēšanas laikā

Viena detaļa ir pelnījusi tavu uzmanību: straumēšanas laikā kļūda var rasties pēc tam, kad fragmenti jau ir parādīti. Lietotājs tad redz atbildi, kas sākas, bet tiek pēkšņi pārtraukta. Tāpēc aptver pašu iterāciju, ne tikai plūsmas izveidi, lai tīri signalizētu par pārtraukumu, nevis atstātu teikumu nepabeigtu.

from openai import APIError

def stream_with_errors(prompt: str):
    """Straumēšana ar robustu kļūdu apstrādi."""
    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 kļūda straumēšanas laikā: {e.message}")
    except Exception as e:
        print(f"\nNegaidīta kļūda: {e}")

stream_with_errors("Paskaidro straumēšanu 2 teikumos.")

Galvenās atziņas

  • Aktivizē straumēšanu ar stream=True, lai nodrošinātu reāllaika pieredzi
  • Filtrē notikumus pēc event.type, lai pareizi apstrādātu katru datu veidu
  • response.output_text.delta satur teksta fragmentus
  • response.completed signalizē beigas un ietver lietojuma metrikas datus
  • Izmanto AsyncOpenAI straumēšanai asinhronās lietotnēs
  • Vienmēr apstrādā kļūdas, pat straumēšanas režīmā