Aqbeż għall-kontenut ewlieni
Malti— Agħżel lingwa
Menu

Streaming: Irċievi Tweġibiet f'Ħin Reali

Lezzjoni 8 / 22 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Streaming: Irċievi Tweġibiet f’Ħin Reali
  2. Għaliex tuża l-Streaming
  3. Avvenimenti Tipizzati, Mhux Fluss Indifferenzjat
  4. Streaming u Sejħiet ta’ Funzjonijiet
  5. Il-Każ Asinkronu
  6. Żbalji Nofs il-Fluss
  7. Punti Ewlenin

Streaming: Irċievi Tweġibiet f’Ħin Reali

Il-streaming jippermettilek tirċievi t-tweġiba token b’token minflok ma tistenna sakemm tiġi ġġenerata kollha. Dan mhux biss ittejjeb l-interfaċċja: huwa dak li jissepara chatbot li jidher bil-mod minn wieħed li jidher mgħaġġel, anke jekk il-prestazzjoni tas-server tkun l-istess.

Għaliex tuża l-Streaming

Mingħajr streaming, l-utenti kultant iħarsu lejn skrin vojt għal għaxar sa tletin sekonda qabel ma tidher it-tweġiba sħiħa f’daqqa. Bis-streaming, l-ewwel kliem jidher f’anqas minn sekonda, u l-qari jibda waqt li l-ġenerazzjoni tkompli. It-tul totali huwa l-istess; il-perċezzjoni mhix. Biex tattivah, teħtieġ biss parametru wieħed, stream=True, li jbiddel il-valur ta’ ritorn ta’ create() f’iteratur ta’ avvenimenti.

from openai import OpenAI
client = OpenAI()

# MHUX bis-streaming — stenna kollox
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Write a paragraph about artificial intelligence."
)
print(response.output_text)  # Jidher kollu f'daqqa wara l-istennija

# BIS-streaming — token b'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()  # Linja ġdida fl-aħħar

Avvenimenti Tipizzati, Mhux Fluss Indifferenzjat

Il-fluss ma jġorrx biss test. Jgħarrafek meta tinħoloq it-tweġiba, meta jiżdied kull oġġett ta’ output, meta jaslu l-frammenti, u meta sseħħ il-kompletament—l-aħħar avveniment jinkludi metriċi ta’ użu. Tiffiltra fuq event.type biex tkun taf x’inhu qed timmaniġġja. Din l-istruttura tippermettilek, pereżempju, turi indikatur ta’ tagħbija hekk kif jitfaċċa response.created u tgħodd it-tokens fl-aħħar mingħajr sejħa API oħra.

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

F’applikazzjoni reali, kważi dejjem trid tagħmel żewġ affarijiet fl-istess ħin: turi l-frammenti u tirrikostruwixxi t-test sħiħ biex tkun tista’ tarkivjah jew tirritornah lis-sejjaħ. Ir-regola hija sempliċi: akkumula hekk kif tittera, għax darba li l-fluss jiġi kkunsmat, ma jistax jerġa’ lura.

def stream_and_collect(prompt: str) -> str:
    """Istreamja t-tweġiba filwaqt li tiġborha."""
    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()  # Linja ġdida
    return full_text

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

Streaming u Sejħiet ta’ Funzjonijiet

Is-sejħiet tal-funzjonijiet huma mstreamjati wkoll, bl-avvenimenti tagħhom stess: l-argumenti jaslu f’frammenti permezz ta’ response.function_call_arguments.delta, u response.function_call_arguments.done jissinjala li l-JSON huwa sħiħ. Dan għandu konsegwenza prattika importanti—qatt tipprova tiddeserjalizza l-argumenti qabel l-avveniment done, inkella jkollok biss JSON imqatta’.

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]

Il-Każ Asinkronu

Hekk kif l-applikazzjoni tiegħek isservi diversi utenti simultanjament, ibdel għal AsyncOpenAI: il-klijent sinkronu jimblokaw il-linja tal-avvenimenti għall-ġenerazzjoni kollha, u jġiegħel lit-talbiet l-oħra jistennew. Is-sintassi tvarja b’żewġ kelmiet biss—await waqt il-ħolqien u async for waqt l-iterazzjoni.

from openai import AsyncOpenAI
import asyncio

async_client = AsyncOpenAI()

async def stream_async(prompt: str):
    """Streaming asinkronu tat-tweġiba."""
    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."))

Fuq il-web, il-streaming ma jservi xejn jekk jieqaf fis-server tiegħek: trid testendih sal-browser. FastAPI jippermetti dan b’StreamingResponse, imħaddem minn ġeneratur li jgħaddi l-frammenti hekk kif jaslu.

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

Żbalji Nofs il-Fluss

Dettall wieħed jistħoqqilhom attenzjoni: fil-streaming, żball jista’ jseħħ wara li diġà ntwrew xi frammenti. L-utent imbagħad jara tweġiba li tibda imma tinqata’. Għalhekk, poġġi l-iterazzjoni nnifisha f’blokk ta’ protezzjoni, mhux biss il-ħolqien tal-fluss, biex tkun tista’ tissinjala l-interruzzjoni b’mod nadif minflok ma tħalli sentenza mhux mitmuma.

from openai import APIError

def stream_with_errors(prompt: str):
    """Streaming b'ġestjoni robusta tal-iżbalji."""
    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.")

Punti Ewlenin

  • Attiva l-streaming b’stream=True għal esperjenza f’ħin reali
  • Iffiltra l-avvenimenti skont event.type biex timmaniġġja kull tip ta’ data korrettament
  • response.output_text.delta fih frammenti ta’ test
  • response.completed jissinjala t-tmiem u jinkludi metriċi ta’ użu
  • Uża AsyncOpenAI għall-streaming f’applikazzjonijiet asinkroni
  • Dejjem immaniġġja l-iżbalji, anke f’modalità ta’ streaming