Pourquoi le function calling est devenu incontournable

Le function calling ne rend pas un modèle plus intelligent : il lui impose un contrat vérifiable. Schémas stricts, coût caché des tokens, et pourquoi MCP ne change pas la donne.

Pourquoi le function calling est devenu incontournable

Un modèle qui répond « 42 » sans avoir interrogé ta base de données, c'est une hallucination. Un modèle qui répond « 42 » après avoir demandé l'appel de get_order_status(order_id="A-1042"), c'est un système. Toute la différence tient dans une poignée de JSON Schema, et c'est ce qui est devenu le socle de tout ce qui fonctionne en production.

Le function calling n'appelle aucune fonction

Le nom est trompeur, et ça coûte cher à ceux qui découvrent le sujet en urgence. Le modèle ne déclenche rien : il produit un objet JSON qui affirme qu'un outil devrait être appelé avec tels arguments.

C'est ton code qui exécute. Le guide OpenAI du function calling est sans ambiguïté : la réponse contient un tool_calls avec un nom et des arguments, tu lances la fonction toi-même, puis tu renvoies le résultat dans un message tool.

Cette séparation n'est pas un défaut de conception. Elle te laisse la main sur les permissions, les timeouts et les effets de bord. Un modèle ne peut pas supprimer une ligne de ta base parce qu'il en a soudainement eu envie.

Ce qui a réellement changé en deux ans

La première génération était une blague. Le modèle inventait des arguments plausibles, oubliait un champ obligatoire, glissait une chaîne là où tu attendais un entier.

Deux évolutions ont réglé l'essentiel. Côté OpenAI, les schémas stricts avec "strict": true et "additionalProperties": false contraignent la sortie au niveau du décodeur, plus au niveau de la bonne volonté du modèle.

La seconde est la capacité à ne rien appeler du tout. Le tool use d'Anthropic autorise très explicitement un tour avec du texte seul, sans appel d'outil. C'est la fonctionnalité la plus sous-estimée du lot, et celle qui sépare un agent utilisable d'un agent qui appuie sur tous les boutons.

L'exemple qui m'a fait changer d'avis

Un support client, deux outils : get_order_status pour consulter une commande, create_refund pour rembourser. Sans schéma strict, le modèle lançait le remboursement sur une simple question de suivi, environ une fois sur vingt.

{
  "name": "create_refund",
  "description": "Rembourse une commande livrée et non conforme.",
  "strict": true,
  "parameters": {
    "type": "object",
    "properties": {
      "order_id": { "type": "string", "pattern": "^[A-Z]-[0-9]{4}$" },
      "reason": { "type": "string", "enum": ["casse", "erreur_produit", "retard_majeur"] }
    },
    "required": ["order_id", "reason"],
    "additionalProperties": false
  }
}

Avec ce contrat, l'appel parasite disparaît : le modèle n'a plus de champ libre pour improviser un identifiant. Le gain ne venait pas d'un modèle plus intelligent, il venait du schéma.

Le vrai déplacement, c'est que la qualité d'un agent se joue désormais dans la description des outils. Une description vague comme « gère les commandes » garantit des appels faux, quel que soit le modèle derrière.

Le coût que personne ne facture

Chaque définition d'outil repart dans le prompt à chaque tour. Dix outils avec des descriptions verbeuses, c'est facilement 1 500 à 2 000 tokens consommés avant même que ta question soit posée.

Sur un agent qui boucle dix fois, tu paies dix fois ce catalogue. Le prix du function calling n'est pas dans l'appel, il est dans la répétition.

La parade est banale et rarement appliquée : exposer moins d'outils par étape, couper les descriptions à une phrase, router en amont vers un sous-ensemble pertinent. Retirer six outils jamais utilisés d'un agent m'a déjà divisé une facture par trois, sans perdre une seule fonctionnalité.

Le contre-argument sérieux : MCP rendrait tout ça obsolète

L'objection tient debout. Le protocole MCP standardise la découverte et l'exposition des outils, ce qui évite de recâbler chaque intégration dans chaque application.

Mais MCP ne remplace pas le function calling, il l'enveloppe. La spec décrit comment un client liste puis invoque des outils, pas comment ton modèle choisit, ni comment tu valides les arguments avant exécution.

L'appel effectif reste à la charge du client : c'est du function calling sous le capot, avec les mêmes schémas et les mêmes erreurs silencieuses. Tu gagnes en interopérabilité, pas en fiabilité. J'ai détaillé les limites du modèle côté agents dans cette analyse des agents tool-use.

Et si ton besoin est de nourrir le modèle avec tes documents plutôt que de lui donner des actions, tu es sur un autre chantier : le RAG. Le point de départ est ce guide de configuration d'un environnement RAG.

Les évaluations qui comptent vraiment

Le Berkeley Function Calling Leaderboard est devenu la référence du domaine, et c'est mérité. Il ne mesure pas seulement le taux d'appels réussis : il teste aussi les appels multiples, le parallélisme et la détection de non-pertinence.

Ce dernier critère est le vrai discriminant. Un modèle qui appelle systématiquement quelque chose est plus dangereux qu'un modèle qui refuse, et la plupart des benchmarks maison l'ignorent complètement.

Mon test tient en dix prompts : cinq qui exigent un outil, cinq qui n'en exigent aucun. Si le modèle échoue sur les cinq seconds, inutile d'optimiser le prompt, il faut changer de modèle ou resserrer les descriptions.

Ce que j'en retiens

Le function calling est devenu incontournable parce qu'il transforme un générateur de texte en composant d'architecture. Il n'ajoute pas d'intelligence : il ajoute un contrat vérifiable entre le modèle et ton système.

Les équipes qui se cassent les dents dessus ne se trompent généralement pas de modèle, elles se trompent de contrat. Schémas lâches, descriptions floues, aucune validation côté serveur : le LLM fait ce qu'il peut avec ce qu'on lui donne.

La prochaine fois qu'un agent part en vrille, regarde le schéma avant de regarder le prompt. C'est là que se cache la majorité des bugs, et c'est aussi le seul endroit que tu contrôles vraiment.