Architecture d'appel de fonctions dans l'API Responses
Šiame puslapyje
Mis à jour le 2 novembre 2026 sur la base de la documentation OpenAI : l’outil Code Interpreter nécessite désormais un paramètre
container(ajouté à tous les exemples), les parties de texte d’entrée utilisent le typeinput_text, et la recherche web utilise l’outilweb_search(web_search_previewest désormais un outil hérité sans filtres de domaine). Les fichiers générés sont récupérés à l’aide des fonctionsfichiers_generesettelechargerde la leçon 10. Sources : Code Interpreter · Recherche web.
Architecture d’appel de fonctions dans l’API Responses
L’appel de fonctions est le mécanisme central qui permet aux modèles OpenAI d’interagir avec le monde extérieur. Dans l’API Responses, ce mécanisme a été repensé pour être plus robuste, plus prévisible et nativement intégré aux outils intégrés tels que la recherche web et l’interpréteur de code.
Le principe fondamental
Le modèle n’exécute jamais rien directement. Il émet des intentions structurées que ton code intercepte et exécute. Dit ainsi, cela peut sembler une limitation technique ; en réalité, c’est le choix de conception qui rend tout le reste possible.
Imagine l’alternative. Si le modèle exécutait lui-même les actions, tu devrais lui confier tes identifiants de base de données, tes clés API et tes permissions d’écriture, sans aucun point de vérification possible. Grâce au découplage, chaque intention passe par ton code : tu valides les arguments, tu appliques les règles métier et tu refuses si nécessaire. Le modèle propose, ton code dispose, et c’est cette frontière qui te permet de mettre l’appel de fonctions en production sans perdre le contrôle.
from openai import OpenAI
client = OpenAI()
# Déclarer un outil personnalisé
tools = [{
"type": "function",
"name": "rechercher_client",
"description": "Search for a client in the CRM by name or email",
"parameters": {
"type": "object",
"properties": {
"terme": {
"type": "string",
"description": "Client name, email, or ID"
},
"champ": {
"type": "string",
"enum": ["nom", "email", "id"],
"description": "Field to search in"
}
},
"required": ["terme"]
}
}]
response = client.responses.create(
model="gpt-5.6-terra",
input="Find the client Jean Dupont",
tools=tools
)
Anatomie d’une réponse
Une réponse ne contient pas soit du texte soit des appels d’outils : output est une liste hétérogène qui peut mélanger les deux. L’habitude à prendre dès ta première ligne de code est d’itérer sur cette liste plutôt que de lire output[0] — un modèle qui explique son raisonnement avant d’appeler une fonction produit exactement ce cas de figure, et un code qui lit le premier élément échouera le jour où il commencera à ajouter des commentaires.
for item in response.output:
if item.type == "function_call":
print(f"Call ID : {item.call_id}")
print(f"Function : {item.name}")
print(f"Args : {item.arguments}")
Le call_id est essentiel : il lie l’appel à son résultat lorsque tu renvoies la réponse au modèle. Sur un seul appel, tu le remarques à peine ; sur trois appels parallèles, c’est la seule chose qui t’empêche d’attribuer la météo de Lyon à une demande concernant Marseille. Renvoie toujours le résultat avec le call_id que tu as reçu, jamais avec un ID que tu reconstruis de ton côté.
La boucle complète
Ce cycle en quatre étapes est invariant : il s’applique à une fonction comme à vingt, à un appel simple comme à un agent enchaînant dix outils. Toute la complexité que tu rencontreras plus tard — parallélisme, erreurs, replis — consiste à instrumenter cette boucle, jamais à la remplacer.
import json
# 1. Premier appel avec les outils déclarés
response = client.responses.create(
model="gpt-5.6-terra",
input="What is the balance for client [email protected]?",
tools=tools
)
# 2. Détecter et exécuter les appels de fonctions
resultats = []
for item in response.output:
if item.type == "function_call":
if item.name == "rechercher_client":
args = json.loads(item.arguments)
resultat = votre_crm.rechercher(args["terme"])
resultats.append({
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(resultat)
})
# 3. Renvoyer les résultats au modèle
response_finale = client.responses.create(
model="gpt-5.6-terra",
input=response.output + resultats,
tools=tools
)
# 4. Le modèle formule sa réponse naturelle
print(response_finale.output_text)
Différences clés avec Chat Completions
L’API Responses apporte plusieurs améliorations architecturales.
Gestion native des outils intégrés
Les outils intégrés sont déclarés exactement comme tes fonctions, mais ils s’exécutent du côté d’OpenAI. La conséquence pratique est agréable : tu n’écris aucune boucle pour eux. Le modèle appelle, obtient le résultat et continue, le tout en un seul aller-retour. La boucle décrite ci-dessus ne concerne que tes fonctions — celles qui s’exécutent sur ta machine.
# Mélanger outils intégrés et personnalisés
tools = [
{"type": "web_search"},
{"type": "code_interpreter", "container": {"type": "auto"}},
{
"type": "function",
"name": "ma_fonction",
"description": "My custom function",
"parameters": {"type": "object", "properties": {}}
}
]
Identifiants d’appel stables
Chaque appel de fonction reçoit un call_id unique qui te permet de tracer précisément quel résultat correspond à quel appel, même avec des appels parallèles.
Flux simplifié
Pas besoin de gérer manuellement les rôles assistant et tool dans les messages. Le champ input accepte directement la concaténation des sorties précédentes avec les résultats des fonctions.
Quand le modèle appelle-t-il une fonction ?
Le modèle décide d’appeler une fonction lorsque la demande de l’utilisateur nécessite des informations qu’il ne possède pas, lorsque la description de la fonction correspond au besoin identifié et lorsque les paramètres requis peuvent être déduits du contexte.
Trois conditions doivent donc être remplies simultanément, ce qui est utile pour le débogage : lorsqu’une fonction n’est pas appelée alors qu’elle devrait l’être, la cause est presque toujours la deuxième — une description qui ne couvre pas la façon dont l’utilisateur a formulé sa demande. Le paramètre tool_choice te permet de forcer le comportement lorsque la description ne suffit pas :
# Laisser le modèle décider
tool_choice = "auto"
# Forcer un appel à une fonction spécifique
tool_choice = {"type": "function", "name": "rechercher_client"}
# Interdire tout appel de fonction
tool_choice = "none"
# Exiger au moins un appel sans préciser lequel
tool_choice = "required"
Svarbiausi punktai
- L’appel de fonctions est un protocole d’intention, pas un protocole d’exécution
- La boucle appel-exécution-retour est le motif fondamental
- Les outils intégrés et personnalisés coexistent dans le même tableau
tools - Le
call_idassure la traçabilité de chaque appel tool_choicete permet de contrôler finement le comportement du modèle