ChatGPT · Function calling et structured outputs
La façon la plus rapide de transformertransformerUn Transformer est une architecture de réseau de neurones qui utilise le self-attention pour traiter des séquences en parallèle. Elle est au cœur de la plupart des modèles de langage et d'IA générative actuels.Voir la définition complète → un chatbot en système consiste à donner au modèle un ensemble de fonctions qu'il peut appeler et à exiger que ses réponses reviennent sous forme de JSON strict, fiable pour votre code. Cette leçon couvre en détail ces deux mécanismes dans l'APIAPIApplication Programming Interface : une interface standardisée qui permet aux applications de communiquer et d'échanger des données sans connaître leur fonctionnement interne respectif.Voir la définition complète → OpenAI.
- Le tool calling est la boucle dans laquelle le modèle demande à votre code d'exécuter quelque chose.
- Les Structured Outputs garantissent que la réponse du modèle respecte votre schémamaUtiliser un logiciel pour automatiser les tâches et campagnes marketing répétitives, afin de personnaliser à grande échelle sur des canaux comme l'email, le web et le social.Voir la définition complète →.
Ils résolvent des problèmes différents et fonctionnent bien ensemble.
Nous utiliserons la Responses API, l'interface principale d'OpenAI. Chat Completions fonctionne toujours et repose sur des concepts quasi identiques, mais les nouvelles fonctionnalités arrivent d'abord dans Responses. Les exemples utilisent gpt-5. Remplacez-le par le modèle actuel qui correspond à votre budget de coût et de latence : la mécanique est la même dans toute la famille.
Deux mécanismes, deux rôles
Gardez-les bien distincts :
- Function (tool) calling : le modèle décide qu'il a besoin de données externes ou d'une action, et émet une requête structurée pour appeler l'une de *vos* fonctions. Votre code l'exécute, renvoie le résultat, et le modèle poursuit. C'est ainsi que le modèle sort de son contexte : bases de données, votre API, une calculatrice, la météo.
- Structured Outputs : vous forcez la *réponse finale* du modèle à respecter exactement un JSON SchemaSchemaUn schema est le plan formel qui définit comment les données sont structurées, nommées, typées et reliées entre elles au sein d'une base de données, d'un fichier ou d'un message.Voir la définition complète →. Pas de prose, pas de balises markdown, pas de « Bien sûr, voici votre JSON. » Uniquement des données valides et parsables, à chaque fois.
Vous utilisez souvent les deux : les tools pour collecter les faits, les Structured Outputs pour mettre en forme le résultat.
Définir un tool
Un tool est la description JSON d'une fonction : un nom, une description et un schéma de paramètres. La description n'est pas décorative. **Le modèle la lit pour décider *quand* et *comment* appeler la fonction** : rédigez-la comme une documentation destinée à un développeur junior.
from openai import OpenAI
client = OpenAI()
tools = [{
"type": "function",
"name": "get_weather",
"description": "Get the current temperature for a city in Celsius.",
"parameters": {
"type": "object",
"properties": {
"city": {"type": "string", "description": "City name, e.g. 'Lisbon'"}
},
"required": ["city"],
"additionalProperties": False
},
"strict": True
}]Trois détails rendent les appels prévisibles :
requiredliste les arguments que le modèle doit fournir.additionalProperties: Falseempêche le modèle d'inventer des champs supplémentaires.strict: Truefait correspondre exactement les arguments au schéma.
La boucle de tool calling
Voici le point sur lequel beaucoup se trompent : le modèle n'exécute pas votre fonction. Il renvoie une *requête* pour l'appeler. Vous exécutez la fonction, renvoyez le résultat et rappelez le modèle. Cet aller-retour, c'est la boucle, et c'est vous qui la gérez.
Le déroulé :
- Envoyez le message de l'utilisateur avec vos définitions de tools.
- Le modèle répond avec un ou plusieurs éléments
function_call(ou une réponse normale si aucun tool n'est nécessaire). - Votre code exécute chaque appel et ajoute un
function_call_outputcontenant le résultat. - Vous rappelez le modèle avec l'input mis à jour. Il rédige alors la réponse finale.
import json
def get_weather(city):
# Supposons que ceci appelle une vraie API.
return {"city": city, "temp_c": 19}
input_list = [{"role": "user", "content": "What's the weather in Lisbon?"}]
response = client.responses.create(
model="gpt-5",
tools=tools,
input=input_list,
)
# Reporter l'output du modèle (y compris les éventuels éléments de raisonnement).
input_list += response.output
for item in response.output:
if item.type == "function_call":
args = json.loads(item.arguments)
result = get_weather(**args)
input_list.append({
"type": "function_call_output",
"call_id": item.call_id,
"output": json.dumps(result),
})
final = client.responses.create(
model="gpt-5",
tools=tools,
input=input_list,
)
print(final.output_text)Notez call_id. Le modèle peut demander plusieurs appels de tools en un seul tour (parallel tool calling), et chaque output doit être rattaché à son appel par son identifiant. Ajoutez tous les résultats avant d'envoyer la requête suivante.
Avec les modèles de raisonnement, renvoyer response.output en entier est important. Cela transmet les éléments de raisonnement du modèle au tour suivant, pour qu'il ne perde pas le fil entre deux appels de tools. Si vous gérez plutôt l'état côté serveur, passez previous_response_id.
Règles pratiques pour la boucle
- Bouclez, ne supposez pas un seul tour. Après avoir renvoyé les outputs des tools, le modèle peut appeler un autre tool. Encapsulez l'étape requête/exécution dans une boucle
whilequi continue tant que des élémentsfunction_callreviennent. Plafonnez-la (par exemple à 8 itérations) pour qu'un modèle désorienté ne tourne pas indéfiniment. - Validez les arguments avant d'exécuter. Le schéma contraint le modèle, mais traitez les arguments des tools comme n'importe quel input non fiable. Ne les passez jamais directement dans un shell, une chaîne SQLSQLSales Qualified Lead : un prospect que l'équipe commerciale a validé comme prêt pour une prise de contact directe et une proposition, après avoir passé des critères de qualification explicites.Voir la définition complète → ou un chemin de fichier.
- Gardez des fonctions ciblées.
get_order_status(order_id)vaut mieux qu'une méga-fonction avec un paramètremode. Des tools ciblés sont plus faciles à choisir correctement pour le modèle et plus faciles à sécuriser pour vous. - Contrôlez le choix si nécessaire.
tool_choice="auto"est la valeur par défaut."required"impose l'appel d'*un* tool.- Nommer un tool précis impose exactement celui-là.
- L'option
allowed_toolsrestreint le modèle à un sous-ensemble de vos tools pour ce tour sans réécrire la liste complète, ce qui préserve aussi l'efficacité du prompt caching. - Réglez
parallel_tool_calls=Falsesi vos tools doivent s'exécuter dans un ordre séquentiel.
Une option plus récente est le custom tool ("type": "custom"). Il accepte du texte libre au lieu d'arguments JSON, ce qui convient à des inputs comme du SQL ou des extraits de code. Vous pouvez éventuellement le contraindre par une grammaire. Utilisez par défaut les function tools JSON et ne recourez aux custom tools que lorsque l'échappement JSON devient gênant.
Structured Outputs : arrarrL'Annual Recurring Revenue (ARR) est le revenu normalisé et prévisible qu'une entreprise par abonnement attend de ses contrats actifs sur une année.Voir la définition complète →êtez de parser de la prose
Le tool calling gère les *actions*. Les Structured Outputs gèrent la *forme de la réponse*. Lorsque vous réglez strict: true et fournissez un schéma, l'API contraint la génération pour que l'output respecte votre schéma. C'est plus robuste que l'ancienne astuce du prompt « réponds en JSON », qui produisait du JSON valide la plupart du temps et cassait à 2 heures du matin.
En Python, le plus propre est de définir votre schéma sous forme de modèle Pydantic et de laisser le SDK le parser pour vous.
from pydantic import BaseModel
class CalendarEvent(BaseModel):
name: str
date: str
participants: list[str]
response = client.responses.parse(
model="gpt-5",
input=[
{"role": "system", "content": "Extract the event details."},
{"role": "user", "content": "Standup with Ana and Rui on Friday."},
],
text_format=CalendarEvent,
)
event = response.output_parsed
print(event.participants) # ['Ana', 'Rui']output_parsed vous renvoie un objet typé, pas une chaîne qu'il faut passer à json.loads en croisant les doigts. Si vous n'êtes pas en Python, passez un JSON Schema brut dans text.format avec "type": "json_schema" et "strict": true. Vous récupérez un texte JSON dont la conformité est garantie.
Une conception de schéma qui fonctionne vraiment
- Toutes les propriétés sont de fait obligatoires. Le mode strict traite toutes les clés comme requises. Pour rendre un champ « optionnel », donnez-lui une union avec null (par exemple
Optional[str]en Pydantic), puis testez la valeur null dans votre code. - Utilisez des enums pour contraindre les choix. Si
statusne peut valoir queopen,pendingouclosed, définissez-le comme enum. Le modèle ne pourra pas renvoyerin-progresset vous surprendre en aval. - Les descriptions de champs dans le schéma orientent *ce qui* va dans chaque champ, pas seulement les types. Servez-vous-en.
- Tenez compte du sous-ensemble supporté. Les Structured Outputs prennent en charge une partie définie de JSON Schema, et certains mots-clés et valeurs de
formatne sont pas appliqués. Consultez le guide Structured Outputs avant de vous appuyer sur l'un d'eux.
Combiner les deux : le schéma réaliste
La plupart des fonctionnalités en production utilisent les deux ensemble. Imaginez un assistant support qui répond à une question de remboursement :
- Le modèle appelle
lookup_order(order_id)(tool calling) pour récupérer des données réelles. - Vous renvoyez la fiche de la commande.
- Le modèle produit une réponse finale contrainte par un schéma
RefundDecision(Structured Outputs). Le schéma comporte un booléeneligible, un enumreasonet une chaînecustomer_message.
Le code de votre application ne parse jamais de texte libre. Il lit decision.eligible et bifurque. C'est tout l'intérêt. Le modèle gère le langage et le jugement, votre code gère le flux de contrôle, et un contrat typé fait l'interface entre les deux.
Les *paramètres* des tools et les Structured *Outputs* sont deux emplacements de schéma distincts. L'un façonne l'appel entrant, l'autre la réponse sortante. Vous pouvez utiliser l'un ou l'autre seul, ou les deux à la fois dans la même requête.
Vérification des acquis
1. Quelle est la différence fondamentale entre le function (tool) calling et les Structured Outputs ?
2. Dans la boucle de tool calling, que se passe-t-il réellement quand le modèle « appelle » une fonction ?
3. Pourquoi la leçon insiste-t-elle pour rédiger la « description » d'un tool comme une documentation destinée à un développeur junior ?
4. Sélectionnez TOUTES les affirmations correctes concernant les champs du schéma de paramètres des tools abordés dans la leçon.
Sélectionnez toutes les réponses correctes.
5. Sélectionnez TOUS les scénarios qui correspondent aux usages décrits dans la leçon.
Sélectionnez toutes les réponses correctes.
Erreurs, coûts et modes de défaillance
Les systèmes réels cassent de manières bien précises. Anticipez-les.
- Tools hallucinés ou arguments erronés. Avec des schémas de tools stricts, c'est rare. Si une fonction échoue réellement, renvoyez une erreur *en tant qu'output du tool* (par exemple
{"error": "order not found"}) plutôt que de lever une exception. Le modèle peut la lire et se rattraper, par exemple en demandant à l'utilisateur un identifiant de commande correct. - Refus. Les Structured Outputs peuvent malgré tout refuser pour des raisons de sécurité. Le SDK le signale : vérifiez l'absence de refus avant de vous fier à
output_parsed. Traitez ce cas explicitement au lieu de le considérer comme des données mal formées. - Troncature. Si le modèle atteint la limite de tokenstokensUn token est l'unité de base de texte que traitent les modèles de langage : le plus souvent un fragment de mot, un mot entier ou un signe de ponctuation, plutôt qu'un simple caractère.Voir la définition complète → d'output au milieu du JSON, vous obtenez des données incomplètes, même en mode strict. La contrainte garantit une *structure valide*, pas la *complétude*. Vérifiez si le statut de la réponse est
incompleteet augmentezmax_output_tokenspour les objets volumineux. Les modèles de raisonnement consomment une partie de ce budget en tokens de raisonnement : gardez de la marge. - Latence à la première utilisation d'un nouveau schéma. La première requête avec un schéma strict inédit peut être plus lente, le temps que l'API prépare la contrainte. Les schémas réutilisés sont rapides : réutilisez vos schémas plutôt que de les générer dynamiquement à chaque requête.
- Tokens. Les définitions de tools et les schémas résident dans la fenêtre de contexte et comptent comme tokens d'input à chaque appel. Des schémas longs et verbeux répartis sur de nombreux tools finissent par peser. Gardez des descriptions concises et n'attachez que les tools dont le modèle pourrait raisonnablement avoir besoin pour cette requête.
Place dans l'écosystème
Vous avez maintenant vu la mécanique brute. Les produits OpenAI de plus haut niveau reposent exactement sur ces primitives :
- Les built-in tools sont des appels de tools que l'API exécute côté serveur. Par exemple la recherche web, la recherche de fichiers et le code interpreter. Vous les activez dans
toolssans écrire l'exécuteur. - Les serveurs MCP distants sont un type de tool dans la Responses API. Vous pointez
toolsvers un serveur Model Context ProtocolModel Context ProtocolUn standard ouvert qui permet aux assistants IA de se connecter aux outils et données de l'entreprise de façon cohérente et gouvernée, sans intégration sur mesure à chaque fois.Voir la définition complète → (par exemple un connecteur Stripe ou GitHub, ou le vôtre), et l'API découvre et appelle ses tools pour vous. MCP est désormais le moyen courant d'exposer un même ensemble de tools à de nombreux clients IA. - Les GPT Actions des Custom GPTs sont du function calling piloté par une spécification OpenAPI. C'est ChatGPT qui gère le schéma requête/exécution, et non votre code. Pour des intégrations plus riches dans ChatGPT, l'Apps SDK s'appuie sur MCP.
- L'Agents SDK encapsule la boucle de tools, les relances et les handoffs, ce qui vous évite d'écrire la boucle
whileà la main. Quand l'orchestration se complexifie (plusieurs agents, guardrails, tracing), passez-y plutôt que de maintenir du code de boucle sur mesure. Voir la documentation de l'Agents SDK.
Une fois la boucle de base comprise, rien de tout cela ne paraît magique. Ce sont des surcouches pratiques au-dessus du contrat que vous venez d'apprendre.
Points clés
- Le tool calling est une boucle que vous gérez. Le modèle *demande* une fonction. Votre code l'exécute, renvoie l'output associé au
call_idet rappelle le modèle. Renvoyez l'output complet (éléments de raisonnement compris), bouclez jusqu'à ce qu'il ne reste plus d'appels de tools et fixez un plafond strict d'itérations. - Utilisez les Structured Outputs avec
strict: truepour toute réponse que votre code parse. Ils garantissent la forme et suppriment le JSON fragile obtenu en croisant les doigts. En Python, définissez un modèle Pydantic et lisezoutput_parsed. - Concevez vos schémas de manière défensive. Traitez tous les champs comme obligatoires (unions avec null pour les champs optionnels), contraignez les choix avec des enums et vérifiez que vos mots-clés font partie du sous-ensemble supporté.
- Renvoyez les erreurs des tools sous forme de données, et vérifiez les refus et le statut
incompleteavant de vous fier au payload. - Quand la boucle grossit, tournez-vous vers MCP, l'Agents SDK ou les GPT Actions. Ils reposent sur ces mêmes primitives : le modèle mental se transpose directement.
À faire, tiré de cette leçon
Ces actions sont compilées dans le plan d'action du rôle.
- Démarrez tout nouveau code sur l'API Responses et lisez response.usage dès le premier jour