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

Imágenes ilimitadas por solicitud

Lección 11 de 12 Actualizado el 30 de julio de 2026 Principiante
En esta página
  1. Una ventaja competitiva de la API de xAI
  2. Qué significa realmente «ilimitado»
  3. Recomendaciones prácticas según el volumen
  4. Arquitecturas multiimagen en producción
  5. Gestión de errores con conjuntos grandes de imágenes
  6. Puntos clave

Una ventaja competitiva de la API de xAI

La API de xAI se distingue de la competencia en un punto técnico clave: no impone ningún límite al número de imágenes que puedes enviar en una única solicitud. Mientras que otras APIs te restringen a 4, 10 o 20 imágenes, Grok acepta tantas como necesites.

Esta flexibilidad habilita casos de uso imposibles en otras plataformas, pero también exige comprender bien las implicaciones prácticas.

Qué significa realmente «ilimitado»

Que no haya límite en la cantidad de imágenes no significa que no existan restricciones. Varios factores limitan naturalmente cuántas imágenes puedes procesar de forma eficaz:

Ventana de contexto

El modelo tiene una ventana de contexto fija. Cada imagen consume entre 256 y 1792 tokens. Si envías 50 imágenes en modo high, podrías gastar hasta 89.600 tokens solo en imágenes, dejando poco margen para el texto y la respuesta.

Calidad del análisis

A partir de cierto número de imágenes, la calidad del análisis disminuye. El modelo debe distribuir su atención entre todas ellas, lo que puede derivar en descripciones superficiales u omisiones.

Latencia y tiempo de espera

Cuantas más imágenes envíes, más tardará el procesamiento. Con un tiempo de espera recomendado de 3600 segundos para los modelos de razonamiento, las solicitudes muy grandes pueden acercarse a este límite.

Recomendaciones prácticas según el volumen

Número de imágenes Recomendación Detalle sugerido
1-3 Análisis detallado posible high
4-10 Comparación eficiente auto
11-20 Clasificación por lotes low
20+ Dividir en subsolicitudes low

Arquitecturas multiimagen en producción

Patrón: Procesamiento secuencial con agregación

Para analizar un gran número de imágenes, procésalas por lotes y agrega después los resultados:

import json

def analyser_catalogue(images, taille_lot=8):
    """Analiza un catálogo de imágenes por lotes."""
    tous_resultats = []

    for i in range(0, len(images), taille_lot):
        lot = images[i:i + taille_lot]

        input_data = []
        for j, img in enumerate(lot, 1):
            input_data.append({
                "type": "input_text",
                "text": f"Imagen {i + j}:"
            })
            input_data.append({
                "type": "input_image",
                "image_url": img,
                "detail": "low"
            })

        input_data.append({
            "type": "input_text",
            "text": """Para cada imagen, identifica en JSON:
{"number": N, "category": "...", "short_description": "..."}
Devuelve un array JSON."""
        })

        response = client.responses.create(
            model="grok-4.5",
            input=input_data,
            store=False
        )

        try:
            resultats_lot = json.loads(response.output_text)
            tous_resultats.extend(resultats_lot)
        except json.JSONDecodeError:
            tous_resultats.append({"batch": i, "raw": response.output_text})

    return tous_resultats

Patrón: Filtrado en embudo

Comienza con una clasificación rápida de todas las imágenes y profundiza solo en las relevantes:

def entonnoir_analyse(images, critere):
    """Filtra y luego analiza en profundidad."""
    # Paso 1: Filtrado rápido
    input_data = []
    for i, img in enumerate(images):
        input_data.append({"type": "input_image", "image_url": img, "detail": "low"})

    input_data.append({
        "type": "input_text",
        "text": f"""De estas {len(images)} imágenes, ¿cuáles
cumplen el criterio: "{critere}"?
Devuelve solo los números (índice base 0) en JSON: [0, 3, 7]"""
    })

    response = client.responses.create(
        model="grok-4.5", input=input_data, store=False
    )

    indices = json.loads(response.output_text)

    # Paso 2: Análisis en profundidad de las imágenes filtradas
    resultats = []
    for idx in indices:
        response_detail = client.responses.create(
            model="grok-4.5",
            input=[
                {"type": "input_image", "image_url": images[idx], "detail": "high"},
                {"type": "input_text", "text": "Análisis detallado de esta imagen."}
            ],
            store=False
        )
        resultats.append({"index": idx, "analysis": response_detail.output_text})

    return resultats

Gestión de errores con conjuntos grandes de imágenes

Al trabajar con un número elevado de imágenes, los errores son más probables. Implementa una gestión robusta:

import time

def requete_avec_retry(input_data, max_retries=3):
    for tentative in range(max_retries):
        try:
            response = client.responses.create(
                model="grok-4.5",
                input=input_data,
                store=False
            )
            return response
        except Exception as e:
            if tentative < max_retries - 1:
                delai = 2 ** tentative  # Retroceso exponencial
                time.sleep(delai)
            else:
                raise e

Puntos clave

  • La API de xAI acepta un número ilimitado de imágenes, pero la ventana de contexto sigue siendo finita
  • A partir de 10 imágenes, usa detail: "low" para preservar la calidad del análisis
  • A partir de 20 imágenes, divide la solicitud en subsolicitudes para garantizar la fiabilidad
  • El patrón de «embudo» (filtrado rápido seguido de análisis detallado) es el más eficaz para volúmenes grandes
  • Implementa reintentos con retroceso exponencial para solicitudes de gran tamaño