BroadRouter
Loslegen

LLM-Streaming erklärt: SSE-Chunks, Deltas, Usage und Abbruch

Vom Team von BroadNet Inference · 4 Min. Lesezeit · Veröffentlicht · Aktualisiert

Eine LLM-API streamt eine Chat Completion als Server-Sent Events: Jede data-Zeile enthält einen JSON-Chunk, dessen choices[0].delta das nächste Textstück trägt. Hängen Sie die Deltas aneinander, stoppen Sie bei data: [DONE] und setzen Sie stream_options include_usage, um die Token-Zahlen in einem letzten Chunk mit leerer choices-Liste zu erhalten. Zum Abbrechen schließen Sie die Verbindung.

Ohne Streaming liefert eine Chat Completion nichts, bis die ganze Antwort fertig ist. Eine Antwort mit 600 Tokens bei etwa 100 Tokens pro Sekunde bedeutet mehrere Sekunden Stille. Mit Streaming erscheinen die ersten Wörter, sobald das Modell sie schreibt. Dieser Beitrag behandelt, was tatsächlich über die Leitung geht, wie Sie es parsen, wie Sie die Token-Usage aus einem Stream holen und wie Sie einen Stream sauber stoppen. Die BroadNet-spezifischen Regeln in Kurzform finden Sie im Referenzleitfaden zu Streaming.

Wie sieht ein SSE-Stream auf der Leitung aus?

Server-Sent Events sind eine schlichte HTTP-Antwort mit Content-Type: text/event-stream. Der Server hält die Verbindung offen und schreibt Events. Jedes Event besteht aus einer oder mehreren data:-Zeilen, gefolgt von einer Leerzeile. OpenAI-kompatible APIs legen einen JSON-Chunk in jedes Event und enden mit einem wörtlichen [DONE]:

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"role":"assistant","content":""},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"One, "},"finish_reason":null}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[{"index":0,"delta":{"content":"two, three."},"finish_reason":"stop"}],"usage":null}

data: {"id":"c1","object":"chat.completion.chunk","choices":[],"usage":{"prompt_tokens":14,"completion_tokens":6,"total_tokens":20}}

data: [DONE]

Die Form oben ist illustrativ und gekürzt. Echte Chunks tragen außerdem model und created, und Reasoning-Modelle können Reasoning-Tokens in usage ausweisen.

Was steckt in einem Chunk?

Feld Wo Bedeutung
choices[0].delta.role Erster Chunk Meist assistant. Wird einmal gesendet.
choices[0].delta.content Die meisten Chunks Das nächste Textstück. Kann leer sein.
choices[0].delta.tool_calls Tool Calls Fragmente des Funktionsnamens und der JSON-Argumente, nach index zusammenzufügen.
choices[0].finish_reason Letzter Inhalts-Chunk stop, length oder tool_calls. Bis dahin null.
usage Letzter Chunk, falls angefordert Summen für die ganze Anfrage. Überall sonst null.

Die Kernidee lautet Delta, nicht Snapshot. Jeder Chunk enthält nur das Neue. Sie setzen die Nachricht zusammen, indem Sie die Stücke der Reihe nach aneinanderhängen. Tool Calls werden genauso gestreamt: Die Argumente kommen als String-Fragmente an, die erst mit dem letzten gültiges JSON ergeben. Parsen Sie sie daher erst, wenn finish_reason den Wert tool_calls hat.

Wie bekommen Sie die Token-Usage aus einem Stream?

Eine Antwort ohne Streaming enthält immer usage. Ein Stream nicht, es sei denn, Sie fragen danach. Setzen Sie stream_options: {"include_usage": true}, dann sendet der Server vor [DONE] einen zusätzlichen Chunk. Dieser Chunk enthält die Summen und ein leeres choices-Array. Bei BroadNet Inference kann die Usage außerdem prompt_tokens_details.cached_tokens und completion_tokens_details.reasoning_tokens enthalten, wenn das Modell sie meldet. Genau das brauchen Sie für das Kosten-Logging.

