Ir al contenido principal
Español— Elegir un idioma
Menú

Agrupación en línea: hasta 10 000 solicitudes sin archivos

Lección 4 de 16 Actualizado el 3 de noviembre de 2026 Avanzado
En esta página
  1. La alternativa ligera a la agrupación por archivos
  2. Agrupación por archivos frente a agrupación en línea
  3. Creación de una tarea en línea
  4. Ejemplo práctico: Clasificación de tickets
  5. Cuándo elegir cada enfoque
  6. Puntos clave

Actualizado el 3 de noviembre de 2026: Actualización del 3 de noviembre: files.download devuelve una respuesta HTTP (httpx2.Response); lee su contenido con .read() antes de llamar a .decode().

La alternativa ligera a la agrupación por archivos

La agrupación en línea (inline batching) te permite enviar solicitudes por lotes directamente en la llamada a la API, omitiendo el paso de subida de archivos. Este es el método ideal cuando tienes un volumen moderado de solicitudes (hasta 10 000) y quieres simplificar tu canalización de datos.

Agrupación por archivos frente a agrupación en línea

Antes de entrar en el código, aclaremos las diferencias entre ambos enfoques:

Criterio Agrupación por archivos Agrupación en línea
Volumen máximo 1 000 000 de solicitudes 10 000 solicitudes
Requisitos previos Subir archivo JSONL Ninguno
Pasos Subida + Creación de tarea Creación de tarea (llamada única)
Casos de uso Producción, grandes volúmenes Pruebas, prototipado, volúmenes medios

Creación de una tarea en línea

En lugar de pasar input_files, pasas un parámetro requests que contiene tu lista de solicitudes directamente:

from mistralai.client import Mistral

client = Mistral(api_key="your-api-key")

# Preparar solicitudes en línea
inline_requests = [
    {
        "custom_id": f"req-{i:04d}",
        "body": {
            "max_tokens": 150,
            "messages": [
                {
                    "role": "system",
                    "content": "Eres un experto en clasificación de texto."
                },
                {
                    "role": "user",
                    "content": f"Clasifica este texto: {text}"
                }
            ]
        }
    }
    for i, text in enumerate(my_texts)
]

# Crear la tarea con solicitudes en línea
job = client.batch.jobs.create(
    requests=inline_requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

print(f"Tarea en línea creada: {job.id}")
print(f"Número de solicitudes: {len(inline_requests)}")

La diferencia en el código es mínima: requests= en lugar de input_files=. El resto del flujo de trabajo (seguimiento del estado, descarga de resultados) es idéntico.

Ejemplo práctico: Clasificación de tickets

Aquí tienes un ejemplo completo de clasificación de tickets de soporte al cliente:

from mistralai.client import Mistral
import json
import time

client = Mistral(api_key="your-api-key")

# Simular tickets de soporte
tickets = [
    {"id": "TK-001", "message": "No puedo iniciar sesión en mi cuenta"},
    {"id": "TK-002", "message": "¿Cómo cancelo mi suscripción?"},
    {"id": "TK-003", "message": "La aplicación falla al iniciarse"},
    {"id": "TK-004", "message": "¿Podéis añadir el modo oscuro?"},
    {"id": "TK-005", "message": "Mi factura es incorrecta"},
]

# Construir solicitudes en línea
requests = [
    {
        "custom_id": ticket["id"],
        "body": {
            "max_tokens": 50,
            "messages": [
                {
                    "role": "system",
                    "content": (
                        "Clasifica el ticket en una de estas categorías: "
                        "AUTHENTICATION, BILLING, BUG, "
                        "FEATURE, SUBSCRIPTION. "
                        "Responde solo con la categoría."
                    )
                },
                {"role": "user", "content": ticket["message"]}
            ]
        }
    }
    for ticket in tickets
]

# Lanzar el lote en línea
job = client.batch.jobs.create(
    requests=requests,
    model="mistral-small-latest",
    endpoint="/v1/chat/completions"
)

# Esperar y recuperar resultados
while True:
    status = client.batch.jobs.get(job_id=job.id)
    if status.status in ("SUCCESS", "FAILED", "CANCELLED"):
        break
    time.sleep(5)

# Analizar resultados
if status.status == "SUCCESS":
    data = client.files.download(file_id=status.output_file)
    for line in data.read().decode("utf-8").strip().split("\n"):
        entry = json.loads(line)
        ticket_id = entry["custom_id"]
        category = entry["response"]["body"]["choices"][0]["message"]["content"]
        print(f"{ticket_id} -> {category.strip()}")

Cuándo elegir cada enfoque

El factor decisivo no es solo el volumen, sino dónde encaja la agrupación en tu flujo de trabajo. Durante el prototipado, pruebas un indicador (prompt) con unos pocos cientos de ejemplos, lo refinas y lo vuelves a ejecutar. Escribir un archivo JSONL intermedio en cada iteración solo ralentiza el bucle. La agrupación en línea elimina esta fricción: tu script genera las solicitudes sobre la marcha, las envía en la misma llamada y puedes iterar en minutos. La misma lógica se aplica a integraciones ligeras, scripts de análisis puntuales o procesamiento diario que se mantenga por debajo de las 10 000 solicitudes.

La agrupación por archivos toma la delantera una vez que el proceso por lotes se convierte en un eslabón de producción. Primero, mecánicamente: más allá de 10 000 solicitudes, es la única opción. Pero, más importante aún, estructuralmente: un archivo subido es un artefacto duradero. Puedes reutilizarlo para múltiples tareas, conservarlo como registro exacto de lo que se envió y separar limpiamente el paso de preparación (que construye, valida y versiona el archivo) del paso de ejecución (que lanza la tarea). Cuando una tarea por lotes se ejecuta nightly con datos de clientes, esta trazabilidad no es un lujo; es lo que te permite responder a la pregunta «¿Qué enviamos al modelo el 12 de marzo?» seis meses después.

En la práctica, muchos equipos utilizan ambos: en línea durante el desarrollo del indicador y luego cambian a agrupación por archivos al industrializar el proceso. Dado que el código para rastrear y recuperar resultados permanece idéntico, la migración se limita a sustituir requests= por input_files=.

Puntos clave

  • La agrupación en línea elimina el paso de subida al pasar las solicitudes directamente mediante el parámetro requests
  • Límite de 10 000 solicitudes por tarea en línea, frente a 1 millón para la agrupación por archivos
  • El seguimiento del estado y la descarga de resultados son idénticos para ambos modos
  • Prefiere la agrupación en línea para prototipado y volúmenes moderados; usa la agrupación por archivos para producción a gran escala