BroadRouter
Loslegen

LLM-Batch-Verarbeitung ohne Batch API: ein fortsetzbarer Runner

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

Ohne Batch API betreiben Sie den Job selbst: Items aus einer JSONL-Datei lesen, gleichzeitige Anfragen auf das Limit des Schlüssels begrenzen, Anfragestarts unter dem Minutenlimit takten, 429 und 5xx mit begrenztem Backoff wiederholen und jedes Ergebnis mit seiner ID anhängen. Beim Neustart überspringen Sie erledigte IDs. Meist bestimmt das Rate Limit, nicht das Modell, wann der Job fertig ist.

Manche LLM-Jobs sind keine Chats. Sie haben 50.000 Support-Tickets zu labeln, 200.000 Produktbeschreibungen zu übersetzen oder eine Million Bewertungen einzustufen. Anbieter wie OpenAI und Anthropic verkaufen dafür eine Batch API. Viele OpenAI-kompatible APIs, darunter BroadNet Inference, haben keine. Dieser Beitrag zeigt, wie Sie den Job selbst ausführen: abschätzen, wie lange er dauert, einen Runner schreiben, der die Limits einhält, und dafür sorgen, dass er sich gefahrlos anhalten und neu starten lässt.

BroadRouter ist die eigene Website von BroadNet, die Beispielrechnungen nutzen also die veröffentlichten Limits von BroadNet. Die Methode funktioniert mit jeder Chat-Completions-API; setzen Sie die Zahlen Ihres Anbieters ein.

Hat BroadNet Inference eine Batch API?

Nein. Die API-Referenz, geprüft am 15. November 2026, dokumentiert POST /v1/chat/completions, POST /v1/audio/transcriptions und GET /v1/models (eine Modellliste) sowie Konto-Endpunkte unter /portal/. Es gibt keinen Batch- oder Datei-Upload-Endpunkt und keinen Batch-Rabatt. Ein Massenjob ist eine Schleife normaler Anfragen.

Das bietet Ihnen eine gehostete Batch API, damit Sie wissen, was Sie nachbauen:

Batch API von OpenAI Message Batches von Anthropic Ihr eigener Runner
Preis 50 % unter synchron 50 % Rabatt Normaler Preis
Bearbeitungszeit Innerhalb von 24 Stunden Meist innerhalb 1 Stunde; verfällt nach 24 Bestimmt durch Ihre Rate Limits
Größe pro Batch 50.000 Anfragen oder 200 MB 100.000 Anfragen oder 256 MB Beliebig
Rate Limits Getrennt von den Limits pro Modell Gelten für Anfragen in der Warteschlange Die Limits Ihres Schlüssels
Reihenfolge der Ergebnisse Kann abweichen; Abgleich über custom_id Abgleich über custom_id Ergebnisse per ID als Schlüssel

Zwei Lehren lassen sich übertragen. Beide Anbieter verlangen eine ID pro Anfrage, weil die Ergebnisse nicht in Reihenfolge zurückkommen. Keiner verspricht eine Antwort in Sekunden. Ihr Runner sollte genauso arbeiten: IDs an allem und eine Planung in Stunden.

Wenn 50 % Rabatt wichtiger sind als die Bearbeitungszeit und die benötigten Modelle dort verfügbar sind, ist eine gehostete Batch API eventuell das günstigere Werkzeug. Rechnen Sie beides mit dem LLM-API-Kostenrechner durch, bevor Sie bauen.

Wie lange dauert der Job?

Rechnen Sie das aus, bevor Sie Code schreiben. Zwei Limits begrenzen den Durchsatz, und das langsamere gewinnt:

  • Limit gleichzeitiger Anfragen ÷ Latenz. Mit 4 gleichzeitigen Anfragen und 2 Sekunden pro Anfrage schaffen Sie 2 pro Sekunde.
  • Anfragen pro Minute. Bei 30 pro Minute können Sie 0,5 pro Sekunde starten, egal wie schnell das Modell ist.

