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

Implimenta l-istreaming fil-Python

Lezzjoni 6 / 16 Aġġornat 2 ta’ Novembru 2026 Zviluppatur
F'din il-paġna
  1. Mill-prototip għall-produzzjoni
  2. Il-mudell bażiku
  3. Immaniġġjar komprensiv tal-iżbalji
  4. Istrejmjar asinkronu ma’ asyncio
  5. Integrazzjoni ma’ FastAPI
  6. Kejl tal-prestazzjoni
  7. Punti Ewlenin

Mill-prototip għall-produzzjoni

Il-lezzjoni ta’ qabel kopriet il-kunċetti tal-istreaming SSE. L-aktar parti diffiċli fadal: li tħawwel loop ta’ dimostrazzjoni f’klijent li jiflaħ taħt piż, jissopravvivi għal żbalji fin-netwerk, u jipprovdi data lil interfaċċja web. Din il-lezzjoni ssegwi t-trajettorja reali ta’ proġett—l-ewwel l-istruttura bażika, imbagħad l-immaniġġjar tal-iżbalji, wara l-asinkronija, l-espożizzjoni HTTP, u fl-aħħar il-kejl.

Il-mudell bażiku

Kollox jibda b’din l-istruttura ta’ għaxar linji, li se tadatta għal kull proġett. Tagħmel żewġ affarijiet fl-istess ħin: turi t-tokens hekk kif jaslu u takkumulahom għar-ritorn tal-funzjoni.

from mistralai.client import Mistral
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

def stream_chat(messages: list, model: str = "mistral-large-latest") -> str:
    """Tibgħat talba ta' streaming u turi t-tokens f'ħin reali."""
    stream = client.chat.stream(
        model=model,
        messages=messages
    )

    full_text = ""
    for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            full_text += content
            print(content, end="", flush=True)

    print()  # Linja ġdida
    return full_text

Din il-verżjoni taħdem għal skritt lokali. Għandha difett fatali fil-produzzjoni: tistampa fit-terminal, allura ma tista’ tagħmel xejn ħlief xogħol fit-terminal.

Immaniġġjar komprensiv tal-iżbalji

Żbalji fin-netwerk, timeouts, u limiti ta’ rati mhumiex ipotetiċi: huma ċertezzi fuq skala ta’ traffiku reali. Il-klijent hawn taħt jindirizza ż-żewġ problemi. Jerġa’ jipprova awtomatikament l-iżbalji 429 b’backoff esponenzjali, u ma jistampa xejn aktar: jemetti avvenimenti ttajpjati permezz ta’ yield, u jħalli lil min sejjaħ jiddeċiedi x’għandu jagħmel bihom—jurihom, jibgħathom lejn WebSocket, jew jiktebhom f’database.

from mistralai.client import Mistral
from mistralai.client.errors import SDKError
import os
import time

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

def stream_with_retry(
    messages: list,
    model: str = "mistral-large-latest",
    max_retries: int = 3,
    max_tokens: int = 2000
) -> dict:
    """Streaming b'tentattiv mill-ġdid awtomatiku u metriċi."""
    for attempt in range(max_retries):
        try:
            stream = client.chat.stream(
                model=model,
                messages=messages,
                max_tokens=max_tokens
            )

            full_text = ""
            finish_reason = None
            chunk_count = 0

            for chunk in stream:
                delta = chunk.data.choices[0].delta
                if delta.content:
                    full_text += delta.content
                    chunk_count += 1
                    yield {"type": "token", "content": delta.content}

                if chunk.data.choices[0].finish_reason:
                    finish_reason = chunk.data.choices[0].finish_reason

            yield {
                "type": "done",
                "full_text": full_text,
                "finish_reason": finish_reason,
                "chunks": chunk_count
            }
            return

        except SDKError as e:
            if e.status_code == 429 and attempt < max_retries - 1:
                wait_time = 2 ** attempt  # Backoff esponenzjali
                yield {"type": "retry", "wait": wait_time, "attempt": attempt + 1}
                time.sleep(wait_time)
            else:
                yield {"type": "error", "message": str(e), "status": e.status_code}
                return

        except Exception as e:
            yield {"type": "error", "message": str(e), "status": None}
            return

Il-backoff esponenzjali 2 ** attempt jistenna sekonda, imbagħad 2, imbagħad 4. Din il-progressjoni mhix dekorattiva: jekk il-klijenti kollha tiegħek jerġgħu jippruvaw bl-istess ritmu fiss, huma jolqtu l-API f’bursts sinkronizzati u jkomplu jsaħħu s-saturazzjoni li qed ibatu minnha. Innota wkoll li biss l-iżball 429 jipprovoka tentattiv mill-ġdid—li terġa’ tipprova 401 minħabba ċavetta invalida biss iddewwem id-dijanjosi.

Fuq in-naħa ta’ min sejjaħ, il-konsum isir qari sempliċi ta’ avveniment:

messages = [
    {"role": "system", "content": "Int assistent tekniku."},
    {"role": "user", "content": "Spjega d-disinn patterns fil-Python."}
]

