L'outil batch : exécuter des outils en parallèle

Claude peut techniquement inclure plusieurs blocs tool_use dans une seule réponse. Mais en pratique, il a tendance à appeler les outils un par un, attendant le résultat de chacun avant de passer au suivant. Cela crée des allers-retours inutiles quand les opérations sont indépendantes.

Le problème

Prenons un exemple : vous demandez à Claude de programmer deux rappels pour la même date. Idéalement, il enverrait une seule réponse avec deux blocs tool_use. Mais souvent, il va :

1. Appeler le premier outil
2. Attendre le résultat
3. Appeler le deuxième outil
4. Attendre le résultat

C’est deux tours de boucle au lieu d’un seul. Pour des opérations indépendantes, c’est du gaspillage.

La solution : un outil batch

L’idée mérite qu’on s’y arrête, parce qu’elle est contre-intuitive : on ne modifie ni l’API, ni le modèle, ni la boucle de conversation. On ajoute un outil ordinaire dont les arguments décrivent d’autres appels d’outils — et cela suffit à changer le comportement de Claude, qui se met à regrouper ce qu’il enchaînait. L’idée est de créer un meta-outil qui accepte une liste d’appels à d’autres outils. Au lieu d’appeler chaque outil séparément, Claude appelle l’outil batch en lui passant toutes les opérations à effectuer.

Chaque invocation dans la liste contient :

• Le nom de l’outil à appeler
• Les arguments à lui transmettre

Définition du schéma batch

batch_tool_schema = {
    "name": "batch_tool",
    "description": "Invoke multiple other tool calls simultaneously",
    "input_schema": {
        "type": "object",
        "properties": {
            "invocations": {
                "type": "array",
                "description": "The tool calls to invoke",
                "items": {
                    "type": "object",
                    "properties": {
                        "name": {
                            "type": "string",
                            "description": "The name of the tool to invoke"
                        },
                        "arguments": {
                            "type": "object",
                            "description": "The arguments to pass to the tool"
                        }
                    }
                }
            }
        }
    }
}

Implémentation de la fonction batch

La fonction parcourt la liste des invocations et exécute chaque outil via le routeur existant :

def run_batch(invocations=[]):
    batch_output = []

    for invocation in invocations:
        name = invocation["name"]
        args = json.loads(invocation["arguments"])

        tool_output = run_tool(name, args)

        batch_output.append({
            "tool_name": name,
            "output": tool_output
        })

    return batch_output

Le fonctionnement :

1. Parcourir chaque invocation de la liste
2. Extraire le nom de l’outil et ses arguments
3. Appeler l’outil via run_tool (la même fonction de routage que d’habitude)
4. Collecter tous les résultats dans une liste

Intégration dans le routeur

Il faut aussi ajouter l’outil batch dans la fonction de routage :

def run_tool(tool_name, tool_input):
    if tool_name == "get_current_datetime":
        return get_current_datetime(**tool_input)
    elif tool_name == "add_duration_to_datetime":
        return add_duration_to_datetime(**tool_input)
    elif tool_name == "set_reminder":
        return set_reminder(**tool_input)
    elif tool_name == "batch_tool":
        return run_batch(**tool_input)

Résultats en pratique

Avec l’outil batch disponible, Claude va naturellement regrouper les opérations indépendantes. Au lieu de faire deux allers-retours pour deux rappels, il appelle une seule fois l’outil batch avec les deux opérations.

Pourquoi ça marche

L’outil batch est essentiellement une astuce d’ingénierie qui donne à Claude une abstraction de niveau supérieur pour l’exécution parallèle. Une limite en découle, à garder en tête : le batch ne convient qu’aux opérations indépendantes. Si le deuxième appel a besoin du résultat du premier, le regroupement est impossible par construction — Claude ne connaît pas encore ce résultat au moment où il compose la liste. Les chaînes dépendantes restent l’affaire de la boucle multi-tours. En lui fournissant un outil explicitement conçu pour regrouper des appels, on l’encouragé à battre les opérations ensemble.

Les avantages :

• Moins d’allers-retours avec l’API
• Meilleure performance globale
• Expérience utilisateur plus fluide (moins d’attente)

C’est une technique simple mais efficace pour optimiser les interactions avec Claude quand plusieurs opérations indépendantes doivent être effectuées.