Der häufige Bug: Code, der bei jedem Chunk chunk.choices[0] liest, wirft beim Usage-Chunk einen Indexfehler. Prüfen Sie zuerst choices.

Python: streamen, Usage sammeln, abbrechen

import os
from openai import OpenAI

client = OpenAI(base_url="https://inference.broadnet.ai/v1", api_key=os.environ["BROADNET_API_KEY"])

stream = client.chat.completions.create(
    model="broadnet/deepseek-v4.1-flash",  # DeepSeek V4.1 Flash, a reasoning model
    messages=[{"role": "user", "content": "Explain SSE in three sentences."}],
    stream=True,
    stream_options={"include_usage": True},
    max_tokens=2000,  # reasoning counts toward this limit
)

def user_pressed_stop():  # replace with your own condition
    return False

parts, usage, finish = [], None, None
try:
    for chunk in stream:
        if chunk.choices:
            choice = chunk.choices[0]
            if choice.delta.content:
                parts.append(choice.delta.content)
                print(choice.delta.content, end="", flush=True)
            if choice.finish_reason:
                finish = choice.finish_reason
        if chunk.usage:
            usage = chunk.usage
        if user_pressed_stop():  # your own condition
            break
finally:
    stream.close()  # closes the HTTP connection

text = "".join(parts)

break allein beendet nur das Lesen, der Socket bleibt aber offen, bis er per Garbage Collection aufgeräumt wird. Schließen Sie ihn explizit, damit der Server die Trennung bemerkt.

Node: streamen mit einem AbortController

import OpenAI from "openai";

const client = new OpenAI({ baseURL: "https://inference.broadnet.ai/v1", apiKey: process.env.BROADNET_API_KEY });
const controller = new AbortController();
setTimeout(() => controller.abort(), 30_000); // hard stop after 30 s

const stream = await client.chat.completions.create(
  {
    model: "broadnet/deepseek-v4.1-flash",
    messages: [{ role: "user", content: "Explain SSE in three sentences." }],
    stream: true,
    stream_options: { include_usage: true },
  },
  { signal: controller.signal },
);

let text = "";
for await (const chunk of stream) {
  const delta = chunk.choices[0]?.delta?.content;
  if (delta) text += delta;
  if (chunk.usage) console.log(chunk.usage);
}

Das openai-node-README dokumentiert die Option signal, und sie funktioniert auch noch, während der Body gelesen wird. Verbinden Sie in einem Webserver controller.abort() mit dem close-Event der Client-Anfrage, damit ein Nutzer, der die Seite verlässt, auch die Generierung stoppt. Mehr zur Einrichtung im Leitfaden zum Node SDK.

curl: die rohen Events sehen

curl -N https://inference.broadnet.ai/v1/chat/completions \
  -H "Authorization: Bearer $BROADNET_API_KEY" \
  -H "Content-Type: application/json" \
  -d '{"model":"broadnet/gemma-4-26b-a4b","stream":true,"stream_options":{"include_usage":true},"messages":[{"role":"user","content":"Count to five."}]}'

-N schaltet die Ausgabepufferung ab, sodass Events beim Eintreffen ausgegeben werden. Mit Strg+C brechen Sie ab; das schließt die Verbindung. Der API-Request-Builder erzeugt diese Anfrage sowie die Python- und Node-Varianten für jedes Modell und jede Base-URL.

Wie brechen Sie einen Stream ab, und was kostet das?

Abbrechen heißt bei SSE einfach, die Verbindung zu schließen. Eine „Stopp“-Nachricht gibt es nicht. Was danach passiert, liegt beim Server: Ein sauber implementierter Server bemerkt den geschlossenen Socket und hört auf zu generieren. Tokens, die bis dahin erzeugt wurden, waren echte Arbeit. Die API-Referenz von BroadNet dokumentiert die Abrechnung abgebrochener Streams nicht. Planen Sie also so, als würden bei Pay-as-you-go die bis zur Trennung erzeugten Tokens berechnet, und prüfen Sie Ihre Usage-Daten. Bei einem Pauschalplan kostet ein abgebrochener Stream nichts extra, gibt die Session aber erst frei, wenn der Server stoppt.

