Nombre illimité d'images par requête

Un avantage concurrentiel de l’API xAI

L’API xAI se distingue de ses concurrents sur un point technique important : elle n’impose aucune limite sur le nombre d’images envoyées dans une seule requête. Là où d’autres API vous limitent à 4, 10 ou 20 images, Grok accepte autant d’images que vous le souhaitez.

Cette flexibilité ouvre des cas d’usage impossibles ailleurs, mais elle exige aussi une bonne compréhension des implications pratiques.

Ce que “illimité” signifie vraiment

L’absence de limite sur le nombre d’images ne signifie pas l’absence de contraintes. Plusieurs facteurs limitent naturellement le nombre d’images que vous pouvez envoyer efficacement :

Fenêtre de contexte

Le modèle dispose d’une fenêtre de contexte de taille fixe. Chaque image consomme entre 256 et 1792 tokens. Si vous envoyez 50 images en mode high, vous utilisez potentiellement 89 600 tokens rien que pour les images, laissant peu de place pour le texte et la réponse.

Qualité de l’analyse

Au-delà d’un certain nombre d’images, la qualité de l’analyse diminue. Le modèle doit répartir son attention sur toutes les images, ce qui peut mener à des descriptions superficielles ou à des oublis.

Latence et timeout

Plus vous envoyez d’images, plus le temps de traitement augmente. Avec un timeout recommandé de 3600 secondes pour les modèles de raisonnement, les requêtes très volumineuses peuvent approcher cette limite.

Recommandations pratiques par volume

Architectures multi-images en production

Pattern : traitement séquentiel avec agrégation

Pour analyser un grand nombre d’images, traitez-les par lots puis agrégez les résultats :

import json

def analyser_catalogue(images, taille_lot=8):
    """Analyse un catalogue d'images par lots."""
    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"Image {i + j} :"
            })
            input_data.append({
                "type": "input_image",
                "image_url": img,
                "detail": "low"
            })

        input_data.append({
            "type": "input_text",
            "text": """Pour chaque image, identifie en JSON :
{"numero": N, "categorie": "...", "description_courte": "..."}
Renvoie un tableau JSON."""
        })

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

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

    return tous_resultats

Pattern : filtrage en entonnoir

Commencez par un tri rapide sur toutes les images, puis approfondissez uniquement celles qui sont pertinentes :

def entonnoir_analyse(images, critere):
    """Filtre puis analyse en profondeur."""
    # Étape 1 : filtrage rapide
    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"""Parmi ces {len(images)} images, lesquelles
correspondent au critère : "{critere}" ?
Renvoie uniquement les numéros (index 0-based) en JSON : [0, 3, 7]"""
    })

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

    indices = json.loads(response.output_text)

    # Étape 2 : analyse approfondie des images filtrées
    resultats = []
    for idx in indices:
        response_detail = client.responses.create(
            model="grok-4",
            input=[
                {"type": "input_image", "image_url": images[idx], "detail": "high"},
                {"type": "input_text", "text": "Analyse détaillée de cette image."}
            ],
            store=False
        )
        resultats.append({"index": idx, "analyse": response_detail.output_text})

    return resultats

Gestion des erreurs avec beaucoup d’images

Quand vous travaillez avec un grand nombre d’images, les erreurs sont plus probables. Implémentez une gestion robuste :

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",
                input=input_data,
                store=False
            )
            return response
        except Exception as e:
            if tentative < max_retries - 1:
                delai = 2 ** tentative  # Backoff exponentiel
                time.sleep(delai)
            else:
                raise e

Points clés à retenir

• L’API xAI accepte un nombre illimité d’images, mais la fenêtre de contexte reste finie
• Au-delà de 10 images, utilisez detail: "low" pour préserver la qualité d’analyse
• Au-delà de 20 images, découpez en sous-requêtes pour la fiabilité
• Le pattern “entonnoir” (filtrage rapide puis analyse détaillée) est le plus efficace pour les gros volumes
• Implémentez des retries avec backoff exponentiel pour les requêtes volumineuses