Siirry pääsisältöön
Suomi— Valitse kieli
Valikko

Streaming ja työkalut

Oppitunti 9 / 14 Päivitetty 29. heinäkuuta 2026 Kehittäjä
Tällä sivulla
  1. Streaming funktion kutsumisen kanssa
  2. Perussääntö
  3. Streamingin toteuttaminen työkalujen kanssa
  4. Työkalukutsujen rekonstruointi streamingissä
  5. Arkkitehtuuri streamingille työkalujen kanssa
  6. Viive ja käyttäjäkokemus
  7. Server-Sent Events (SSE) web-sovelluksille
  8. Keskeiset asiat

Streaming funktion kutsumisen kanssa

Streamingin avulla vastaanotat mallin vastauksen askel askeleelta, token kerrallaan. Tämä on välttämätöntä responsiivisille käyttöliittymille. Mutta miten streaming toimii yhdessä funktion kutsumisen kanssa?

Perussääntö

Funktio-kutsut palautetaan yhdessä osassa, eikä niitä streamata vähitellen. Tämä on merkittävä ero tavalliseen tekstiin, joka saapuu token kerrallaan.

Käytännössä:

  • Vastauksen teksti streamataan vähitellen
  • tool_calls saapuvat kaikki kerralla yhdessä tapahtumassa

Tämä rajoitus on olemassa hyvästä syystä: työkalukutsun on oltava täydellinen (nimi + kelvollinen JSON-argumentti), jotta voit suorittaa sen. Osittainen JSON olisi käyttökelvoton.

Streamingin toteuttaminen työkalujen kanssa

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

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

    # Työkalukutsut (saapuvat yhtenä lohkona)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Tarkista streamin loppu
    if chunk.choices[0].finish_reason == "tool_calls":
        # Malli odottaa työkalun tuloksia
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Vastaus päättyi, työkalua ei kutsuttu
        break

Työkalukutsujen rekonstruointi streamingissä

Joissakin tapauksissa työkalukutsun argumentit voivat saapua streamissa useassa osassa. Sinun on rekonstruoitava ne:

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

Tämä puskurointimenetelmä varmistaa, että rekonstruoit jokaisen työkalukutsun oikein, vaikka data saapuisikin palasina.

Arkkitehtuuri streamingille työkalujen kanssa

Todellisessa sovelluksessa sinun on hallittava kahta samanaikaista streamia:

  1. Reaaliaikainen näyttö: näytä teksti sitä mukaa kun se saapuu
  2. Työkalukutsujen kerääminen: kokoa kutsut suoritusta varten
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":
            # Suorita työkalut ja käynnistä uudelleen
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Viive ja käyttäjäkokemus

Streaming työkalujen kanssa sisältää luontaisia taukoja virrassa:

  1. Käyttäjä esittää kysymyksensä
  2. Malli alkaa miettiä (ei näkyviä tokeneita)
  3. Malli päättää kutsua työkalua (vastaanotat tool_callin)
  4. Tauko – suoritat funktion
  5. Lähetät tuloksen takaisin
  6. Malli generoi vastauksensa (streamataan vähitellen)

Käyttäjäkokemuksen parantamiseksi näytä indikaattori vaiheen 4 aikana:

🔍 Etsitään säätä Pariisissa...

Tämä estää käyttäjää luulemasta, että sovellus on jumissa.

Server-Sent Events (SSE) web-sovelluksille

Jos rakennat web-API:a, käytä SSE:tä streamin välittämiseen:

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

Keskeiset asiat

  • Työkalukutsut saapuvat yhtenä osana, eivät streamattuina vähitellen
  • Tavallinen teksti streamataan edelleen token kerrallaan
  • Rekonstruoi pirstoutuneet työkalukutsut puskurilla, joka on indeksoitu index:n mukaan
  • Käsittele kahta streamia rinnakkain: tekstin näyttö ja työkalukutsujen kerääminen
  • Näytä indikaattori työkalun suorituksen aikana käyttäjäkokemuksen vuoksi
  • Käytä SSE:tä web-sovelluksissa