BroadRouter
Comenzar

Procesamiento por lotes con LLM sin Batch API: un runner reanudable

Por el equipo de BroadNet Inference · 8 min de lectura · Publicado · Actualizado

Sin Batch API, ejecute el trabajo usted mismo: lea los elementos de un archivo JSONL, limite las solicitudes en curso al tope de la clave, espacie los inicios por debajo del límite por minuto, reintente los 429 y 5xx con backoff acotado y anexe cada resultado con su ID. Al reiniciar, omita los ID terminados. Normalmente es el rate limit, no el modelo, lo que fija la hora de finalización.

Algunos trabajos con LLM no son chats. Tiene 50,000 tickets de soporte que etiquetar, 200,000 descripciones de productos que traducir o un millón de reseñas que puntuar. Proveedores como OpenAI y Anthropic venden una Batch API para esto. Muchas APIs compatibles con OpenAI, entre ellas BroadNet Inference, no la tienen. Este artículo muestra cómo ejecutar el trabajo usted mismo: calcular cuánto tardará, escribir un runner que respete los límites y hacer que sea seguro detenerlo y reiniciarlo.

BroadRouter es el sitio de BroadNet, así que los ejemplos numéricos usan los límites publicados por BroadNet. El método funciona con cualquier API de chat completions; sustituya las cifras por las de su proveedor.

¿BroadNet Inference tiene Batch API?

No. La referencia de la API, consultada el 15 de noviembre de 2026, documenta POST /v1/chat/completions, POST /v1/audio/transcriptions y GET /v1/models (una lista de modelos), además de endpoints de cuenta en /portal/. No hay endpoint de lotes ni de carga de archivos, ni descuento por lotes. Un trabajo masivo es un bucle de solicitudes normales.

Esto es lo que ofrece una Batch API gestionada, para que sepa qué está reconstruyendo:

Batch API de OpenAI Message Batches de Anthropic Su propio runner
Precio 50 % menos que en modo síncrono 50 % de descuento Precio normal
Tiempo de entrega En 24 horas La mayoría en 1 hora; caduca a las 24 Lo fijan sus rate limits
Tamaño por lote 50,000 solicitudes o 200 MB 100,000 solicitudes o 256 MB Cualquier tamaño
Rate limits Separados de los límites por modelo Aplican a las solicitudes en cola Los límites de su clave
Orden de resultados Puede variar; empareje por custom_id Empareje por custom_id Usted asocia los resultados por ID

Hay dos lecciones que se trasladan. Ambos proveedores le obligan a etiquetar cada solicitud con un ID, porque los resultados no vuelven en orden. Ninguno promete una respuesta en segundos. Su runner debe funcionar igual: ID en todo y un plan medido en horas.

Si un descuento del 50 % importa más que el tiempo de entrega, y los modelos que necesita están ahí, una Batch API gestionada puede ser la herramienta más barata. Calcule el costo de ambas opciones con la calculadora de costos de API de LLM antes de construir.

¿Cuánto tardará el trabajo?

Calcúlelo antes de escribir código. Dos límites restringen el rendimiento, y manda el más lento:

  • Límite de solicitudes en curso ÷ latencia. Con 4 solicitudes en curso y 2 segundos por solicitud, puede terminar 2 por segundo.
  • Solicitudes por minuto. A 30 por minuto, puede iniciar 0.5 por segundo, por rápido que sea el modelo.

Una clave de pago por uso de BroadNet permite 4 solicitudes en curso y 30 por minuto. Con los valores de la referencia de la API cuando la consultamos (30 por minuto y 4 en curso, 2026-11-15), el rate limit es el que manda salvo que cada solicitud tarde más de 8 segundos, y la tabla siguiente usa 30 por minuto:

Elementos Un elemento por solicitud 20 elementos por solicitud
10,000 5.6 horas 17 minutos
100,000 2.3 días 2.8 horas
1,000,000 23 días 28 horas

A 30 solicitudes por minuto, una clave hace 1,800 solicitudes por hora, o 43,200 al día. Los reintentos también cuentan: cada 429 que provoque consume un hueco.

La segunda columna es la palanca más grande. Los elementos cortos, como reseñas o asuntos de tickets, pueden ir de 10 a 50 por solicitud como lista numerada, con un array JSON de vuelta. Compruebe que el array tenga una entrada por elemento y que cada una lleve su número. El artículo de clasificación de texto en árabe muestra el patrón. Los elementos largos no se agrupan: cada solicitud tiene que caber en la ventana de contexto del modelo, y la calidad puede bajar a medida que crece la lista. Pruebe la agrupación con 200 elementos antes de confiar en ella.

No reparta un trabajo entre varias claves para superar un límite por clave sin preguntar. La Política de Uso Aceptable de BroadNet prohíbe eludir límites de tasa, de concurrencia o de presupuesto. Si necesita más, pregunte a BroadNet o use sesiones de plan, más abajo. El planificador de trabajos por lotes hace este cálculo para su número de elementos, su latencia y sus límites.

