Chargement

Conversations multi-tours avec des outils

Leçon 2710 min
Chargement

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.

Quatre messages entre notre serveur et Claude, avec l'historique complet des messages omis par souci de clarté, décrit ci-dessous.

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 :

  1. L'utilisateur demande : « Quel jour sommes-nous dans 103 jours ? »
  2. Claude répond avec un bloc d'utilisation d'outils demandant get_current_datetime
  3. Votre serveur appelle la fonction et renvoie le résultat
  4. Claude se rend compte qu'il a besoin de plus d'informations et demande add_duration_to_datetime
  5. Votre serveur appelle cette fonction et renvoie le résultat
  6. Claude dispose désormais de suffisamment d'informations pour fournir la réponse finale

Diagramme des étapes ci-dessus sous forme de cinq messages entre votre serveur et Claude, utilisant des blocs ToolUse et ToolResult.

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 :

python
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

La boucle dans le code ci-dessus : si Claude ne demande pas d'outil, nous avons la réponse finale, sinon nous exécutons l'outil et recommençons.

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 :

python
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 :

python
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 message

Extraction 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 :

python
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.