Fünf Streaming-Bugs, auf die Sie prüfen sollten

  1. Puffernde Proxys. Nginx und manche CDNs puffern Antworten, sodass der Client alles auf einmal bekommt. Schalten Sie die Proxy-Pufferung für die Streaming-Route ab.
  2. Keine Prüfung auf [DONE]. Eine abgebrochene Verbindung sieht aus wie eine kurze Antwort. Behandeln Sie ein fehlendes [DONE] als unvollständig und notieren Sie die X-Request-ID, wie im Leitfaden zu Fehlern beschrieben.
  3. Retry mitten im Stream. SDKs wiederholen nicht mehr, sobald der Body eintrifft. Ein Retry ist eine neue Anfrage und bei Pay-as-you-go eine neue Rechnung.
  4. finish_reason: length ignorieren. Bei Reasoning-Modellen wie DeepSeek V4.1 Flash zählt das Thinking zu max_tokens, ein kleines Limit kann den Stream also stoppen, bevor sichtbarer Text erscheint. Was Reasoning-Tokens kosten.
  5. Zeilen falsch trennen. Wenn Sie SSE von Hand parsen, puffern Sie Bytes, bis Sie eine Leerzeile sehen. Ein TCP-Read kann mitten in einem JSON-Chunk enden.

Wo BroadNet Inference ins Bild passt

BroadNet Inference nutzt das übliche OpenAI-kompatible Streaming-Format, sodass die SDKs für Python und Node es unverändert parsen. Die Usage im letzten Chunk enthält gecachte und Reasoning-Tokens, wenn das Modell sie meldet. Laut Doku sollte Streaming vor dem Produktiveinsatz trotzdem pro Modell geprüft werden; lassen Sie den Code oben also gegen genau das Modell laufen, das Sie ausliefern. Wenn es Ihnen vor allem darum geht, wie schnell das erste Token ankommt, lesen Sie als Nächstes TTFT vs. Durchsatz. Brauchen Sie Echtzeit-Sprache über WebSockets, ist diese API dafür nicht gebaut; sie bietet Chat Completions und Transkription von Dateien.

Häufige Fragen

Was ist der Unterschied zwischen SSE und WebSockets beim LLM-Streaming?

SSE ist einseitig, vom Server zum Client, über eine normale HTTP-Antwort. Mehr braucht eine Chat Completion nicht, deshalb nutzen OpenAI-kompatible APIs SSE. WebSockets sind bidirektional und brauchen ein Protokoll-Upgrade; sie werden für Echtzeit-Sprache genutzt, nicht für Chat Completions.

Warum ist usage in meinen Streaming-Chunks null?

Usage wird nur gesendet, wenn Sie danach fragen. Ergänzen Sie stream_options mit include_usage auf true. Dann hat jeder Chunk außer dem letzten usage null, und der letzte Chunk trägt die Summen mit einer leeren choices-Liste.

Wird mir ein abgebrochener Stream berechnet?

Das ist je nach Anbieter verschieden, und viele dokumentieren es nicht. Gehen Sie davon aus, dass Tokens berechnet werden, die erzeugt wurden, bevor der Server die geschlossene Verbindung bemerkt hat. Loggen Sie die X-Request-ID und gleichen Sie sie mit Ihren Usage-Daten ab.

Woran erkenne ich, dass ein Stream normal beendet wurde?

Sie haben data: [DONE] erhalten, und der letzte Inhalts-Chunk hatte einen finish_reason wie stop. Ein finish_reason length bedeutet, dass max_tokens die Antwort abgeschnitten hat. Kein [DONE] bedeutet, dass die Verbindung abgebrochen ist.

Macht Streaming das Modell schneller?

Nein. Die gesamte Generierungszeit bleibt gleich. Streaming verkürzt die Zeit, bis der Nutzer die ersten Wörter sieht, und genau das lässt eine Chat-Oberfläche schnell wirken.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen