Chargement

L'outil de traitement par lots

Leçon 3010 min
Chargement

Lorsque vous travaillez avec les capacités d'appel d'outils de Claude, vous remarquerez peut-être que Claude peut inclure plusieurs blocs d'utilisation d'outils dans un seul message de l'assistant. Cela permet à Claude d'exécuter plusieurs outils en parallèle plutôt que d'effectuer des requêtes séparées pour chacun. Cependant, amener Claude à faire cela de manière constante peut s'avérer difficile en pratique.

Le problème des appels d'outils multiples

Supposons que vous demandiez à Claude de définir deux rappels pour la même date. En théorie, Claude devrait pouvoir renvoyer une seule réponse contenant deux blocs d'utilisation d'outils - un pour chaque rappel. Mais en réalité, Claude envoie souvent des réponses séparées à la place.

L'échange idéal : un message de l'assistant avec deux utilisations de l'outil set_reminder pour le 1er janvier, « Taxes dues » et « Rendez-vous chez le médecin ».

Ce qui se passe généralement, c'est que Claude effectue le premier appel d'outil, attend le résultat, puis effectue le second appel d'outil dans un message de suivi. Cela crée des allers-retours inutiles dans la communication alors que les opérations auraient pu être effectuées simultanément.

Claude répond à la demande de nos deux rappels de notre serveur avec un seul appel batch_tool : set_reminder pour « RDV médecin » et « Taxes dues ».

La solution de l'outil de traitement par lots

La solution consiste à implémenter un « outil de traitement par lots » - un outil spécial qui accepte une liste d'autres appels d'outils à exécuter simultanément. Il s'agit essentiellement d'une solution de contournement qui incite Claude à effectuer plusieurs appels d'outils en même temps.

Claude répond à la demande de nos deux rappels de notre serveur avec un seul appel batch_tool : set_reminder pour « RDV médecin » et « Taxes dues ».

Voici comment cela fonctionne :

  • Vous définissez un schéma d'outil de traitement par lots qui indique à Claude qu'il peut exécuter plusieurs autres outils en parallèle
  • Au lieu d'appeler les outils directement, Claude appelle l'outil de traitement par lots avec une liste d'invocations d'outils
  • Votre code traite cette liste et exécute chaque appel d'outil
  • Vous renvoyez les résultats combinés à Claude

Implémentation du schéma de l'outil de traitement par lots

Le schéma de l'outil de traitement par lots définit la manière dont Claude doit structurer ses requêtes lorsqu'il souhaite exécuter plusieurs outils :

python
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"
                        }
                    }
                }
            }
        }
    }
}

Traitement des appels de l'outil de traitement par lots

Lorsque Claude utilise l'outil de traitement par lots, vous devez traiter la liste des invocations et exécuter chacune d'elles. Voici l'implémentation :

python
def run_batch(invocations=[]):
    batch_output = []
    
    for invocation in invocations:
        name = invocation["name"]
        args = invocation["arguments"]
        
        tool_output = run_tool(name, args)
        
        batch_output.append({
            "tool_name": name,
            "output": tool_output
        })
    
    return batch_output

Vous devrez également mettre à jour votre fonction principale de routage des outils pour gérer les appels de l'outil de traitement par lots :

python
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

Avec l'outil de traitement par lots implémenté, Claude est beaucoup plus susceptible de regrouper les opérations associées. Au lieu d'effectuer des requêtes séparées pour chaque rappel, Claude utilisera l'outil de traitement par lots pour définir les deux rappels simultanément.

Le flux de la conversation devient beaucoup plus propre - une requête de l'utilisateur, une réponse de Claude avec l'appel de l'outil de traitement par lots, et un suivi unique contenant tous les résultats. Cela réduit la latence et rend votre application plus efficace.

Bien que cela puisse sembler être une solution de contournement (et c'en est une), le modèle de l'outil de traitement par lots constitue un moyen efficace d'encourager Claude à réfléchir aux opérations qui peuvent être parallélisées et à les exécuter plus efficacement.