Ein Pay-as-you-go-Schlüssel von BroadNet erlaubt 4 gleichzeitige Anfragen und 30 pro Minute. Bei den Werten in der API-Referenz zum Zeitpunkt unserer Prüfung (30 pro Minute und 4 gleichzeitig, 2026-11-15) ist das Rate Limit die Grenze, sofern nicht jede Anfrage länger als 8 Sekunden dauert, und die Tabelle unten rechnet mit 30 pro Minute:

Items Ein Item pro Anfrage 20 Items pro Anfrage
10.000 5,6 Stunden 17 Minuten
100.000 2,3 Tage 2,8 Stunden
1.000.000 23 Tage 28 Stunden

Bei 30 Anfragen pro Minute schafft ein Schlüssel 1.800 Anfragen pro Stunde oder 43.200 pro Tag. Retries zählen mit: Jeder 429, den Sie auslösen, verbraucht einen Slot.

Die zweite Spalte ist der größte Hebel. Kurze Items wie Bewertungen oder Ticket-Betreffzeilen lassen sich zu 10 bis 50 pro Anfrage als nummerierte Liste senden, mit einem JSON-Array als Antwort. Prüfen Sie, dass das Array einen Eintrag pro Input hat und jeder seine Nummer trägt. Der Beitrag zur Klassifizierung arabischer Texte zeigt das Muster. Lange Items lassen sich nicht bündeln: Jede Anfrage muss weiterhin ins Kontextfenster des Modells passen, und die Qualität kann mit wachsender Liste sinken. Testen Sie das Bündeln an 200 Items, bevor Sie sich darauf verlassen.

Verteilen Sie einen Job nicht ungefragt auf mehrere Schlüssel, um ein Limit pro Schlüssel zu umgehen. Die Acceptable Use Policy von BroadNet verbietet die Umgehung von Rate-, Parallelitäts- oder Budgetlimits. Wenn Sie mehr brauchen, fragen Sie BroadNet oder nutzen Sie Plan-Sessions, siehe unten. Der Batch-Job-Planer erledigt diese Rechnung für Ihre Item-Zahl, Latenz und Limits.

Wie sieht ein fortsetzbarer Runner aus?

Dieser Runner liest items.jsonl (ein {"id", "text"}-Objekt pro Zeile) und hängt pro Item eine Ergebniszeile an results.jsonl an. Er braucht nur das OpenAI Python SDK.

import asyncio, json, os, random, time
from openai import AsyncOpenAI, APIStatusError, APIConnectionError, APITimeoutError

client = AsyncOpenAI(base_url=os.environ.get("BASE_URL", "https://inference.broadnet.ai/v1"),
                     api_key=os.environ["BROADNET_API_KEY"],
                     max_retries=0,        # we retry ourselves, with a cap we can see
                     timeout=120)
MODEL = os.environ.get("MODEL", "broadnet/deepseek-v4.1-flash")
IN_FLIGHT = int(os.environ.get("IN_FLIGHT", "4"))     # PAYG key: 4 in flight. Plan: 1 per session.
RPM = int(os.environ.get("RPM", "30"))                # PAYG key: 30 requests a minute
MAX_ATTEMPTS = 6

class Pacer:
    """Spaces request starts at least 60/RPM seconds apart, across all workers."""
    def __init__(self, rpm):
        self.gap, self.next, self.lock = 60 / rpm, 0.0, asyncio.Lock()
    async def wait(self):
        async with self.lock:
            now = time.monotonic()
            delay = max(0.0, self.next - now)
            self.next = max(now, self.next) + self.gap
        await asyncio.sleep(delay)

def retryable(e):
    if isinstance(e, (APIConnectionError, APITimeoutError)):
        return True
    return isinstance(e, APIStatusError) and e.status_code in (429, 500, 502, 503, 504)

async def call(item, pacer):
    for attempt in range(MAX_ATTEMPTS):
        await pacer.wait()                          # every attempt counts against the rate limit
        try:
            r = await client.chat.completions.create(
                model=MODEL, max_tokens=1500, reasoning_effort="low",
                messages=[{"role": "system", "content": "Classify the review as positive, negative or mixed. Reply with one word."},
                          {"role": "user", "content": item["text"]}])
            c = r.choices[0]
            return {"id": item["id"], "ok": True, "finish_reason": c.finish_reason,
                    "output": c.message.content, "usage": r.usage.model_dump() if r.usage else None}
        except Exception as e:
            if not retryable(e) or attempt == MAX_ATTEMPTS - 1:
                return {"id": item["id"], "ok": False, "error": repr(e)[:300]}
            await asyncio.sleep(random.uniform(0, min(60, 2 ** attempt)))   # full jitter, capped

