inference.eu

Guides · Tool calling

Appel d'outils : laissez les modèles ouverts appeler vos fonctions

L'appel d'outils, ou function calling, permet à un modèle de demander à votre code ce qu'il ne sait pas faire seul : consulter une commande, interroger une base de données, envoyer un e-mail ou appeler une autre API. Vous décrivez les outils, le modèle décide quand s'en servir et avec quels arguments, et votre code les exécute. C'est le socle de tout agent, aux formats OpenAI comme Anthropic.

Contacter l'équipeExemple de requête
  1. 01Format d'API: OpenAI et Anthropic
  2. 02Centres de données dans l'UE
  3. 03Couvert par un seul DPA
tools.py
import json, os
from openai import OpenAI

client = OpenAI(base_url="https://api.inference.eu/v1", api_key=os.environ["INFERENCE_EU_API_KEY"])

def get_order_status(order_id: str) -> dict:
    return {"order_id": order_id, "status": "shipped", "carrier": "DHL", "eta": "2026-11-05"}

tools = [{
    "type": "function",
    "function": {
        "name": "get_order_status",
        "description": "Look up the shipping status of a customer order by its id.",
        "parameters": {
            "type": "object",
            "properties": {"order_id": {"type": "string", "description": "Order id, e.g. A-10293"}},
            "required": ["order_id"],
        },
    },
}]

messages = [{"role": "user", "content": "Where is my order A-10293?"}]
reply = client.chat.completions.create(model="gpt-oss-120b", messages=messages, tools=tools)
msg = reply.choices[0].message

if msg.tool_calls:
    messages.append(msg)
    for call in msg.tool_calls:
        result = get_order_status(**json.loads(call.function.arguments))
        messages.append({"role": "tool", "tool_call_id": call.id, "content": json.dumps(result)})
    reply = client.chat.completions.create(model="gpt-oss-120b", messages=messages, tools=tools)

print(reply.choices[0].message.content)

Comment fonctionne l'appel d'outils

Vous joignez à la requête un tableau tools. Chaque outil a type: "function" et un objet function avec name, description et parameters en JSON Schema. Le modèle les lit en même temps que la conversation. S'il juge un outil nécessaire, il ne répond pas par du texte : il renvoie message.tool_calls, chacun avec un id, le nom de la fonction et des arguments sous forme de chaîne JSON, et finish_reason vaut tool_calls.

Le modèle n'exécute rien. Votre code analyse les arguments, appelle la vraie fonction et renvoie le résultat dans un message role: "tool" avec le tool_call_id correspondant. Le modèle s'en sert pour répondre, ou demande un autre outil.

Contrôler l'usage des outils

tool_choice encadre la décision. auto, par défaut, laisse le modèle choisir entre répondre et appeler un outil. required impose au moins un appel, utile pour les étapes d'extraction. none désactive les outils pour un tour, et désigner une fonction précise force celle-ci. Avec parallel_tool_calls: false, le modèle se limite à un appel par tour, si vos outils doivent s'enchaîner dans l'ordre.

La qualité des descriptions compte plus que tout. Dites ce que fait l'outil, quand l'utiliser et ce que signifie chaque paramètre, avec un exemple de valeur. Limitez le nombre d'outils par requête : un modèle qui choisit parmi quelques outils clairs se trompe moins que face à cinquante.

La boucle d'agent en pratique

Les vraies tâches demandent souvent plusieurs tours : chercher, récupérer les détails, puis agir. Mettez en place une boucle. Envoyez la requête ; si la réponse contient des appels d'outils, exécutez-les, ajoutez le message de l'assistant et chaque résultat, puis renvoyez. Arrêtez quand le modèle répond en texte ou après un nombre maximal de tours que vous fixez.

Validez les arguments avant d'agir, car le modèle peut fournir un mauvais identifiant ou oublier un champ. Soyez prudent avec les outils qui modifient quelque chose, comme les paiements ou les e-mails : demandez une confirmation humaine ou limitez-les à des valeurs sûres. Renvoyez les erreurs d'outil comme résultats explicites pour que le modèle puisse se corriger.

Formats, modèles et cas particuliers

Les mêmes outils fonctionnent avec l'API Responses, où appels de fonctions et sorties sont des éléments typés, et avec le format Messages d'Anthropic, où les outils utilisent input_schema et les appels reviennent sous forme de blocs tool_use auxquels vous répondez par tool_result. Choisissez le format de votre framework.

Tous les modèles ne se valent pas pour l'usage d'outils. Les grands modèles d'instruction comme gpt-oss-120b gèrent bien les boucles en plusieurs étapes ; les petits modèles peuvent oublier un appel ou inventer des arguments. Si arguments n'est pas un JSON valide, renvoyez une erreur et laissez le modèle réessayer, ou utilisez des schémas strict. Les définitions d'outils comptent en tokens d'entrée à chaque requête.

Tool calling : questions fréquentes

Les questions que nous posent le plus les achats, les développeurs et les juristes. Il en manque une ? Posez-la-nous directement.

Poser une question

Pages liées

Présentation de l'API

Faites passer vos charges IA sur une infrastructure européenne

Dites-nous quels modèles vous utilisez et votre volume approximatif. Nous répondons sous un jour ouvré avec un tarif et la suite.

  • Réponse sous un jour ouvré
  • Tarif adapté à votre volume
  • DPA prêt à signer