for event in stream_with_retry(messages):
    if event["type"] == "token":
        print(event["content"], end="", flush=True)
    elif event["type"] == "retry":
        print(f"\n[Tentattiv mill-ġdid {event['attempt']}, nistenna {event['wait']}s...]")
    elif event["type"] == "done":
        print(f"\n\n--- Lest ({event['chunks']} chunks, {event['finish_reason']})")
    elif event["type"] == "error":
        print(f"\n[Żball: {event['message']}]")

Istrejmjar asinkronu ma’ asyncio

Il-klijent sinkronu jimblokaw it-thread tiegħu għall-ġenerazzjoni kollha. Fuq server web li jrid jimmaniġġja ħamsin konversazzjoni simultanja, dan ifisser li timmobilizza ħamsin thread biss biex tistenna. Il-klijent asinkronu jneħħi din ir-restrizzjoni:

from mistralai.client import Mistral
import asyncio
import os

client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

async def async_stream_chat(messages: list) -> str:
    """Streaming asinkronu għal applikazzjonijiet konkorrenti."""
    stream = await client.chat.stream_async(
        model="mistral-large-latest",
        messages=messages
    )

    full_text = ""
    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            full_text += content
            print(content, end="", flush=True)

    print()
    return full_text

# Eżekuzzjoni
async def main():
    messages = [{"role": "user", "content": "Merħba, ippreżenta ruħek."}]
    result = await async_stream_chat(messages)
    print(f"\nTotal: {len(result)} karattri")

asyncio.run(main())

Il-loġika hija identika għall-verżjoni sinkrona; biss stream_async, l-await fuq is-sejħa, u l-async for fuq il-loop jinbidlu.

Integrazzjoni ma’ FastAPI

Sussegwentement, trid toħroġ dan l-istreaming mill-proċess Python tiegħek u ddahħlu fil-browser. FastAPI jimmaniġġja dan b’StreamingResponse, sakemm terġa’ tiffurmatta kull framment għall-format SSE li rajna fil-lezzjoni ta’ qabel:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse
from mistralai.client import Mistral
import os
import json

app = FastAPI()
client = Mistral(api_key=os.getenv("MISTRAL_API_KEY"))

async def generate_stream(prompt: str):
    """Ġeneratur SSE għal FastAPI."""
    stream = await client.chat.stream_async(
        model="mistral-large-latest",
        messages=[{"role": "user", "content": prompt}]
    )

    async for chunk in stream:
        content = chunk.data.choices[0].delta.content
        if content:
            data = json.dumps({"content": content})
            yield f"data: {data}\n\n"

    yield "data: [DONE]\n\n"

@app.get("/chat/stream")
async def chat_stream(prompt: str):
    return StreamingResponse(
        generate_stream(prompt),
        media_type="text/event-stream"
    )

Żewġ dettalji jiddeterminaw jekk dan l-endpoint jaħdimx sewwa. Il-linja doppja vojta \n\n li tispiċċa kull yield hija dak li jifred l-avvenimenti fil-protokoll SSE: mingħajrha, il-browser jistenna għal żmien indefinit għal avveniment li jqisu mhux lest. U media_type="text/event-stream" huwa dak li jippermetti lill-klijent JavaScript jikkonsma r-risposta b’EventSource minflok fetch standard.

Kejl tal-prestazzjoni

Ladarba l-istreaming ikun postu, trid tkun taf kif qed jaħdem. Żewġ metriċi huma biżżejjed biex tmexxi l-ottimizzazzjoni:

import time

start = time.perf_counter()
first_token_time = None
token_count = 0

stream = client.chat.stream(
    model="mistral-large-latest",
    messages=[{"role": "user", "content": "Ikteb paragrafu dwar Pariġi."}]
)

for chunk in stream:
    if chunk.data.choices[0].delta.content:
        if first_token_time is None:
            first_token_time = time.perf_counter() - start
        token_count += 1

total_time = time.perf_counter() - start

print(f"Time to First Token (TTFT): {first_token_time:.3f}s")
print(f"Tokens iġġenerati: {token_count}")
print(f"Ħin totali: {total_time:.3f}s")
print(f"Tokens/sekonda: {token_count / total_time:.1f}")

TTFT (Time to First Token)—il-ħin bejn l-ibgħat tat-talba u l-wiri tal-ewwel karattru—hija l-aktar metrika importanti għall-esperjenza tal-utent. Tieħu preċedenza fuq il-ħin totali: ġenerazzjoni ta’ ħmistax-il sekonda li l-ewwel kelma tagħha tidher fi tliet għaxriet ta’ sekonda se tidher mgħaġġla, filwaqt li ġenerazzjoni ta’ ħames sekondi mogħtija f’blokk wieħed se tidher bil-mod. Kejjilha fuq il-prompts reali tiegħek, inkluż il-messaġġ tas-sistema—messaġġ tas-sistema ta’ żewġ paġni jtawwal it-TTFT qabel ma jiġi ġġenerat l-ewwel token.

Punti Ewlenin

  • Uża mudell ta’ ġeneratur (yield) biex tippropaga t-tokens tal-istreaming
  • Implimenta backoff esponenzjali għal żbalji 429 (limitu ta’ rata)
  • Ippreferixxi stream_async għal applikazzjonijiet web konkorrenti
  • Kejjel it-TTFT u t-tokens/sekonda biex tottimizza l-prestazzjoni
  • Ma’ FastAPI, StreamingResponse + text/event-stream jippropagaw l-SSE lejn il-browser