Chargement

Implémenter les tours multiples

Leçon 2715 min
Chargement

La création d'un système de conversation avec des outils nécessite la mise en œuvre d'une boucle qui continue à 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 préparé une réponse finale 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 doit 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 de conversation principale suit un modèle 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 aucun outil.

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ésultat d'outil

Chaque bloc d'utilisation d'outils doit recevoir en réponse un bloc de résultat d'outil correspondant. Le lien entre eux est maintenu grâce à des identifiants correspondants :

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.

La structure du bloc de résultat d'outil comprend :

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 d'outils robuste nécessite de gérer les erreurs potentielles. Lorsqu'un outil échoue, nous devons tout de même fournir un bloc de résultat à Claude :

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 qui associe les noms d'outils à leurs implémentations :

python
def run_tool(tool_name, tool_input):
    if tool_name == "get_current_datetime":
        return get_current_datetime(**tool_input)
    elif tool_name == "another_tool":
        return another_tool(**tool_input)
    # Ajoutez d'autres outils selon vos besoins

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

Flux de travail complet

La conversation multi-tours complète fonctionne ainsi :

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

Cela crée une expérience fluide où Claude peut utiliser plusieurs outils sur plusieurs tours pour répondre pleinement à des demandes d'utilisateur complexes. L'historique de la conversation maintient le contexte complet, permettant à Claude de s'appuyer sur les résultats d'outils précédents pour fournir des réponses complètes.