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

Streaming u Għodod

Lezzjoni 9 / 14 Aġġornat 29 ta’ Lulju 2026 Zviluppatur
F'din il-paġna
  1. Streaming mal-Function Calling
  2. Ir-Regola Fundamentali
  3. Implimentazzjoni tas-Streaming bl-Għodod
  4. Rikostruzzjoni tas-Sejħiet tal-Għodod fis-Streaming
  5. Arkitettura għas-Streaming bl-Għodod
  6. Latenza u Esperjenza tal-Utent
  7. Server-Sent Events (SSE) għal Applikazzjonijiet Web
  8. Punti Ewlenin

Streaming mal-Function Calling

Is-streaming jippermettilek tirċievi r-risposta tal-mudell gradwalment, token b’token. Dan huwa essenzjali għal interfaċċji tal-utent li jirreaġixxu malajr. Imma kif jinteraġixxi s-streaming mal-function calling?

Ir-Regola Fundamentali

Is-sejħiet tal-funzjonijiet jintbagħtu f’biċċa waħda, mhux progressivament bħal stream. Din hija differenza kbira mit-test normali, li jasla token b’token.

Fil-prattika:

  • It-test tar-risposta jiġi streamed progressivament
  • Is-tool_calls jaslu kollha f’daqqa f’avveniment wieħed

Dan il-vinċolu jeżisti għal raġuni tajba: sejħa ta’ għodda trid tkun kompluta (isem + arguments JSON validi) biex tkun tista’ tesegwixxiha. JSON parzjali ma jkunx jista’ jintuża.

Implimentazzjoni tas-Streaming bl-Għodod

stream = client.chat.completions.create(
    model="grok-4.5",
    messages=messages,
    tools=tools,
    stream=True
)

collected_tool_calls = []
collected_content = ""

for chunk in stream:
    delta = chunk.choices[0].delta

    # Test streamed
    if delta.content:
        collected_content += delta.content
        print(delta.content, end="", flush=True)

    # Sejħiet tal-għodod (jaslu f'blokk wieħed)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Iċċekkja t-tmiem tal-istream
    if chunk.choices[0].finish_reason == "tool_calls":
        # Il-mudell jistenna r-riżultati tal-għodod
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Ir-risposta ntemmet, l-ebda għodda msejħa
        break

Rikostruzzjoni tas-Sejħiet tal-Għodod fis-Streaming

F’xi każijiet, l-arguments tas-sejħiet tal-għodod jistgħu jaslu f’diversi biċċiet fi ħdan l-istream. Trid tirrikostruwixxihom:

tool_calls_buffer = {}

for chunk in stream:
    delta = chunk.choices[0].delta

    if delta.tool_calls:
        for tc_chunk in delta.tool_calls:
            idx = tc_chunk.index

            if idx not in tool_calls_buffer:
                tool_calls_buffer[idx] = {
                    "id": tc_chunk.id,
                    "function": {
                        "name": tc_chunk.function.name or "",
                        "arguments": ""
                    }
                }

            if tc_chunk.function.name:
                tool_calls_buffer[idx]["function"]["name"] = tc_chunk.function.name
            if tc_chunk.function.arguments:
                tool_calls_buffer[idx]["function"]["arguments"] += tc_chunk.function.arguments

Dan l-approċċ ta’ buffering jiżgura li tirrikostruwixxi kull sejħa tal-għodda korrettament, anke jekk id-data tasal frammentata.

Arkitettura għas-Streaming bl-Għodod

F’applikazzjoni reali, għandek bżonn timmaniġġja żewġ flussi simultanji:

  1. Wirja f’ħin reali: uri t-test hekk kif jasal
  2. Akumulazzjoni tas-sejħiet tal-għodod: iġbor is-sejħiet għall-eżekuzzjoni
async def handle_streaming_response(stream):
    content_parts = []
    tool_calls = []
    current_tool = None

    async for chunk in stream:
        delta = chunk.choices[0].delta

        if delta.content:
            content_parts.append(delta.content)
            yield {"type": "text", "data": delta.content}

        if delta.tool_calls:
            for tc in delta.tool_calls:
                tool_calls.append(tc)

        if chunk.choices[0].finish_reason == "tool_calls":
            # Eżegwixxi l-għodod imbagħad erġa' ibda
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latenza u Esperjenza tal-Utent

Is-streaming bl-għodod jinvolwi waqfiet naturali fil-fluss:

  1. L-utent jagħmel il-mistoqsija tiegħu
  2. Il-mudell jibda jaħseb (l-ebda token viżibbli)
  3. Il-mudell jiddeċiedi li jsejjaħ għodda (tirċievi t-tool_call)
  4. Waqfa — tesegwixxi l-funzjoni
  5. Tibgħat lura r-riżultat
  6. Il-mudell jiġġenera r-risposta tiegħu (streamed progressivament)

Għall-esperjenza tal-utent, uri indikatur matul il-pass 4:

🔍 Qed infittex it-temp f'Pariġi...

Dan jipprevjeni lill-utent milli jaħseb li l-applikazzjoni ffriżat.

Server-Sent Events (SSE) għal Applikazzjonijiet Web

Jekk qed tibni API web, uża SSE biex tgħaddi l-istream:

from fastapi import FastAPI
from fastapi.responses import StreamingResponse

app = FastAPI()

@app.get("/chat")
async def chat(message: str):
    async def event_stream():
        stream = client.chat.completions.create(
            model="grok-4.5",
            messages=[{"role": "user", "content": message}],
            tools=tools,
            stream=True
        )
        for chunk in stream:
            if chunk.choices[0].delta.content:
                yield f"data: {chunk.choices[0].delta.content}\n\n"

    return StreamingResponse(event_stream(), media_type="text/event-stream")

Punti Ewlenin

  • Is-sejħiet tal-għodod jaslu f’biċċa waħda, mhux streamed progressivament
  • It-test normali jkompli jiġi streamed token b’token
  • Irrikostruwixxi sejħiet tal-għodod frammentati b’buffer indizzjat b’index
  • Immaniġġja żewġ flussi paralleli: wirja tat-test + ġbir tas-sejħiet tal-għodod
  • Uri indikatur matul l-eżekuzzjoni tal-għodod għall-UX
  • Uża SSE għal applikazzjonijiet web