Workflows de parallélisation

Deuxième pattern de la boîte à outils : la parallélisation. Elle décompose des tâches complexes en évaluations focalisées qui s’exécutent simultanément, puis agrège les résultats pour une décision finale — plusieurs angles d’expertise sur un même objet, au lieu d’un seul prompt qui tenterait de tout embrasser.

Le problème avec les prompts complexes uniques

Prenez une app de sélection de matériaux : l’utilisateur soumet la photo d’une pièce, et le système doit arbitrer entre métal, polymère, céramique, composite, élastomère et bois — chacun avec ses critères de résistance, de coût et de fabrication. Deux tentations, deux échecs :

• Prompt unique : peu fiable, Claude jongle avec trop de critères
• Prompt massif : Claude est surchargé cognitivement

C’est la leçon des prompts spécifiques poussée à sa limite : plus une requête empile d’exigences hétérogènes, plus chacune est traitée superficiellement. Six analyses expertes réclamées d’un bloc produisent six analyses médiocres.

La solution : parallélisation

Chaque instance reçoit la même image mais un prompt hautement spécialisé — les critères du métal pour l’une, ceux du polymère pour l’autre — et ne porte qu’une casquette d’expert à la fois. Ces requêtes étant indépendantes, elles s’exécutent réellement en parallèle : l’analyse complète dure le temps de la plus lente, pas la somme de toutes. Puis l’appel d’agrégation reçoit les avis d’experts — courts et structurés — et tranche : c’est un prompt de comparaison, bien plus simple que le monolithe qu’on a évité.

Structure du pattern

1. Décomposer la tâche en sous-tâches indépendantes.
2. Exécuter les sous-tâches en parallèle.
3. Agréger les résultats en une décision.

Le mot décisif est « indépendantes » : la parallélisation exige que les sous-tâches ne dépendent pas les unes des autres. Si l’étape B a besoin du résultat de l’étape A, c’est un chaînage qu’il vous faut — le pattern de la prochaine leçon.

En code

Le client asynchrone du SDK lance les analyses en même temps avec asyncio.gather, puis un dernier appel les compare :

import asyncio
from anthropic import AsyncAnthropic

client = AsyncAnthropic()

CRITERES = {
    "métal": "résistance mécanique, tenue en température, usinabilité, corrosion",
    "polymère": "masse, coût en grande série, résistance chimique, moulage",
    "céramique": "dureté, isolation, fragilité aux chocs",
}

def texte(response):
    return "".join(block.text for block in response.content if block.type == "text")

async def analyser(image_block, materiau, criteres):
    response = await client.messages.create(
        model=model,
        max_tokens=4096,
        messages=[{"role": "user", "content": [
            image_block,
            {"type": "text", "text": (
                f"Évalue si cette pièce peut être fabriquée en {materiau}. "
                f"Critères : {criteres}. Termine par une note de 1 à 10 et une phrase de justification."
            )},
        ]}],
    )
    return materiau, texte(response)

async def recommander(image_block):
    analyses = await asyncio.gather(
        *(analyser(image_block, materiau, criteres) for materiau, criteres in CRITERES.items())
    )
    rapport = "\n\n".join(f'<analyse materiau="{m}">\n{t}\n</analyse>' for m, t in analyses)
    response = await client.messages.create(
        model=model,
        max_tokens=4096,
        messages=[{"role": "user", "content": (
            f"{rapport}\n\nCompare ces analyses et recommande le matériau le plus adapté, "
            "avec une phrase de justification."
        )}],
    )
    return texte(response)

image_block est le bloc image de la leçon 57. La durée totale est celle de l’analyse la plus lente, pas la somme des trois. Les appels parallèles comptent tous dans vos limites de débit : pour un grand nombre de sous-tâches, plafonnez la concurrence, par exemple avec un asyncio.Semaphore.

Avantages

La deuxième ligne du tableau mérite un développement : chaque sous-prompt s’évalue isolément avec le pipeline du début du cours. Si l’analyse polymère est faible, vous la retravaillez et la re-mesurez sans toucher aux cinq autres — impossible avec un prompt monolithique où chaque retouche risque de tout déséquilibrer. Et la vitesse vient en bonus : le travail parallèle réduit la latence totale par rapport au même travail en séquence.

Le réflexe à emporter : recherchez les situations où vous demandez à une IA de considérer plusieurs critères ou de comparer plusieurs options — chaque fois qu’un prompt contient « en tenant compte de A, B, C, D et E », demandez-vous si A, B, C, D et E ne mériteraient pas chacun leur requête.

À vous de jouer

Découper un prompt surchargé. Reprenez un prompt qui demande à Claude de juger selon cinq critères à la fois. Écrivez cinq prompts spécialisés et un prompt d’agrégation, lancez-les avec asyncio.gather, puis comparez sur dix cas la qualité et la durée avec le prompt unique.

Sources officielles : Parallelization workflows (Claude Academy) · Building effective agents (Anthropic : les patterns de workflows et les agents)

Points clés à retenir

• Un prompt surchargé de critères hétérogènes produit des analyses superficielles
• Parallélisation : même entrée, N prompts spécialisés simultanés, puis un appel d’agrégation
• Condition d’application : les sous-tâches doivent être indépendantes (sinon → chaînage)
• Chaque sous-prompt s’évalue et s’améliore isolément — l’atout maintenance du pattern
• Signal d’usage : tout prompt en « considère A, B, C, D et E » est un candidat au découpage