Ajouter plusieurs outils

Maintenant qu’un outil fonctionne de bout en bout, il est temps d’ajouter les deux outils restants pour compléter notre système de rappels : add_duration_to_datetime et set_reminder. La bonne nouvelle tient en une phrase : une fois les fondations en place, ajouter de nouveaux outils est simple — et cette leçon en est la démonstration, car ni la boucle de conversation, ni la gestion des blocs, ni le traitement des erreurs n’auront à bouger.

Ajouter les schémas à la conversation

Premier branchement : la liste des schémas transmise à l’API s’allonge.

tools=[
    get_current_datetime_schema,
    add_duration_to_datetime_schema,
    set_reminder_schema
]

Claude reçoit désormais les trois définitions à chaque requête et choisit librement — l’un, plusieurs en séquence, ou aucun. Ce choix ne repose que sur les descriptions rédigées dans les schémas : c’est maintenant que le soin mis à les écrire paie. Trois outils aux descriptions nettes et disjointes se laissent router sans erreur ; des descriptions qui se chevauchent produiraient des appels hésitants. Pensez aussi au coût marginal : chaque schéma ajouté est renvoyé avec chaque requête — une boîte à outils se garde ciblée.

Connecter les fonctions

Second branchement : la fonction run_tool apprend les nouveaux noms.

def run_tool(tool_name, tool_input):
    if tool_name == "get_current_datetime":
        return get_current_datetime(**tool_input)
    elif tool_name == "set_reminder":
        return set_reminder(**tool_input)
    elif tool_name == "add_duration_to_datetime":
        return add_duration_to_datetime(**tool_input)
    else:
        raise Exception(f"Nom d'outil inconnu : {tool_name}")

Deux détails valent l’arrêt. Le **tool_input décompresse le dictionnaire d’arguments généré par Claude en arguments nommés — c’est lui qui permet à run_tool de rester générique sans connaître les signatures. Et la branche else finale est votre filet : si Claude demande un jour un outil que le routeur ignore — faute de frappe dans un schéma, outil retiré —, l’erreur est explicite et immédiate, au lieu d’un None silencieux qui empoisonnerait la conversation trois tours plus loin.

Tester le système complet

Avec tous les outils connectés, testez des workflows complexes nécessitant plusieurs appels. Par exemple : « Créez un rappel pour aller chez le médecin. Le rendez-vous est dans 100 jours. »

Claude décompose automatiquement la demande en étapes logiques :

1. Obtenir la date actuelle avec get_current_datetime
2. Ajouter 100 jours avec add_duration_to_datetime
3. Créer le rappel avec set_reminder

Ce plan n’est écrit nulle part dans votre code — Claude l’a déduit de la demande et des descriptions d’outils. Observez la structure de dépendance : l’étape 2 a besoin du résultat de l’étape 1, l’étape 3 du résultat de la 2. C’est exactement ce que la boucle de conversation multi-tours rend possible : à chaque tour, le modèle voit les résultats précédents et décide de la suite. En exécutant le test, vous verrez d’ailleurs Claude expliquer son plan avant chaque appel d’outil — la sortie montre le workflow complet, la date future calculée, puis la confirmation du rappel.

Point clé

Une fois l’infrastructure de base du Tool Use en place, ajouter un outil ne nécessite que deux étapes simples :

1. Inclure le schéma dans votre tableau d’outils
2. Ajouter un cas dans votre fonction d’acheminement

Plus, bien sûr, l’écriture de la fonction elle-même. La configuration initiale — blocs, boucle, résultats — a pu sembler complexe, mais c’était un coût fixe : le passage à l’échelle avec cinq, dix ou vingt outils reste très gérable, car chaque ajout répète le même petit rituel sans toucher au moteur.

Points clés à retenir

• Ajouter un outil = un schéma dans la liste + un cas dans run_tool — le moteur ne change pas
• Le routage repose sur les descriptions des schémas : nettes et disjointes = appels fiables
• La branche else transforme un outil inconnu en erreur explicite plutôt qu’en silence toxique
• Claude planifie seul les enchaînements dépendants (date → calcul → rappel) grâce à la boucle multi-tours
• L’infrastructure est un coût fixe : la boîte à outils grandit à coût marginal minime