Spring til hovedindhold
Dansk— Vælg et sprog
Menu

Streaming og værktøjer

Lektion 9 af 14 Opdateret 29. juli 2026 Udvikler
På denne side
  1. Streaming med funktionskald
  2. Den fundamentale regel
  3. Implementering af streaming med værktøjer
  4. Rekonstruktion af værktøjskald ved streaming
  5. Arkitektur for streaming med værktøjer
  6. Latens og brugeroplevelse
  7. Server-Sent Events (SSE) til webapplikationer
  8. Vigtige pointer

Streaming med funktionskald

Streaming giver dig mulighed for at modtage modellens svar inkrementelt, token for token. Dette er afgørende for responsive brugergrænseflader. Men hvordan interagerer streaming med funktionskald?

Den fundamentale regel

Funktionskald returneres i en enkelt blok, ikke streamet progressivt. Dette er en væsentlig forskel fra almindelig tekst, som ankommer token for token.

I praksis:

  • Svartekst streames progressivt
  • tool_calls ankommer samlet i en enkelt begivenhed

Denne begrænsning findes af en god grund: Et værktøjskald skal være komplet (navn + gyldige JSON-argumenter), før du kan udføre det. Delvis JSON ville være ubrugelig.

Implementering af streaming med værktøjer

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

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

    # Værktøjskald (ankommer i en enkelt blok)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Tjek for slutning af stream
    if chunk.choices[0].finish_reason == "tool_calls":
        # Modellen forventer værktøjsresultater
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Svaret er afsluttet, intet værktøj kaldt
        break

Rekonstruktion af værktøjskald ved streaming

I nogle tilfælde kan argumenter til værktøjskald ankomme i flere dele inden for streamen. Du skal rekonstruere dem:

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

Denne buffer-tilgang sikrer, at du rekonstruerer hvert værktøjskald korrekt, selv hvis dataene ankommer fragmenteret.

Arkitektur for streaming med værktøjer

I en rigtig applikation skal du håndtere to samtidige streams:

  1. Realtidsvisning: vis tekst, efterhånden som den kommer ind
  2. Akkumulering af værktøjskald: saml kald til udførelse
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":
            # Udfør værktøjer og genstart
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latens og brugeroplevelse

Streaming med værktøjer indebærer naturlige pauser i flowet:

  1. Brugeren stiller sit spørgsmål
  2. Modellen begynder at tænke (ingen synlige tokens)
  3. Modellen beslutter at kalde et værktøj (du modtager tool_call)
  4. Pause — du udfører funktionen
  5. Du sender resultatet tilbage
  6. Modellen genererer sit svar (streamet progressivt)

For brugeroplevelsens skyld skal du vise en indikator under trin 4:

🔍 Søger efter vejr i Paris...

Dette forhindrer brugeren i at tro, at applikationen er frosset.

Server-Sent Events (SSE) til webapplikationer

Hvis du bygger en web-API, skal du bruge SSE til at videresende streamen:

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

Vigtige pointer

  • Værktøjskald ankommer i en enkelt blok, ikke streamet progressivt
  • Almindelig tekst fortsætter med at blive streamet token for token
  • Rekonstruer fragmenterede værktøjskald med en buffer indekseret efter index
  • Håndtér to streams parallelt: tekstvisning + indsamling af værktøjskald
  • Vis en indikator under udførelse af værktøjer for bedre UX
  • Brug SSE til webapplikationer