L'outil batch : executer des outils en parallele

Claude peut techniquement inclure plusieurs blocs tool_use dans une seule reponse. Mais en pratique, il a tendance a appeler les outils un par un, attendant le resultat de chacun avant de passer au suivant. Cela cree des allers-retours inutiles quand les operations sont independantes.

Le probleme

Prenons un exemple : vous demandez a Claude de programmer deux rappels pour la meme date. Idealement, il enverrait une seule reponse avec deux blocs tool_use. Mais souvent, il va :

1. Appeler le premier outil
2. Attendre le resultat
3. Appeler le deuxieme outil
4. Attendre le resultat

C’est deux tours de boucle au lieu d’un seul. Pour des operations independantes, c’est du gaspillage.

La solution : un outil batch

L’idee est de creer un meta-outil qui accepte une liste d’appels a d’autres outils. Au lieu d’appeler chaque outil separement, Claude appelle l’outil batch en lui passant toutes les operations a effectuer.

Chaque invocation dans la liste contient :

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

Definition du schema 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"
                        }
                    }
                }
            }
        }
    }
}

Implementation de la fonction batch

La fonction parcourt la liste des invocations et execute 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 meme fonction de routage que d’habitude)
4. Collecter tous les resultats dans une liste

Integration 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)

Resultats en pratique

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

Pourquoi ca marche

L’outil batch est essentiellement une astuce d’ingenierie qui donne a Claude une abstraction de niveau superieur pour l’execution parallele. En lui fournissant un outil explicitement concu pour regrouper des appels, on l’encourage a battre les operations ensemble.

Les avantages :

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

C’est une technique simple mais efficace pour optimiser les interactions avec Claude quand plusieurs operations independantes doivent etre effectuees.