← Blog
Une sonnette de comptoir lavande avec un bouton orange et une base crème sur fond clair.
Publié le
2026-11-16

Appel d’outils LLM : construire une boucle contrôlée

L'appel d'outils par un LLM, aussi appelé function calling, permet à un modèle de demander une opération nommée avec des arguments structurés. L'application reçoit cette demande, vérifie sa validité et les droits d'accès, exécute l'opération, puis transmet le résultat au modèle. La consultation de l'état d'une tâche constitue un bon premier exemple : l'assistant répond à partir des données actuelles de l'application, sans obtenir un accès libre à la base de données.

Ce guide construit un petit gestionnaire Python en lecture seule et teste les contrôles qui précèdent l'exécution. Les réponses sont simulées : aucun identifiant, téléchargement de modèle ou accès réseau n'est nécessaire. L'exemple vérifie le comportement de l'application. Il ne mesure pas la capacité d'un modèle à choisir un outil et ne prouve pas qu'un point de terminaison d'inférence le prend en charge.

Comment fonctionne le function calling ?

Une interaction courante comporte cinq étapes. L'application envoie la question et les définitions des outils disponibles. Le modèle renvoie un nom d'outil, des arguments et un identifiant d'appel. L'application valide la demande et les autorisations avant d'exécuter l'outil. Elle ajoute le résultat à la conversation en l'associant à cet identifiant. Le modèle formule alors une réponse ou demande une autre opération. Le guide de Hugging Face sur le function calling illustre les définitions d'outils avec un nom, une description et un schéma de paramètres.

Une réponse conforme au schéma ne suffit pas à couvrir toute cette séquence. La tâche demandée peut appartenir à un autre utilisateur, le service peut être indisponible ou le modèle peut répéter une demande. L'application doit définir le comportement attendu dans chaque cas.

BesoinApproche adaptéeResponsabilité de l'application
Extraire des champs d'un texte fourniSortie structuréeVérifier les valeurs et leur correspondance avec la source
Consulter l'état actuel d'une tâche autoriséeOutil ciblé en lecture seuleIdentité, droits d'accès, consultation et traitement du résultat
Annuler une tâche ou modifier un enregistrementOutil d'écriture distinctRègles de validation, idempotence durable et journal d'audit
Choisir un serveur d'inférence disponibleCouche de routage d'inférenceCompatibilité du serveur et exécution des outils applicatifs

Commencer par un outil au périmètre limité

L'exemple expose get_job_status(job_id). Il accepte un identifiant et renvoie l'un des trois états suivants : queued, running ou complete. Il ne peut ni exécuter du SQL arbitraire, ni accepter une URL, ni modifier une tâche. Cette interface réduite facilite l'examen du comportement attendu et des cas d'échec.

L'application fournit les identifiants autorisés à partir d'un contexte de confiance. Le modèle ne fournit aucun identifiant d'utilisateur, d'organisation ou indicateur d'autorisation. Dans un service réel, déduisez les droits de la session authentifiée et appliquez les mêmes restrictions dans le service de données. L'ensemble fixe d'identifiants ci-dessous montre où placer ce contrôle ; il ne constitue pas un système d'authentification.

Le schéma et les contrôles à l'exécution expriment le même contrat d'arguments. Le gestionnaire refuse aussi les clés JSON répétées, les champs supplémentaires et les chaînes d'arguments trop longues. Le format des identifiants d'appel et les limites de taille sont des règles propres à cette démonstration. Vérifiez leur compatibilité avec votre protocole.

Une boucle d'appel d'outils exécutable en Python

Enregistrez le code suivant dans tool_loop.py. Il utilise uniquement la bibliothèque standard de Python et une structure de messages de type Chat Completions. D'autres API peuvent représenter les appels et les résultats différemment. La fonction de rappel next_message correspond à l'emplacement d'un futur adaptateur de point de terminaison. Ici, elle renvoie deux réponses simulées.

import copy
import json
import re

TOOL = {
    "type": "function",
    "function": {
        "name": "get_job_status",
        "description": "Read the status of one job accessible to this user.",
        "parameters": {
            "type": "object",
            "properties": {"job_id": {"type": "string", "pattern": "^job-[0-9]{3}$"}},
            "required": ["job_id"], "additionalProperties": False,
        },
    },
}


def unique_object(pairs):
    result = {}
    for key, value in pairs:
        if key in result:
            raise ValueError("Duplicate JSON key")
        result[key] = value
    return result


