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 cohérente 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.
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 échanges inutiles alors que les opérations auraient pu être effectuées simultanément.
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 à la fois.
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 directement les outils, 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 comment Claude doit structurer ses requêtes lorsqu'il souhaite exécuter plusieurs outils :
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 :
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_outputVous devrez également mettre à jour votre fonction principale de routage des outils pour gérer les appels de l'outil de traitement par lots :
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
Une fois l'outil de traitement par lots implémenté, Claude est beaucoup plus susceptible de regrouper les opérations liées entre elles. 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 conversation devient beaucoup plus clair - une requête de l'utilisateur, une réponse de Claude avec l'appel de l'outil de traitement par lots, et un suivi avec 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 est un moyen efficace d'encourager Claude à réfléchir aux opérations qui peuvent être parallélisées et à les exécuter plus efficacement.