¿Cómo es un runner reanudable?

Este runner lee items.jsonl (un objeto {"id", "text"} por línea) y anexa una línea de resultado por elemento a results.jsonl. Solo necesita el SDK de OpenAI para Python.

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

Ejecútelo con python batch_run.py items.jsonl results.jsonl. Probamos exactamente este archivo contra un servidor simulado local que devolvía 429 aleatorios (8 %) y 500 (5 %) y rechazaba cualquier cosa por encima de 4 en curso o 30 inicios por minuto. 25 elementos terminaron en 55 segundos con 28 solicitudes (3 reintentos), y nunca hubo más de 30 inicios en ninguna ventana de 60 segundos. Con el límite del simulador elevado a 300 por minuto para ahorrar tiempo, una ejecución de 120 elementos interrumpida a los 10 segundos se reanudó desde 39 resultados guardados y terminó con 120 ID únicos y sin duplicados.

¿Por qué un pool de workers y no asyncio.gather?

La guía del error 429 usa un semáforo alrededor de asyncio.gather. Eso está bien para unos cientos de llamadas. Para un trabajo grande, es mejor un pool fijo de workers que toman elementos de una cola:

  • Memoria. gather crea una tarea por elemento desde el principio. Un pool solo mantiene los elementos en curso.
  • La concurrencia es el tamaño del pool. Cuatro workers nunca pueden tener cinco solicitudes abiertas.
  • Los resultados se escriben en disco a medida que terminan, en cualquier orden, asociados por ID.

El Pacer se ocupa del segundo límite. Un semáforo por sí solo evita superar 4 en curso, pero si las solicitudes tardan un segundo, cuatro workers iniciarían 240 por minuto y recibirían 429 en la mayoría. El pacer espacia los inicios 2 segundos entre todos los workers, reintentos incluidos.

¿Cómo se mantienen seguros los reintentos?

Reintente solo lo que puede funcionar en un segundo intento:

Respuesta Acción
429 Espere y reintente; la documentación de BroadNet dice “use response details and bounded backoff” (Traducción: use los detalles de la respuesta y un backoff acotado)
500, 502, 503, 504, timeouts, conexiones caídas Reintente con backoff exponencial acotado
400, 422 Corrija la solicitud; reintentar envía el mismo error
401, 402, 403 Detenga el trabajo; la clave, el saldo o la política requieren atención
413 Acorte el elemento

El runner desactiva los reintentos propios del SDK (max_retries=0) para que haya exactamente una política de reintentos, con un tope visible. El backoff es exponencial con full jitter, con un tope de 60 segundos, para que los workers que fallaron juntos no reintenten juntos. Tras seis intentos, el elemento se escribe con "ok": false y el trabajo sigue. Un elemento defectuoso nunca detiene un millón.

Una llamada al modelo no tiene efectos secundarios, así que aquí la entrega es “al menos una vez”: si el proceso muere a mitad de una solicitud, ese elemento se envía de nuevo al reiniciar, y lo paga dos veces. Ese es el único desperdicio. Si el trabajo también escribe en otro sistema, como tickets o correos, haga esa escritura idempotente por ID de elemento y hágala en una pasada aparte sobre results.jsonl. El artículo sobre agentes de larga duración trata a fondo los efectos secundarios idempotentes.

¿Cómo funciona el checkpointing?

El archivo de salida es el checkpoint. Cada elemento terminado es una línea vaciada a disco, así que tras una caída, un despliegue o un Ctrl-C, la siguiente ejecución lee el archivo, reúne los ID con "ok": true y encola solo el resto. Los elementos que fallaron antes se reintentan en la siguiente ejecución y su nueva línea se anexa. Al leer los resultados, quédese con la última línea de cada ID.

Tres hábitos hacen que esto aguante durante días:

  1. ID estables. Use una clave de base de datos o un hash de la entrada, nunca un número de línea que cambia cuando cambia el archivo de entrada.
  2. Revise finish_reason. Una respuesta cortada en max_tokens es "ok": true pero inútil. DeepSeek V4.1 Flash, GLM 5.3 y Qwen3.8 27B razonan antes de responder, y el razonamiento cuenta dentro de max_tokens. El runner fija reasoning_effort="low", que BroadNet documenta, y deja 1,500 tokens.
  3. Registre el uso en cada línea. Sumar usage de results.jsonl le da la factura real de tokens para compararla con su estimación.

¿Cuánto cuesta: pago por uso o una sesión de plan?