async def run(in_path, out_path):
    done = set()
    if os.path.exists(out_path):                    # resume: skip ids that already succeeded
        with open(out_path) as f:
            done = {json.loads(l)["id"] for l in f if l.strip() and json.loads(l).get("ok")}
    todo = [it for it in map(json.loads, open(in_path)) if it["id"] not in done]
    print(f"{len(done)} done, {len(todo)} to go")
    pacer, queue = Pacer(RPM), asyncio.Queue()
    for it in todo:
        queue.put_nowait(it)
    with open(out_path, "a") as out:
        async def worker():
            while True:
                try:
                    it = queue.get_nowait()
                except asyncio.QueueEmpty:
                    return
                res = await call(it, pacer)
                out.write(json.dumps(res, ensure_ascii=False) + "\n")
                out.flush()                         # one line per finished item = the checkpoint
        await asyncio.gather(*(worker() for _ in range(IN_FLIGHT)))

if __name__ == "__main__":
    import sys
    asyncio.run(run(sys.argv[1], sys.argv[2]))

Starten Sie ihn mit python batch_run.py items.jsonl results.jsonl. Wir haben genau diese Datei gegen einen lokalen Mock-Server getestet, der zufällig 429 (8 %) und 500 (5 %) zurückgab und alles über 4 gleichzeitige Anfragen oder 30 Starts pro Minute ablehnte. 25 Items waren nach 55 Sekunden mit 28 Anfragen (3 Retries) fertig, und in keinem 60-Sekunden-Fenster gab es mehr als 30 Starts. Mit auf 300 pro Minute angehobenem Mock-Limit, um Zeit zu sparen, setzte ein nach 10 Sekunden abgebrochener Lauf mit 120 Items bei 39 gespeicherten Ergebnissen wieder ein und endete mit 120 eindeutigen IDs ohne Duplikate.

Warum ein Worker-Pool und nicht asyncio.gather?

Der 429-Leitfaden nutzt eine Semaphore um asyncio.gather. Für ein paar hundert Aufrufe ist das in Ordnung. Für einen großen Job ist ein fester Pool von Workern, die aus einer Queue ziehen, besser:

  • Speicher. gather erzeugt im Voraus einen Task pro Item. Ein Pool hält nur die Items, die gerade laufen.
  • Parallelität ist die Pool-Größe. Vier Worker können nie fünf offene Anfragen haben.
  • Ergebnisse fließen auf die Platte, sobald sie fertig sind, in beliebiger Reihenfolge, mit der ID als Schlüssel.

Der Pacer kümmert sich um das zweite Limit. Eine Semaphore allein verhindert, dass Sie 4 gleichzeitige Anfragen überschreiten, aber wenn Anfragen eine Sekunde dauern, würden vier Worker 240 pro Minute starten und bei den meisten einen 429 bekommen. Der Pacer setzt die Starts über alle Worker hinweg 2 Sekunden auseinander, Retries eingeschlossen.

Wie bleiben Retries sicher?

Wiederholen Sie nur, was beim zweiten Versuch gelingen kann:

Antwort Aktion
429 Zurückhalten und wiederholen; die Doku von BroadNet sagt “use response details and bounded backoff” (Übersetzung: Antwortdetails und begrenzten Backoff nutzen)
500, 502, 503, 504, Timeouts, abgebrochene Verbindungen Mit begrenztem exponentiellem Backoff wiederholen
400, 422 Anfrage korrigieren; ein Retry liefert denselben Fehler
401, 402, 403 Job anhalten; Schlüssel, Guthaben oder Richtlinie brauchen Aufmerksamkeit
413 Item kürzen

Der Runner schaltet die eigenen Retries des SDK ab (max_retries=0), damit es genau eine Retry-Strategie mit sichtbarer Obergrenze gibt. Der Backoff ist exponentiell mit Full Jitter und auf 60 Sekunden begrenzt, damit Worker, die gemeinsam gescheitert sind, nicht gemeinsam wiederholen. Nach sechs Versuchen wird das Item als "ok": false geschrieben, und der Job läuft weiter. Ein fehlerhaftes Item hält nie eine Million auf.

