Utiliser plusieurs outils ensemble

Une fois l’infrastructure de base en place (boucle de conversation, routage, gestion des résultats), ajouter de nouveaux outils devient très simple. On suit toujours le même schéma.

Exemple concret : un système de rappels

L’exemple des rappels a été choisi pour une raison précise : il montre pourquoi on découpe en plusieurs outils plutôt qu’en un seul. On pourrait écrire un unique outil « programmer un rappel dans 177 jours » ; il faudrait alors qu’il sache aussi quelle date on est et comment additionner des jours — trois responsabilités dans une fonction, et un schéma que Claude remplira mal.

Découpé en trois outils au périmètre net, chacun fait une chose vérifiable, et c’est Claude qui orchestre l’enchaînement. Notez au passage le deuxième : le calcul de dates lui est confié précisément parce qu’un modèle de langage n’est pas fiable pour compter les jours.

1. Obtenir la date et l’heure actuelles - pour savoir “quand on est”
2. Ajouter une durée à une date - Claude n’est pas fiable pour le calcul de dates
3. Créer un rappel - pour effectivement programmer le rappel

Chaque capacité correspond à un outil avec sa fonction et son schéma JSON.

Déclarer les outils disponibles

On passe la liste complète des schémas dans l’appel à Claude :

response = chat(messages, tools=[
    get_current_datetime_schema,
    add_duration_to_datetime_schema,
    set_reminder_schema
])

Claude connaît ainsi les trois outils et peut décider lesquels utiliser selon le contexte.

Mettre à jour le routeur d’outils

On ajoute simplement les nouveaux cas dans la fonction de routage :

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)

Le principe est toujours le même : vérifier le nom de l’outil, appeler la fonction correspondante avec les arguments fournis, retourner le résultat. Ce routeur est le seul endroit de votre code qui grandit avec le nombre d’outils — raison de plus pour qu’il ne fasse que router. Toute logique métier qui s’y glisse deviendra impossible à tester isolément.

Test avec un cas réel

Pour vérifier que tout fonctionne, on peut envoyer une requête qui nécessite plusieurs outils en séquence :

“Programme un rappel pour mon rendez-vous médical. C’est 177 jours après le 1er janvier 2050.”

Claude va alors :

1. Appeler add_duration_to_datetime pour calculer la date (27 juin 2050)
2. Appeler set_reminder pour programmer le rappel à cette date

Chaque appel est un tour de la boucle de conversation. Claude enchaîne les outils de manière autonome.

Le flux des messages

En examinant l’historique de la conversation, on voit la structure complète :

1. Message utilisateur avec la demande initiale
2. Message assistant contenant du texte explicatif ET des blocs tool_use
3. Messages de résultats d’outils
4. Messages assistant de suivi avec d’éventuels nouveaux appels d’outils
5. Réponse finale de Claude

Cette structure explique un bug classique du débutant : lire response.content[0] en supposant que c’est le texte, alors que le premier bloc peut très bien être un tool_use. Parcourez toujours la liste et traitez chaque bloc selon son type. Un point important : Claude peut inclure plusieurs types de blocs dans un seul message — du texte explicatif mélangé à des demandes d’outils.

Le schéma d’ajout d’outils

Une fois l’infrastructure en place, ajouter un nouvel outil suit toujours ces quatre étapes :

1. Écrire la fonction qui implémente la logique de l’outil
2. Définir le schéma JSON qui décrit les paramètres attendus
3. Ajouter le schéma à la liste tools dans run_conversation
4. Ajouter un cas dans la fonction run_tool

Cette approche modulaire permet d’enrichir les capacités de l’assistant sans toucher au code existant. Chaque nouvel outil s’intègre naturellement dans le flux de conversation et la logique de gestion des outils.