En pago por uso, el costo son los tokens. Tome 100,000 reseñas, un prompt de sistema de 150 tokens, una reseña de 150 tokens y 100 tokens de salida con razonamiento bajo. Eso son 30 millones de tokens de entrada y 10 millones de salida. En DeepSeek V4.1 Flash cuesta 30 × $0.175 + 10 × $0.52. Mantenga el prompt de sistema al principio e idéntico byte a byte, y sus 15 millones de tokens pueden cobrarse a la tarifa de entrada en caché de $0.0055 por 1M cuando la caché acierta. Sus líneas de usage muestran con qué frecuencia lo hizo.

En un plan, los tokens son gratis y el costo es el tiempo. Una sesión de plan de DeepSeek V4.1 Flash “runs one request at a time” (Traducción: ejecuta una solicitud a la vez), así que fije IN_FLIGHT=1 por sesión. El rendimiento por sesión es 86,400 ÷ segundos por elemento, al día. BroadNet indica una velocidad típica de unos 100 tokens por segundo, pero su latencia depende de la longitud del prompt y del razonamiento, así que mídala con 50 elementos. Si mide 3 segundos por elemento, una sesión procesa 28,800 al día:

Trabajo Sesiones Tiempo a 3 s/elemento Plan
100,000 elementos 1 Unos 3.5 días Una semana de Órbita (Orbit), $15 por sesión
100,000 elementos 4 Unas 21 horas Cuatro semanas de Órbita, una por sesión; o unas 21 horas de Meteoro (Meteor) por sesión, a $1 cada una
1,000,000 elementos 6 Unos 6 días Seis semanas de Órbita

Los planes se ofrecen “best effort under fair use” (Traducción: con el mejor esfuerzo bajo uso justo), y BroadNet no publica un límite de solicitudes por minuto para las claves de plan; su cuenta muestra los límites que aplican. Configure RPM a partir de ellos, no a ojo. La guía de planificación de sesiones explica cómo repartir las sesiones entre claves.

Dónde encaja BroadNet Inference

BroadNet Inference no tiene Batch API, así que encaja en trabajos masivos cuando usted prefiere controlar el runner y pagar precios normales por token, o fijar el costo con sesiones de plan de DeepSeek V4.1 Flash. Para trabajos pequeños con presupuesto ajustado, Gemma 4 VL 26B, a $0.10 de entrada y $0.22 de salida por 1M, funciona con el crédito inicial de $5. Los prompts y las salidas no se conservan después de cada solicitud. Si su trabajo puede esperar un día y los modelos que necesita están en un proveedor con un descuento por lotes del 50 %, eso puede costar menos; compare antes de comprometerse. Los planes y límites están en inference.broadnet.ai/plans.

Preguntas frecuentes

¿BroadNet Inference tiene Batch API?

No. Su referencia de API, consultada el 15 de noviembre de 2026, documenta POST /v1/chat/completions, POST /v1/audio/transcriptions y GET /v1/models, sin endpoint de lotes ni de carga de archivos, y sin descuento por lotes. Ejecute los trabajos masivos como solicitudes normales dentro de los límites de su clave.

¿Cómo proceso 100,000 prompts con una API de LLM?

Ponga los elementos en un archivo JSONL, cada uno con un ID. Ejecute un número fijo de workers igual al límite de solicitudes en curso de la clave, espacie los inicios por debajo del límite por minuto, reintente los 429 y 5xx con backoff acotado y anexe cada resultado a un archivo de salida con su ID para que el trabajo pueda reanudarse.

¿Cuánto tarda un lote de un millón de solicitudes?

Divida los elementos entre su tasa real. A 30 solicitudes por minuto y un elemento por solicitud, una clave procesa 43,200 al día, así que un millón tarda unos 23 días. Agrupar 20 elementos cortos por solicitud lo reduce a unas 28 horas, si el modelo maneja bien el prompt más largo.

¿Uso asyncio.gather o un pool de workers para llamadas por lotes a un LLM?

Para decenas de miles de elementos, use un pool fijo de workers que tomen elementos de una cola. gather con un semáforo sirve para trabajos pequeños, pero crea todas las tareas de entrada y complica la reanudación y el seguimiento del progreso.

¿Puedo usar varias claves de API para ir más rápido?

Consulte primero. La Política de Uso Aceptable de BroadNet prohíbe eludir los límites de tasa o de concurrencia, así que pregunte a BroadNet antes de repartir un trabajo entre varias claves para superar un límite por clave. Agrupar más elementos por solicitud y las sesiones de plan son las formas documentadas de aumentar el rendimiento.

¿Un plan de tarifa plana sirve para trabajos por lotes?

Puede servir, con DeepSeek V4.1 Flash. Una sesión ejecuta una solicitud a la vez sin medidor de tokens, así que el costo es fijo y la cuestión es el tiempo. Mida los segundos por elemento y compre suficientes sesiones para terminar dentro del periodo.

Leer en MarkdownPreguntar a ChatGPTPreguntar a ClaudePreguntar a Perplexity