Ein Modellaufruf hat keine Seiteneffekte, die Zustellung erfolgt hier also mindestens einmal: Stirbt der Prozess mitten in einer Anfrage, wird dieses Item beim Neustart erneut gesendet, und Sie zahlen es doppelt. Das ist die einzige Verschwendung. Schreibt der Job auch in ein anderes System, etwa Tickets oder E-Mails, machen Sie diesen Schreibvorgang per Item-ID idempotent und erledigen ihn in einem separaten Durchlauf über results.jsonl. Der Beitrag zu lang laufenden Agenten behandelt idempotente Seiteneffekte ausführlich.

Wie funktioniert das Checkpointing?

Die Ausgabedatei ist der Checkpoint. Jedes fertige Item ist eine geflushte Zeile; nach einem Absturz, einem Deploy oder Strg+C liest der nächste Lauf die Datei, sammelt die IDs mit "ok": true und stellt nur den Rest in die Queue. Zuvor gescheiterte Items werden im nächsten Lauf wiederholt, und ihre neue Zeile wird angehängt. Nehmen Sie beim Auslesen pro ID die letzte Zeile.

Drei Gewohnheiten sorgen dafür, dass das über Tage hält:

  1. Stabile IDs. Verwenden Sie einen Datenbankschlüssel oder einen Hash des Inputs, nie eine Zeilennummer, die sich verschiebt, wenn sich die Eingabedatei ändert.
  2. Prüfen Sie finish_reason. Eine bei max_tokens abgeschnittene Antwort ist "ok": true, aber nutzlos. DeepSeek V4.1 Flash, GLM 5.3 und Qwen3.8 27B denken nach, bevor sie antworten, und Reasoning zählt zu max_tokens. Der Runner setzt reasoning_effort="low", was BroadNet dokumentiert, und lässt 1.500 Tokens Spielraum.
  3. Loggen Sie die Nutzung pro Zeile. Die Summe von usage aus results.jsonl ergibt die tatsächliche Token-Rechnung, die Sie mit Ihrer Schätzung vergleichen können.

Was kostet es: Pay-as-you-go oder Plan-Session?

Bei Pay-as-you-go sind die Kosten Tokens. Nehmen Sie 100.000 Bewertungen, einen System-Prompt mit 150 Tokens, eine Bewertung mit 150 Tokens und 100 Output-Tokens bei niedrigem Reasoning. Das sind 30 Millionen Input- und 10 Millionen Output-Tokens. Auf DeepSeek V4.1 Flash kostet das 30 × $0.175 + 10 × $0.52. Halten Sie den System-Prompt an erster Stelle und byte-identisch, dann können seine 15 Millionen Tokens dort, wo der Cache greift, zum Tarif für gecachten Input von $0.0055 pro 1M abgerechnet werden. Ihre usage-Zeilen zeigen, wie oft das der Fall war.

Bei einem Plan sind Tokens kostenlos, und die Zeit ist der Preis. Eine Plan-Session für DeepSeek V4.1 Flash “runs one request at a time” (Übersetzung: verarbeitet jeweils eine Anfrage), setzen Sie also IN_FLIGHT=1 pro Session. Der Durchsatz pro Session beträgt 86.400 ÷ Sekunden pro Item, pro Tag. BroadNet gibt die typische Geschwindigkeit mit etwa 100 Tokens pro Sekunde an, aber Ihre Latenz hängt von Prompt-Länge und Reasoning ab, messen Sie sie also an 50 Items. Messen Sie 3 Sekunden pro Item, schafft eine Session 28.800 pro Tag:

Job Sessions Zeit bei 3 s/Item Plan
100.000 Items 1 Etwa 3,5 Tage Eine Orbit-Woche, $15 pro Session
100.000 Items 4 Etwa 21 Stunden Vier Orbit-Wochen, eine pro Session; oder etwa 21 Meteor-Stunden pro Session zu je $1
1.000.000 Items 6 Etwa 6 Tage Sechs Orbit-Wochen