def handle_call(call, allowed_jobs, lookup, seen_ids, seen_jobs):
    if not isinstance(call, dict) or call.get("type") != "function":
        raise ValueError("Invalid tool envelope")
    call_id, function = call.get("id"), call.get("function")
    if (not isinstance(call_id, str) or not re.fullmatch(r"[A-Za-z0-9_-]{1,64}", call_id)
            or call_id in seen_ids or not isinstance(function, dict)):
        raise ValueError("Invalid or reused call ID")
    seen_ids.add(call_id)

    def reply(payload):
        return {"role": "tool", "tool_call_id": call_id,
                "content": json.dumps(payload, separators=(",", ":"))}

    if function.get("name") != "get_job_status":
        return reply({"error": "unknown_tool"})
    raw = function.get("arguments")
    try:
        if not isinstance(raw, str) or len(raw) > 2048:
            raise ValueError("Invalid argument payload")
        args = json.loads(raw, object_pairs_hook=unique_object)
        if (not isinstance(args, dict) or set(args) != {"job_id"}
                or not isinstance(args["job_id"], str)
                or not re.fullmatch(r"job-[0-9]{3}", args["job_id"])):
            raise ValueError("Invalid job argument")
    except (ValueError, RecursionError):
        return reply({"error": "invalid_arguments"})
    job_id = args["job_id"]
    if job_id not in allowed_jobs:
        return reply({"error": "not_available"})
    if job_id in seen_jobs:
        return reply({"error": "duplicate_request"})
    seen_jobs.add(job_id)
    try:
        status = lookup(job_id)
    except Exception:
        return reply({"error": "lookup_failed"})
    if status not in ("queued", "running", "complete"):
        return reply({"error": "lookup_failed"})
    return reply({"job_id": job_id, "status": status})


def run_loop(next_message, lookup, allowed_jobs, max_turns=3):
    if type(max_turns) is not int or not 1 <= max_turns <= 10:
        raise ValueError("Choose 1 to 10 model turns")
    allowed_jobs = frozenset(allowed_jobs)  # Trusted application context.
    messages = [{"role": "user", "content": "What is the status of job-001?"}]
    seen_ids, seen_jobs = set(), set()
    for _ in range(max_turns):
        message = next_message(copy.deepcopy(messages), [copy.deepcopy(TOOL)])
        if not isinstance(message, dict) or message.get("role") != "assistant":
            raise ValueError("Invalid assistant message")
        calls = message.get("tool_calls")
        if calls is None or calls == []:
            answer = message.get("content")
            if not isinstance(answer, str) or not answer.strip():
                raise ValueError("Missing final answer")
            messages.append({"role": "assistant", "content": answer})
            return answer, messages
        if not isinstance(calls, list) or len(calls) != 1:
            raise ValueError("This example accepts one tool call per turn")
        result = handle_call(calls[0], allowed_jobs, lookup, seen_ids, seen_jobs)
        messages.append({"role": "assistant", "content": None,
                         "tool_calls": copy.deepcopy(calls)})
        messages.append(result)
    raise RuntimeError("Model-turn limit reached")


def demo():
    scripted = iter([
        {"role": "assistant", "content": None, "tool_calls": [{
            "id": "call_1", "type": "function", "function": {
                "name": "get_job_status", "arguments": '{"job_id":"job-001"}'}}]},
        {"role": "assistant", "content": "Job job-001 is running."},
    ])
    answer, messages = run_loop(
        lambda history, tools: next(scripted),
        lambda job_id: {"job-001": "running"}[job_id],
        allowed_jobs={"job-001"},
    )
    print(messages[2]["content"])
    print(answer)


if __name__ == "__main__":
    demo()

Exécutez le fichier avec Python :

python tool_loop.py

Le jeu de données local produit :

{"job_id":"job-001","status":"running"}
Job job-001 is running.

L'application conserve l'appel de l'assistant et le résultat correspondant dans l'historique. Un outil inconnu, des arguments invalides, un accès refusé ou un échec du service produit un petit objet d'erreur. Une structure de message invalide ou un identifiant d'appel réutilisé arrête la boucle. L'exemple accepte un seul appel d'outil par tour et s'arrête après trois requêtes au modèle si aucune réponse finale n'arrive.

Une nouvelle demande pour la même tâche, avec un autre identifiant d'appel, renvoie duplicate_request. L'exemple applique volontairement une seule tentative par tâche, y compris après l'échec d'une consultation. Il évite ainsi de relancer une opération sans décision explicite. En production, un service de lecture peut nécessiter une autre politique de reprise ou de fraîcheur des données, avec ses propres limites.

Ce que les tests locaux vérifient

Nous avons exécuté ce code avec des messages simulés et des fonctions locales. Les 14 tests automatisés ont réussi, avec plusieurs sous-cas de charges utiles mal formées. Ils couvrent le résultat autorisé, la correspondance des identifiants, l'ordre de l'historique, les outils inconnus, les arguments invalides, les tâches interdites, les répétitions, les exceptions, les sorties inattendues du service, les messages mal formés, les appels multiples, l'absence de réponse finale et la limite de tours.

