Lorsque vous créez des applications avec plusieurs outils, vous devez gérer des scénarios où Claude peut avoir besoin d'appeler plusieurs outils en séquence pour répondre à une seule question de l'utilisateur. Par exemple, si un utilisateur demande « Quel jour sommes-nous dans 103 jours ? », Claude doit d'abord obtenir la date actuelle, puis y ajouter 103 jours.

Cela crée un modèle de conversation multi-tours dans lequel Claude effectue plusieurs demandes d'outils avant de fournir une réponse finale. Votre application doit gérer cela automatiquement.
Le modèle d'outils multi-tours
Voici ce qui se passe en coulisses lorsque Claude a besoin de plusieurs outils :
- L'utilisateur demande : « Quel jour sommes-nous dans 103 jours ? »
- Claude répond avec un bloc d'utilisation d'outils demandant
get_current_datetime - Votre serveur appelle la fonction et renvoie le résultat
- Claude se rend compte qu'il a besoin de plus d'informations et demande
add_duration_to_datetime - Votre serveur appelle cette fonction et renvoie le résultat
- Claude dispose désormais de suffisamment d'informations pour fournir la réponse finale

Construction d'une boucle de conversation
Pour gérer ce modèle, vous avez besoin d'une boucle de conversation qui continue jusqu'à ce que Claude cesse de demander des outils :
def run_conversation(messages):
while True:
response = chat(messages)
add_assistant_message(messages, response)
# Pseudo-code
if response isn't asking for a tool:
break
tool_result_blocks = run_tools(response)
add_user_message(messages, tool_result_blocks)
return messages
Refactorisation des fonctions d'aide
Avant d'implémenter la boucle de conversation, vous devez mettre à jour vos fonctions d'aide pour gérer correctement plusieurs blocs de message.
Mise à jour des gestionnaires de messages
Vos fonctions add_user_message et add_assistant_message supposent actuellement qu'elles travaillent toujours avec du texte brut. Mettez-les à jour pour gérer des objets de message complets :
from anthropic.types import Message
def add_user_message(messages, message):
user_message = {
"role": "user",
"content": message.content if isinstance(message, Message) else message
}
messages.append(user_message)Cela vous permet de transmettre soit une chaîne de caractères, soit une liste de blocs, soit un objet de message complet.
Mise à jour de la fonction de chat
Modifiez votre fonction de chat pour qu'elle accepte une liste d'outils et renvoie le message complet au lieu du simple texte :
def chat(messages, system=None, temperature=1.0, stop_sequences=[], tools=None):
params = {
"model": model,
"max_tokens": 1000,
"messages": messages,
"temperature": temperature,
"stop_sequences": stop_sequences,
}
if tools:
params["tools"] = tools
if system:
params["system"] = system
message = client.messages.create(**params)
return messageExtraction du texte des messages
Étant donné que la fonction de chat renvoie désormais des messages complets au lieu de simplement du texte, ajoutez une fonction d'aide pour extraire le texte lorsque c'est nécessaire :
def text_from_message(message):
return "\n".join(
[block.text for block in message.content if block.type == "text"]
)Cette fonction trouve tous les blocs de texte dans un message et les assemble, ce qui est utile lorsque vous devez afficher la réponse finale aux utilisateurs.
Pourquoi ces changements sont importants
Ces étapes de refactorisation préparent votre code à la réalité des conversations utilisant des outils :
- Plusieurs blocs par message - Les réponses de Claude peuvent contenir à la fois des blocs de texte et des blocs d'utilisation d'outils
- Gestion flexible des messages - Vos fonctions peuvent désormais fonctionner avec divers formats de message
- Préservation complète des messages - Vous conservez toutes les informations fournies par Claude, pas seulement les parties textuelles
- Prise en charge des listes d'outils - Votre fonction de chat peut désormais recevoir et utiliser plusieurs outils
Avec ces bases en place, vous êtes prêt à implémenter la boucle de conversation complète qui gère automatiquement plusieurs appels d'outils, créant ainsi une expérience fluide où Claude peut utiliser tous les outils dont il a besoin pour répondre complètement aux questions des utilisateurs.