Pläne werden “best effort under fair use” (Übersetzung: nach bestem Bemühen im Rahmen fairer Nutzung) erbracht, und BroadNet veröffentlicht kein Minutenlimit für Anfragen mit Plan-Schlüsseln; Ihr Konto zeigt die geltenden Limits. Setzen Sie RPM anhand dieser Werte, nicht nach Gefühl. Der Leitfaden zum Session-Planer erklärt, wie Sie Sessions auf Schlüssel verteilen.

Wo BroadNet Inference ins Bild passt

BroadNet Inference hat keine Batch API und eignet sich daher für Massenjobs, wenn Sie den Runner lieber selbst steuern und normale Preise pro Token zahlen oder die Kosten mit Plan-Sessions für DeepSeek V4.1 Flash festschreiben wollen. Für kleine Jobs mit knappem Budget läuft Gemma 4 VL 26B zu $0.10 Input und $0.22 Output pro 1M mit dem Startguthaben von $5. Prompts und Ausgaben werden nach jeder Anfrage nicht gespeichert. Wenn Ihr Job einen Tag warten kann und die benötigten Modelle bei einem Anbieter mit 50 % Batch-Rabatt verfügbar sind, kann das weniger kosten; vergleichen Sie, bevor Sie sich festlegen. Pläne und Limits finden Sie unter inference.broadnet.ai/plans.

Häufige Fragen

Hat BroadNet Inference eine Batch API?

Nein. Die API-Referenz, geprüft am 15. November 2026, dokumentiert POST /v1/chat/completions, POST /v1/audio/transcriptions und GET /v1/models, ohne Batch- oder Datei-Upload-Endpunkt und ohne Batch-Rabatt. Führen Sie Massenjobs als gewöhnliche Anfragen innerhalb der Limits Ihres Schlüssels aus.

Wie verarbeite ich 100.000 Prompts mit einer LLM-API?

Legen Sie die Items mit je einer ID in eine JSONL-Datei. Lassen Sie eine feste Zahl von Workern laufen, die dem Limit gleichzeitiger Anfragen des Schlüssels entspricht, takten Sie die Starts unter dem Minutenlimit, wiederholen Sie 429 und 5xx mit begrenztem Backoff und hängen Sie jedes Ergebnis mit der ID als Schlüssel an eine Ausgabedatei an, damit der Job fortgesetzt werden kann.

Wie lange dauert ein Batch mit einer Million Anfragen?

Teilen Sie die Items durch Ihre reale Rate. Bei 30 Anfragen pro Minute und einem Item pro Anfrage schafft ein Schlüssel 43.200 pro Tag, eine Million dauert also rund 23 Tage. Mit 20 kurzen Items pro Anfrage sinkt das auf etwa 28 Stunden, sofern das Modell mit dem längeren Prompt gut umgeht.

Sollte ich für Batch-LLM-Aufrufe asyncio.gather oder einen Worker-Pool nutzen?

Für Zehntausende Items nutzen Sie einen festen Pool von Workern, die aus einer Queue ziehen. gather mit einer Semaphore funktioniert für kleine Jobs, erzeugt aber alle Tasks im Voraus und erschwert Fortsetzen und Fortschrittsverfolgung.

Kann ich mehrere API-Schlüssel nutzen, um schneller zu sein?

Klären Sie das vorher. Die Acceptable Use Policy von BroadNet verbietet die Umgehung von Rate- oder Parallelitätslimits, fragen Sie BroadNet also, bevor Sie einen Job auf mehrere Schlüssel verteilen, um ein Limit pro Schlüssel zu umgehen. Mehr Items pro Anfrage und Plan-Sessions sind die dokumentierten Wege zu mehr Durchsatz.

Eignet sich ein Flatrate-Plan für Batch-Jobs?

Für DeepSeek V4.1 Flash durchaus. Eine Session verarbeitet jeweils eine Anfrage ohne Token-Zähler, die Kosten sind also fix und die Frage ist die Zeit. Messen Sie die Sekunden pro Item und kaufen Sie dann genug Sessions, um innerhalb des Zeitraums fertig zu werden.

Als Markdown lesenChatGPT fragenClaude fragenPerplexity fragen