Hoppa till huvudinnehåll
Svenska— Välj ett språk
Meny

Strömning och verktyg

Lektion 9 av 14 Uppdaterad 29 juli 2026 Utvecklare
På denna sida
  1. Strömning med funktionsanrop
  2. Den grundläggande regeln
  3. Implementera strömning med verktyg
  4. Återskapa verktygsanrop vid strömning
  5. Arkitektur för strömning med verktyg
  6. Latens och användarupplevelse
  7. Server-Sent Events (SSE) för webbapplikationer
  8. Viktiga punkter

Strömning med funktionsanrop

Strömning låter dig ta emot modellens svar inkrementellt, token för token. Detta är avgörande för responsiva användargränssnitt. Men hur samverkar strömning med funktionsanrop?

Den grundläggande regeln

Funktionsanrop returneras i en enda chunk, inte progressivt strömmade. Detta är en stor skillnad jämfört med vanlig text, som anländer token för token.

I praktiken innebär det:

  • Svarstext strömmas progressivt
  • tool_calls anländer alla på en gång i en enda händelse

Denna begränsning finns av goda skäl: ett verktygsanrop måste vara komplett (namn + giltiga JSON-argument) för att du ska kunna exekvera det. Delvis JSON skulle vara oanvändbar.

Implementera strömning med verktyg

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

    # Strömmad text
    if delta.content:
        collected_content += delta.content
        print(delta.content, end="", flush=True)

    # Verktygsanrop (anländer i ett enda block)
    if delta.tool_calls:
        for tc in delta.tool_calls:
            collected_tool_calls.append(tc)

    # Kontrollera slutet på strömmen
    if chunk.choices[0].finish_reason == "tool_calls":
        # Modellen förväntar sig verktygsresultat
        break
    elif chunk.choices[0].finish_reason == "stop":
        # Svaret är klart, inget verktyg anropat
        break

Återskapa verktygsanrop vid strömning

I vissa fall kan argument för verktygsanrop anlända i flera delar inom strömmen. Du behöver återskapa 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

Denna buffertmetod säkerställer att du återskapar varje verktygsanrop korrekt, även om datan anländer fragmenterad.

Arkitektur för strömning med verktyg

I en riktig applikation måste du hantera två samtidiga strömmar:

  1. Realtidsvisning: visa texten när den kommer in
  2. Ackumulering av verktygsanrop: samla anrop för exekvering
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":
            # Exekvera verktyg och starta om
            results = await execute_tools(tool_calls)
            yield {"type": "tool_results", "data": results}

Latens och användarupplevelse

Strömning med verktyg innebär naturliga pauser i flödet:

  1. Användaren ställer sin fråga
  2. Modellen börjar tänka (inga synliga tokens)
  3. Modellen beslutar sig för att anropa ett verktyg (du receives tool_call)
  4. Paus — du exekverar funktionen
  5. Du skickar tillbaka resultatet
  6. Modellen genererar sitt svar (strömmas progressivt)

För användarupplevelsen bör du visa en indikator under steg 4:

🔍 Söker efter väder i Paris...

Detta förhindrar att användaren tror att applikationen har fryst.

Server-Sent Events (SSE) för webbapplikationer

Om du bygger ett webb-API använder du SSE för att vidarebefordra strömmen:

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

Viktiga punkter

  • Verktygsanrop anländer i en enda chunk, inte progressivt strömmade
  • Normal text fortsätter att strömmas token för token
  • Återskapa fragmenterade verktygsanrop med en buffert indexerad efter index
  • Hantera två strömmar parallellt: textvisning + insamling av verktygsanrop
  • Visa en indikator under verktygsexekvering för bra UX
  • Använd SSE för webbapplikationer