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

Streaming ottimizzat

Lezzjoni 5 / 20 Aġġornat 28 ta’ Lulju 2026 Avvanzat
F'din il-paġna
  1. X’ibiddel is-streaming fil-fatt
  2. Il-konsum tas-stream fuq in-naħa tal-klijent
  3. It-trażmissjoni tas-stream lejn il-browser
  4. Iż-żamma tal-konnessjoni matul iż-żmien
  5. Punti Ewlenin

X’ibiddel is-streaming fil-fatt

Is-streaming ma jagħmilx il-mudell iktar mgħaġġel: jagħmel l-istennija sopportabbli. Għal tweġiba li tieħu ħames sekondi biex tiġġenera, utent mingħajr streaming jħares lejn skrin vojt għal ħames sekondi qabel ma jirċievi blokk ta’ test. Bis-streaming, jaraw l-ewwel kliem wara ftit mijiet ta’ millisekondi u jaqraw hekk kif il-mudell jikteb. It-tul totali huwa identiku, iżda l-perċezzjoni hija kompletament differenti. Għalhekk, fil-produzzjoni, li ma tużax is-streaming huwa kważi dejjem difett fid-disinn aktar milli għażla konxja.

Madankollu, is-stream irid jgħaddi mill-katina kollha tiegħek. Stream iġġenerat korrettament mill-API iżda akkumulat mis-server tal-applikazzjoni tiegħek jew ibbufferjat mill-proxy invers tiegħek jasal għand l-utent f’blokk waħda: ħallast il-prezz tal-kumplessità għas-streaming mingħajr ma ġejt il-benefiċċji. Għalhekk, din il-lezzjoni ssegwi l-mogħdija sħiħa, mis-sejħa tal-API sal-browser.

Il-konsum tas-stream fuq in-naħa tal-klijent

Bl-API tar-Risposti, li tissettja stream=True tibdel ir-risposta f’sekwenza ta’ avvenimenti ttajpjati li tgħaddi minnhom hekk kif jaslu. Kull framment ta’ test jasal f’avveniment response.output_text.delta; it-tmiem tas-stream huwa sinjalat minn response.completed, li jġib l-oġġett sħiħ tar-risposta, utli biex tirrikupra l-użu tat-tokens.

import openai

client = openai.OpenAI()

def generate_streaming(prompt: str):
    """Ġenerazzjoni b'streaming bl-API tar-Risposti."""
    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)
        elif event.type == "response.completed":
            print()  # Linja ġdida fl-aħħar
            return event.response

Il-flag flush=True mhuwiex kożmetiku: mingħajru, Python jibbufferja l-output waħdu, u tispiċċa bl-imġiba tal-blokk li kont qed tipprova tevita. Dan id-dettall jirrepeti f’kull saff tal-katina, u hija d-diffikultà ewlenija tas-streaming.

Il-mekkaniżmu jkopri wkoll is-sejħiet tal-funzjonijiet. L-argumenti tal-għodod jinbnew progressivament, u tista’ twerihom hekk kif jiġġeneraw biex tissinjala lill-utent li qed tiġi fformulata tfittxija, minflok ma tħallihom iħarsu lejn interfaċċa ffriżata waqt li l-mudell iħejji s-sejħa tiegħu.

tools = [
    {
        "type": "function",
        "name": "search_product",
        "description": "Searches for a product in the catalog.",
        "parameters": {
            "type": "object",
            "properties": {
                "query": {"type": "string"},
                "category": {"type": "string"},
            },
            "required": ["query"],
        },
    }
]

def streaming_with_tools(prompt: str):
    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        tools=tools,
        stream=True,
    )

    for event in stream:
        match event.type:
            case "response.output_text.delta":
                print(event.delta, end="", flush=True)
            case "response.function_call_arguments.delta":
                # Argumenti tal-funzjoni li qed jiġu ġġenerati bħalissa
                print(f"[arg: {event.delta}]", end="")
            case "response.function_call_arguments.done":
                print(f"\n[Sejħa tal-funzjoni kompluta]")

It-trażmissjoni tas-stream lejn il-browser

Il-frontend tiegħek ma jkellimx l-API ta’ OpenAI direttament—jiklem is-server tiegħek, li għalhekk irid jittrażmetti s-stream. Is-Server-Sent Events (SSE) huma l-format naturali għal dan: tweġiba HTTP li tibqa’ miftuħa, fejn kull linja data: iġġib framment JSON. L-eżempju li ġej jittrażmetti t-test hekk kif jasal, imbagħad jemetti messaġġ finali li fih in-numru ta’ tokens, li jippermettilek tifattura jew tirreġistra mingħajr sejħa oħra.

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
import openai
import json

app = FastAPI()
client = openai.OpenAI()

