Le modèle exécute-t-il lui-même la fonction ?

Non. Le modèle renvoie le nom de la fonction et ses arguments ; c'est votre application qui l'exécute puis renvoie le résultat. Mistral et Google l'écrivent explicitement dans leur documentation.

Comment forcer le modèle à appeler un outil ?

Avec le paramètre de choix d'outil : « any » chez Anthropic, Mistral et Google, « required » chez OpenAI. Chez Anthropic et OpenAI, on peut aussi imposer un outil précis.

Function calling : l'appel d'outils chez quatre éditeurs

Le function calling, ou appel d'outils, permet à un grand modèle de langage (LLM) de demander l'exécution d'une fonction que vous avez décrite. Le modèle ne l'exécute pas : il renvoie le nom de la fonction et ses arguments, votre code l'exécute, puis vous lui renvoyez le résultat pour qu'il continue. C'est le mécanisme de base de tout agent. Les quatre éditeurs comparés ici suivent le même principe, avec des noms de champs différents.

Ce site est édité par IArche, qui édite ALMA, la plateforme IA pour PME d'IArche. Le comparatif ci-dessous décrit la documentation de chaque éditeur telle que lue le 15/11/2026, sans classement.

Le cycle, partout le même

La documentation de Mistral le découpe en cinq étapes :

vous définissez les outils (et, si vous voulez, un message système) ;
l'utilisateur interroge le modèle avec ces outils ;
le modèle génère les arguments de la fonction, si besoin ;
vous exécutez la fonction ;
le modèle produit la réponse finale à partir du résultat.

OpenAI décrit les mêmes cinq étapes, en précisant que la dernière réponse peut contenir… de nouveaux appels d'outils. C'est cette répétition qui fait la boucle d'un agent (voir architecture d'un agent).

Déclarer un outil

Chez les quatre éditeurs, un outil se décrit par un nom, une description et des paramètres au format JSON Schema (un objet avec properties et required). Seule l'enveloppe change :

Éditeur	Champ des paramètres	Enveloppe
Anthropic	`input_schema`	objet outil direct (`name`, `description`, `input_schema`)
Mistral	`parameters`	`{"type": "function", "function": {...}}`
OpenAI	`parameters`	`type: "function"`, `name`, `description`, `parameters`, `strict`
Google (Gemini)	`parameters`	`type: "function"`, `name`, `description`, `parameters`

Recevoir l'appel et renvoyer le résultat

Éditeur	Ce que renvoie le modèle	Ce que vous renvoyez
Anthropic	bloc `tool_use` avec un `id`, et `stop_reason: "tool_use"`	bloc `tool_result` avec `tool_use_id`
Mistral	appel d'outil avec un identifiant	message de rôle `tool` avec `name`, `content` et `tool_call_id`
OpenAI (interface Responses)	appel avec un `call_id`	élément `function_call_output` avec le même `call_id`
Google (Gemini)	appel de fonction avec un `call_id`	étape `function_result` avec `name`, `call_id` et `result`

Dans tous les cas, l'identifiant relie le résultat à l'appel : c'est ce qui permet au modèle de s'y retrouver quand il a demandé plusieurs outils à la fois. Pour brancher des outils une fois pour plusieurs applications plutôt que de les déclarer dans chaque requête, voyez la comparaison MCP ou function calling.

Exemple chez Anthropic

Ce code reprend l'exemple de la documentation d'Anthropic, réduit à l'essentiel :

import anthropic

client = anthropic.Anthropic()
tools = [{
    "name": "get_weather",
    "description": "Get the current weather for a given location.",
    "input_schema": {
        "type": "object",
        "properties": {"location": {"type": "string"}},
        "required": ["location"],
    },
}]
messages = [{"role": "user", "content": "What's the weather in San Francisco?"}]

response = client.messages.create(
    model="claude-opus-5-5", max_tokens=1024, tools=tools, messages=messages)
tool_use = next(b for b in response.content if b.type == "tool_use")

weather = "15 degrees Celsius, partly cloudy"  # votre code appelle le vrai service ici
messages += [
    {"role": "assistant", "content": response.content},
    {"role": "user", "content": [
        {"type": "tool_result", "tool_use_id": tool_use.id, "content": weather}]},
]
followup = client.messages.create(
    model="claude-opus-5-5", max_tokens=1024, tools=tools, messages=messages)

Contrôler quand le modèle appelle un outil

Éditeur	Laisser choisir	Forcer un appel	Interdire	Autres options
Anthropic	`auto` (par défaut)	`any`, ou `tool` pour un outil précis	`none`	`strict: true` pour garantir le respect du schéma
Mistral	`auto` (par défaut)	`any`	`none`	—
OpenAI	`auto` (par défaut)	`required`, ou une fonction précise	`none`	`allowed_tools` pour restreindre à un sous-ensemble ; `strict`
Google (Gemini)	`auto` (par défaut)	`any`	`none`	`validated` pour garantir le respect du schéma

Appels parallèles

Les quatre éditeurs permettent au modèle de demander plusieurs fonctions dans un même tour. Pour l'empêcher : disable_parallel_tool_use: true dans le choix d'outil chez Anthropic, parallel_tool_calls: false chez Mistral et OpenAI. Google distingue les appels parallèles (fonctions indépendantes dans un même tour) et compositionnels (appels enchaînés, par exemple obtenir un lieu puis la météo de ce lieu).

Ce que coûte un outil

Chez Anthropic, les définitions d'outils, les blocs d'appel et les blocs de résultat sont facturés comme des jetons d'entrée ou de sortie ; l'interface de programmation (API) ajoute aussi un message système dédié à l'appel d'outils, de 286 jetons pour Claude Opus 5.5 d'après la documentation lue le 15/11/2026. Les outils exécutés côté serveur, comme la recherche web, ont un tarif à l'usage en plus. Le détail est sur la page coût d'un agent.

Conseils communs aux documentations

Peu d'outils : OpenAI suggère de viser moins de 20 fonctions disponibles au début d'un tour, en précisant que c'est une indication souple.
Des descriptions précises : Anthropic indique que le modèle décide d'appeler un outil d'après la demande et la description de l'outil.
Des paramètres manquants : d'après Anthropic, un modèle peut deviner une valeur absente au lieu de la demander ; validez donc les arguments dans votre code avant d'exécuter.