Les tests d'accès refusé et d'outil inconnu vérifient que la consultation n'a jamais lieu. Le test de répétition vérifie qu'un second appel ne déclenche pas une seconde consultation. Le test d'échec provoque une exception TimeoutError simulée et vérifie que ses détails privés ne sont pas transmis au modèle.

Ces contrôles ne démontrent ni la précision d'un modèle ni le respect d'un délai réel. La réponse finale de la démonstration est prédéfinie. Pour un assistant déployé, évaluez la correspondance entre ses réponses et les résultats des outils, y compris les erreurs et les informations absentes. Une réponse incorrecte peut suivre un appel valide et une consultation réussie.

Brancher un véritable point de terminaison

Avant de remplacer les réponses simulées, vérifiez ensemble le modèle, le moteur d'inférence, l'analyseur d'appels et le format d'API. La documentation de vLLM sur l'appel d'outils décrit les configurations propres aux modèles et distingue les appels analysables de leur qualité. Un point de terminaison compatible avec OpenAI ne prouve pas, à lui seul, que votre schéma et votre séquence de messages fonctionneront. Notre guide des API compatibles avec OpenAI aborde le choix de l'intégration.

Créez un adaptateur qui transmet l'historique et les outils, puis convertit la réponse vers la structure acceptée par votre gestionnaire. Pour cet exemple, utilisez des messages complets, sans diffusion en continu. Si vous ajoutez le streaming, reconstituez l'appel entier avant d'analyser ses arguments ou de l'exécuter. Définissez le traitement des appels multiples ; cette version les refuse avant toute exécution.

Préparez un petit jeu d'évaluation comprenant des questions qui exigent une consultation, des questions sans outil, des identifiants ambigus, des tâches interdites et des services indisponibles. Mesurez séparément le choix de l'outil, la justesse des arguments, les décisions d'accès, la fidélité de la réponse finale, la latence et le coût total des requêtes. Reprenez ces vérifications après un changement de modèle, d'analyseur ou de configuration du moteur.

Encadrer le travail effectué

La limite de trois tours borne le nombre de requêtes au modèle. Elle n'interrompt pas un appel réseau bloqué. Configurez de vrais délais de connexion et de réponse dans les clients d'inférence et de données, avec des mécanismes d'annulation adaptés. Limitez aussi la taille des résultats et la durée totale.

Cette démonstration renvoie uniquement un identifiant et un état issu d'une liste autorisée. Elle ne transmet ni erreurs brutes du service ni texte arbitraire. Les outils qui lisent des documents nécessitent d'autres précautions : le texte récupéré peut contenir des instructions, et il ne doit pas déterminer les permissions accordées par l'application. Examinez séparément l'accès au point de terminaison et son exposition réseau avec le guide de sécurité des LLM auto-hébergés (en anglais).

Les ensembles qui repèrent les doublons ne durent qu'une boucle et restent en mémoire. Ils ne garantissent pas une idempotence durable entre processus, redémarrages ou reprises. Avant d'ajouter un outil d'écriture, définissez l'action que l'utilisateur valide, contrôlez les droits au moment de l'exécution et enregistrez un identifiant d'opération géré par l'application. Les identifiants d'appel du modèle servent à la corrélation ; ne leur attribuez pas une garantie d'exécution unique.

Conservez des traces qui relient la requête, la décision d'appel, le résultat de l'exécution et la réponse finale. Masquez les arguments et résultats sensibles. Un opérateur doit pouvoir distinguer une tâche incorrectement demandée par le modèle d'une consultation valide refusée par le service.

Où intervient Hivenet ?

Pour un assistant qui consulte des données métier sensibles, partez d'un cas concret : qui pose les questions, quels enregistrements sont accessibles, quelles opérations sont permises et ce qui constitue une réponse correcte. Private AI avec Hivenet peut aider à définir le modèle, l'infrastructure, le parcours des données et les modalités d'exploitation selon ces besoins.

Si vous exploitez plusieurs serveurs d'inférence compatibles, Hivenet Router fournit une couche de routage auto-hébergée. Conservez l'exécution des outils et les permissions applicatives dans votre application, puis testez les appels via le serveur effectivement sélectionné. L'exemple de ce guide n'a été testé ni avec Router ni avec un véritable point de terminaison de modèle.

Présentez une consultation type, ses règles d'accès et la réponse attendue lors d'un échange sur votre projet. L'équipe disposera ainsi d'un cas mesurable à tester avant d'élargir les accès ou d'ajouter des opérations qui modifient les données.

Votre prochaine charge de travail sur Hivenet.

Choisissez une charge de travail d’IA, de calcul ou de stockage à tester sur Hivenet, ou échangez avec notre équipe sur sa mise en production.