Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Straumēšana un rīki

Nodarbība 9 no 14 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Straumēšana, izsaucot funkcijas
  2. Pamatlikums
  3. Straumēšanas ieviešana ar rīkiem
  4. Rīku izsaukumu rekonstruēšana straumēšanas režīmā
  5. Arhitektūra straumēšanai ar rīkiem
  6. Latence un lietotāja pieredze
  7. Server-Sent Events (SSE) tīmekļa lietotnēm
  8. Galvenās atziņas

Straumēšana, izsaucot funkcijas

Straumēšana ļauj saņemt modeļa atbildi pakāpeniski, pa vienam tokenam. Tas ir būtiski, lai nodrošinātu reaģētspējīgas lietotāja saskarnes. Bet kā straumēšana mijiedarbojas ar funkciju izsaukšanu?

Pamatlikums

Funkciju izsaukumi tiek atgriezti vienā gabalā, nevis straumēti pakāpeniski. Tas ir būtiska atšķirība no parastā teksta, kas ierodas pa vienam tokenam.

Praksē tas nozīmē:

  • Atbildes teksts tiek straumēts pakāpeniski
  • tool_calls ierodas visi vienlaicīgi vienā notikumā

Šis ierobežojums pastāv pamatota iemesla dēļ: rīka izsaukumam ir jābūt pilnīgam (nosaukums + derīgi JSON argumenti), lai tu to varētu izpildīt. Daļējs JSON būtu nelietojams.

Straumēšanas ieviešana ar rīkiem

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

    # Straumēts teksts
    if delta.content:
        collected_content += delta.content
        print(delta.content, end="", flush=True)

    # Rīku izsaukumi (ierodas vienā blokā)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Pārbauda straumes beigām
    if chunk.choices[0].finish_reason == "tool_calls":
        # Modelis sagaida rīku rezultātus
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Atbilde pabeigta, rīks netika izsaukts
        break

Rīku izsaukumu rekonstruēšana straumēšanas režīmā

Dažos gadījumos rīku izsaukumu argumenti straumē var ierasties vairākos gabalos. Tie ir jārekonstruē:

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

Šī buferizācijas pieeja nodrošina, ka tu pareizi rekonstruē katru rīka izsaukumu, pat ja dati ierodas fragmentēti.

Arhitektūra straumēšanai ar rīkiem

Reālā lietotnē tev ir jāapstrādā divas vienlaicīgas straumes:

  1. Reāllaika attēlošana: rādi tekstu, tiklīdz tas ierodas
  2. Rīku izsaukumu uzkrāšana: vāc izsaukumus izpildei
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":
            # Izpildi rīkus, tad atsāc
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latence un lietotāja pieredze

Straumēšana ar rīkiem rada dabiskus pārtraukumus plūsmā:

  1. Lietotājs uzdod jautājumu
  2. Modelis sāk domāt (nav redzamu tokenus)
  3. Modelis nolemj izsaukt rīku (tu saņem tool_call)
  4. Pauze — tu izpildi funkciju
  5. Tu nosūti atpakaļ rezultātu
  6. Modelis ģenerē savu atbildi (tiek straumēta pakāpeniski)

Lietotāja pieredzes uzlabošanai 4. solī parādi indikatoru:

🔍 Meklē laika ziņas Parīzē...

Tas novērš situāciju, kad lietotājs domā, ka lietotne ir iesaldēta.

Server-Sent Events (SSE) tīmekļa lietotnēm

Ja veido tīmekļa API, izmanto SSE, lai pārraidītu straumi:

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

Galvenās atziņas

  • Rīku izsaukumi ierodas vienā gabalā, nevis tiek straumēti pakāpeniski
  • Parasts teksts turpina plūst pa vienam tokenam
  • Rekonstruē fragmentētus rīku izsaukumus, izmantojot buferi, kas indeksēts pēc index
  • Apstrādā divas paralēlas straumes: teksta attēlošanu un rīku izsaukumu vākšanu
  • Rīku izpildes laikā parādi indikatoru, lai uzlabotu lietotāja pieredzi
  • Tīmekļa lietotnēm izmanto SSE