@app.post("/api/chat")
async def chat_streaming(request: dict):
    prompt = request["message"]

    async def generate():
        stream = client.responses.create(
            model="gpt-5.6-terra",
            input=prompt,
            stream=True,
        )

        for event in stream:
            if event.type == "response.output_text.delta":
                data = json.dumps({"text": event.delta})
                yield f"data: {data}\n\n"
            elif event.type == "response.completed":
                usage = event.response.usage
                data = json.dumps({
                    "end": True,
                    "input_tokens": usage.input_tokens,
                    "output_tokens": usage.output_tokens,
                })
                yield f"data: {data}\n\n"

    return StreamingResponse(
        generate(),
        media_type="text/event-stream",
        headers={
            "Cache-Control": "no-cache",
            "X-Accel-Buffering": "no",  # Importanti għal nginx
        },
    )

Imbagħad hemm il-proxy invers, is-suspettat tas-soltu meta “s-streaming ma jaħdimx fil-produzzjoni għalkemm ħadem lokalment.” B’mod predefinit, nginx jakkumula r-risposta tal-backend qabel ma jittrażmettiha. Il-konfigurazzjoni hawn taħt tiddiżattiva dan l-imġiba għar-rotta speċifika biss.

location /api/chat {
    proxy_pass http://127.0.0.1:8000;
    proxy_buffering off;
    proxy_cache off;
    proxy_set_header Connection "";
    chunked_transfer_encoding on;
}

Iż-żamma tal-konnessjoni matul iż-żmien

Stream miftuħ għal diversi għexieren ta’ sekondi huwa aktar espost minn sejħa qasira: qtugħ fin-netwerk, laqgħa ta’ kwota, u l-ġenerazzjoni tieqaf f’nofs sentenza. L-istrateġija ta’ retry tiegħek trid tagħmel distinzjoni bejn dawn iż-żewġ każijiet, għax jeħtieġu approċċi differenti. Żball fil-konnessjoni għandu jiġi ppruvat mill-ġdid b’backoff esponenzjali, u jagħti ż-żmien lin-netwerk biex jirkupra mingħajr ma jħabbat l-API; qbiż tal-kwota għandu jiġi ppruvat mill-ġdid wara stennija fissa, peress li t-tieqa tal-limitu tar-rata tirrisettja f’intervalli regolari.

import openai

def resilient_streaming(prompt: str, max_attempts: int = 3):
    """Streaming b'ġestjoni tal-iżbalji u retry."""
    for attempt in range(max_attempts):
        try:
            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
                    yield event.delta

            return  # Suċċess, oħroġ

        except openai.APIConnectionError:
            if attempt < max_attempts - 1:
                import time
                time.sleep(2 ** attempt)  # Backoff esponenzjali
            else:
                raise
        except openai.RateLimitError:
            import time
            time.sleep(5)  # Stennija fissa għal-limitu tar-rata

Aġġustament finali jtejjeb il-kumdità tal-qari. L-emissjoni ta’ kull token tipproduċi test imqatta’, speċjalment jekk l-interfaċċa tiegħek tapplika animazzjoni jew jekk ir-riżultat imur għat-test-għal-kliem (text-to-speech). L-akkumulazzjoni sal-aħħar ta’ sentenza tagħti ritmu aktar qrib il-qari uman, bl-ispiża ta’ dewmien żgħir addizzjonali fuq l-ewwel framment.

def streaming_by_sentence(prompt: str):
    """Jakkumula u jipproduċi b'sentenza sħiħa."""
    buffer = ""

    stream = client.responses.create(
        model="gpt-5.6-terra",
        input=prompt,
        stream=True,
    )

    for event in stream:
        if event.type == "response.output_text.delta":
            buffer += event.delta
            # Fittex tmiem is-sentenza
            for separator in [".\n", "!\n", "?\n", ". ", "! ", "? "]:
                if separator in buffer:
                    parts = buffer.split(separator, 1)
                    yield parts[0] + separator.rstrip()
                    buffer = parts[1] if len(parts) > 1 else ""

    if buffer.strip():
        yield buffer.strip()

Innota l-if buffer.strip() finali: mingħajru, tweġiba li ma tispiċċax b’punteġġjatura qawwija titlef l-aħħar kliem tagħha. Dan it-tip ta’ żball jinnota ftit fit-testijiet u jidher fil-produzzjoni fuq tweġibiet imqassra minn max_output_tokens.

Punti Ewlenin

  • Dejjem uża s-streaming fil-produzzjoni biex tnaqqas il-latenza perċepita
  • Ikkonfigura nginx b’proxy_buffering off għal SSE
  • Immaniġġja l-iżbalji b’retry u backoff esponenzjali
  • Akkumula skont is-sentenza għal wiri aktar naturali