Chargement

Implémenter plusieurs tours

Leçon 2815 min
Chargement

Construire un système de conversation avec des outils nécessite d'implémenter une boucle qui continue d'appeler Claude jusqu'à ce qu'il cesse de demander l'utilisation d'outils. Lorsque Claude ne demande plus d'outils, cela signale qu'il a une réponse finale prête pour l'utilisateur.

Détecter les demandes d'outils

La clé pour savoir si Claude souhaite utiliser un outil réside dans le champ stop_reason du message de réponse. Lorsque Claude décide qu'il a besoin d'appeler un outil, ce champ est défini sur "tool_use". Cela nous donne un moyen simple de vérifier si nous devons poursuivre la boucle de conversation :

python
if response.stop_reason != "tool_use":
    break  # Claude is done, no more tools needed

La boucle de conversation

La fonction principale de conversation suit un schéma simple :

python
def run_conversation(messages):
    while True:
        response = chat(messages, tools=[get_current_datetime_schema])
        add_assistant_message(messages, response)
        print(text_from_message(response))
        
        if response.stop_reason != "tool_use":
            break
            
        tool_results = run_tools(response)
        add_user_message(messages, tool_results)
    
    return messages

Cette boucle continue jusqu'à ce que Claude fournisse une réponse finale sans demander d'outils.

Gérer plusieurs appels d'outils

Claude peut demander plusieurs outils dans une seule réponse. Le contenu du message contient une liste de blocs, et nous devons traiter chaque bloc d'utilisation d'outils séparément :

message.content contient un TextBlock et des ToolUseBlocks pour "10 + 10" et "30 + 30", chacun exécuté et renvoyé sous forme de ToolResultBlock.

La fonction run_tools gère cela en filtrant les blocs d'utilisation d'outils et en traitant chacun d'eux :

python
def run_tools(message):
    tool_requests = [
        block for block in message.content if block.type == "tool_use"
    ]
    tool_result_blocks = []
    
    for tool_request in tool_requests:
        # Traiter chaque demande d'outil...

Blocs de résultats d'outils

Pour chaque bloc d'utilisation d'outils, nous devons créer un bloc de résultat d'outil correspondant. Ces blocs comportent des champs obligatoires spécifiques :

Cellule de notebook où run_tools appelle get_current_datetime lorsque le nom de l'outil correspond, puis construit un bloc de résultat d'outil.

Le bloc de résultat d'outil doit inclure le même ID que le bloc d'utilisation d'outil d'origine, mais dans le champ tool_use_id :

python
tool_result_block = {
    "type": "tool_result",
    "tool_use_id": tool_request.id,
    "content": json.dumps(tool_output),
    "is_error": False
}

Gestion des erreurs

Une exécution robuste des outils nécessite de gérer les erreurs potentielles. Lorsqu'un outil échoue, nous devons tout de même renvoyer un bloc de résultat d'outil, mais avec des informations d'erreur :

python
try:
    tool_output = run_tool(tool_request.name, tool_request.input)
    tool_result_block = {
        "type": "tool_result",
        "tool_use_id": tool_request.id,
        "content": json.dumps(tool_output),
        "is_error": False
    }
except Exception as e:
    tool_result_block = {
        "type": "tool_result", 
        "tool_use_id": tool_request.id,
        "content": f"Error: {e}",
        "is_error": True
    }

Routage évolutif des outils

Pour prendre en charge plusieurs outils, créez une fonction de routage distincte au lieu de coder en dur les noms d'outils :

python
def run_tool(tool_name, tool_input):
    if tool_name == "get_current_datetime":
        return get_current_datetime(**tool_input)
    elif tool_name == "other_tool":
        return other_tool_function(**tool_input)
    # Ajoutez d'autres outils si nécessaire

Cette approche facilite l'ajout de nouveaux outils sans modifier la logique de conversation principale.

Flux de travail complet

La conversation complète à plusieurs tours fonctionne ainsi :

  • Envoyer le message de l'utilisateur à Claude avec les outils disponibles
  • Claude répond avec du texte et/ou des blocs d'utilisation d'outils
  • Exécuter les outils demandés et créer des blocs de résultats d'outils
  • Renvoyer les résultats des outils à Claude sous forme de message utilisateur
  • Répéter jusqu'à ce que Claude fournisse une réponse finale sans demande d'outils

Cela crée une expérience fluide où Claude peut effectuer plusieurs appels d'outils sur plusieurs tours de conversation afin de rassembler toutes les informations nécessaires avant de fournir une réponse finale complète à l'utilisateur.