OpenAI Function Calling : exemples pour bien démarrer

Name

Viktor Zinchenko

Updated on 14/11/2025

Dans le paysage en constante évolution de l’intelligence artificielle (IA), le function calling d’OpenAI (aujourd’hui exposé via les tools) est devenu l’un des blocs de base les plus importants pour les applications réelles. Il permet de connecter des modèles de langage puissants comme gpt-4.1 et gpt-4.1-mini à vos propres APIs, bases de données et logique métier.

Au lieu de demander au modèle de “générer du JSON” en espérant qu’il respecte votre format, vous décrivez des fonctions en JSON Schema, et le modèle renvoie un appel de fonction structuré que vous pouvez exécuter en toute sécurité dans votre code.

Dans ce guide, vous allez voir :

• Ce qu’est le function calling OpenAI et comment il fonctionne aujourd’hui
• Comment définir des tools/functions avec JSON Schema
• Des exemples pratiques : planifier des réunions, obtenir des cours de bourse, réserver des voyages
• Comment utiliser des fonctionnalités modernes comme les Structured Outputs pour rendre le function calling plus fiable
• Bonnes pratiques, pièges courants et FAQ

Qu’est-ce que l’OpenAI Function Calling (Tools) ?

Le function calling permet à un modèle de répondre avec des appels de fonction lisibles par machine au lieu de simple texte. Dans l’API moderne, ces appels sont représentés comme des tools :

• Vous définissez des tools avec :
  • type: "function"
  • function.name, function.description
  • function.parameters (un JSON Schema décrivant les arguments)
• Vous envoyez ces tools avec votre prompt.
• Le modèle décide s’il doit appeler un tool et renvoie un tool call avec un nom de fonction et des arguments JSON.
• Votre application :
  1. Analyse le tool call,
  2. Exécute la fonction correspondante dans votre backend,
  3. Renvoie éventuellement le résultat au modèle pour générer une réponse finale destinée à l’utilisateur.

Sous le capot, le function calling est pris en charge dans :

• La Responses API (POST /v1/responses) – la méthode recommandée pour les nouvelles applications.
• L’ancienne Chat Completions API (POST /v1/chat/completions) – toujours largement utilisée et supportée.

Historiquement, le function calling utilisait les paramètres functions et function_call. Ils sont désormais dépréciés au profit de tools et tool_choice, donc tout nouveau code devrait utiliser le nouveau style.

Exemple de base : planifier une réunion (Chat Completions API)

Commençons par un exemple simple avec la Chat Completions API. Nous allons demander au modèle de planifier une réunion et le laisser renvoyer des arguments structurés pour une fonction schedule_meeting.

Requête JSON (conceptuelle)

{
    "model": "gpt-4.1-mini",
    "messages": [
        {
            "role": "user",
            "content": "Schedule a meeting with John Doe next Tuesday at 3 PM."
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "schedule_meeting",
                "description": "Schedule a meeting in the calendar.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "attendee": {
                            "type": "string",
                            "description": "Name of the attendee for the meeting."
                        },
                        "date": {
                            "type": "string",
                            "description": "Date of the meeting in ISO 8601 format."
                        },
                        "time": {
                            "type": "string",
                            "description": "Time of the meeting, including time zone."
                        }
                    },
                    "required": ["attendee", "date", "time"],
                    "additionalProperties": false
                },
                "strict": true
            }
        }
    ],
    "tool_choice": "auto"
}

La réponse du modèle contiendra quelque chose comme :

{
    "role": "assistant",
    "tool_calls": [
        {
            "id": "call_123",
            "type": "function",
            "function": {
                "name": "schedule_meeting",
                "arguments": "{\"attendee\":\"John Doe\",\"date\":\"2025-11-18\",\"time\":\"15:00 Europe/Berlin\"}"
            }
        }
    ]
}

Votre backend peut analyser arguments, appeler votre vraie fonction schedule_meeting (par exemple via Google Calendar ou Outlook), puis éventuellement renvoyer le résultat au modèle pour un message de confirmation convivial.

Exemple : recherche de cours de bourse

Voici un exemple plus proche d’une “API” : appel d’une fonction get_stock_price à partir du langage naturel.

Requête avec un tool get_stock_price

{
    "model": "gpt-4.1-mini",
    "messages": [
        {
            "role": "user",
            "content": "What's the current price of Apple stock?"
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "get_stock_price",
                "description": "Get the current stock price for a ticker symbol.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "ticker_symbol": {
                            "type": "string",
                            "description": "Ticker symbol of the stock, e.g. AAPL."
                        },
                        "currency": {
                            "type": "string",
                            "enum": ["USD", "EUR", "GBP"],
                            "description": "Currency for the price."
                        }
                    },
                    "required": ["ticker_symbol"],
                    "additionalProperties": false
                },
                "strict": true
            }
        }
    ],
    "tool_choice": "auto"
}

Lorsque l’utilisateur demande “What’s the current price of Apple stock?”, le modèle va produire un appel de tool du type :

{
    "type": "function",
    "function": {
        "name": "get_stock_price",
        "arguments": "{\"ticker_symbol\":\"AAPL\",\"currency\":\"USD\"}"
    }
}

Vous devez ensuite :

1. Appeler votre véritable API de prix boursiers.
2. Renvoyer le résultat au modèle dans une requête de suivi.
3. Laisser le modèle générer une explication compréhensible pour l’utilisateur.

Exemple : réservation de voyage avec Function Calling

Le function calling est particulièrement utile lorsque les prompts sont flous et humains, mais que votre backend a besoin de paramètres clairs et structurés.

Considérez l’énoncé suivant :

“I need to book a trip from Bonn to Amsterdam for my wife, mother, my two sons, my daughter, and me. The airline must fly direct.”

Nous voulons que le modèle en extraie :

• departure
• destination
• number_people
• travel_mode (par ex. plane / train)

Définition du tool book_travel

{
    "model": "gpt-4.1-mini",
    "messages": [
        {
            "role": "user",
            "content": "I need to book a trip from Bonn to Amsterdam for my wife, mother, my two sons and daughter, and me. The airline must fly direct."
        }
    ],
    "tools": [
        {
            "type": "function",
            "function": {
                "name": "book_travel",
                "description": "Search or book transportation for a group of travelers.",
                "parameters": {
                    "type": "object",
                    "properties": {
                        "departure": {
                            "type": "string",
                            "description": "City or airport you are traveling from."
                        },
                        "destination": {
                            "type": "string",
                            "description": "City or airport you are traveling to."
                        },
                        "number_people": {
                            "type": "integer",
                            "description": "How many people are traveling."
                        },
                        "travel_mode": {
                            "type": "string",
                            "enum": ["plane", "train", "bus", "car"],
                            "description": "Preferred mode of travel."
                        },
                        "non_stop_only": {
                            "type": "boolean",
                            "description": "Whether only non-stop options are allowed."
                        }
                    },
                    "required": ["departure", "destination", "number_people"],
                    "additionalProperties": false
                },
                "strict": true
            }
        }
    ],
    "tool_choice": "auto"
}

Le modèle pourrait renvoyer :

{
    "name": "book_travel",
    "arguments": "{\"departure\":\"Bonn\",\"destination\":\"Amsterdam\",\"number_people\":6,\"travel_mode\":\"plane\",\"non_stop_only\":true}"
}

À partir de là, vous pouvez brancher ces paramètres directement dans votre service de recherche de vols.

Utiliser les SDK OpenAI modernes (Python & JavaScript)

En pratique, vous n’enverrez pas du JSON brut “à la main”. Vous utiliserez plutôt les SDK officiels et travaillerez avec des réponses typées.

Exemple Python (Chat Completions + tools)

from openai import OpenAI
 
client = OpenAI()
 
tools = [
    {
        "type": "function",
        "function": {
            "name": "schedule_meeting",
            "description": "Schedule a meeting in the calendar.",
            "parameters": {
                "type": "object",
                "properties": {
                    "attendee": {"type": "string"},
                    "date": {"type": "string"},
                    "time": {"type": "string"},
                },
                "required": ["attendee", "date", "time"],
                "additionalProperties": False,
            },
            "strict": True,
        },
    }
]
 
completion = client.chat.completions.create(
    model="gpt-4.1-mini",
    messages=[
        {
            "role": "user",
            "content": "Schedule a meeting with John Doe next Tuesday at 3 PM.",
        }
    ],
    tools=tools,
    tool_choice="auto",
)
 
tool_calls = completion.choices[0].message.tool_calls
if tool_calls:
    call = tool_calls[0]
    args = client.responses._client._utils.json.loads(call.function.arguments)
    # Your real implementation:
    # result = schedule_meeting(**args)

Exemple JavaScript (Node.js)

import OpenAI from "openai";
 
const client = new OpenAI();
 
const tools = [
    {
        type: "function",
        function: {
            name: "get_stock_price",
            description: "Get the current price for a given ticker symbol.",
            parameters: {
                type: "object",
                properties: {
                    ticker_symbol: {
                        type: "string",
                        description: "Stock ticker symbol, e.g. AAPL",
                    },
                },
                required: ["ticker_symbol"],
                additionalProperties: false,
            },
            strict: true,
        },
    },
];
 
const response = await client.chat.completions.create({
    model: "gpt-4.1-mini",
    messages: [
        { role: "user", content: "What's the current price of Apple stock?" },
    ],
    tools,
    tool_choice: "auto",
});
 
const toolCalls = response.choices[0].message.tool_calls;

Structured Outputs : un function calling plus fiable

Le JSON Mode garantit que le modèle renvoie du JSON valide, mais pas forcément du JSON qui respecte votre schéma. Structured Outputs est une fonctionnalité plus récente qui renforce cela en appliquant votre JSON Schema lorsque le modèle appelle des tools :

• Définissez "strict": true dans la définition function de votre tool.
• Les arguments du modèle sont alors garantis conformes à votre schéma (types, champs obligatoires, pas de propriétés supplémentaires), ce qui réduit drastiquement les erreurs de parsing et de validation.

C’est particulièrement utile pour :

• Extraire des données complexes et imbriquées à partir de texte libre
• Construire des workflows multi‑étapes où chaque étape dépend de données structurées précises
• Générer des paramètres pour des systèmes en aval comme SQL, des pipelines analytiques ou des visualisations de données

Même avec Structured Outputs, vous devez continuer à considérer les valeurs comme des entrées non sûres (par exemple vérifier les plages, gérer les IDs manquants, valider les règles métier).

Design patterns & bonnes pratiques

1. Garder les tools petits et ciblés

Au lieu d’une énorme fonction do_everything, définissez des tools petits et composables :

• get_user_profile
• get_user_orders
• create_support_ticket
• schedule_meeting

Cela rend les schémas plus simples à maintenir et améliore la capacité du modèle à choisir le bon tool.

2. Utiliser des noms et descriptions clairs

• Les noms de fonctions devraient être des verbes : create_invoice, fetch_weather, book_travel.
• Les descriptions devraient expliquer quand utiliser la fonction, pas seulement ce qu’elle fait.

Mauvais :

“Get data from the system.”

Bon :

“Use this function whenever the user asks about their recent orders or order history.”

3. Être strict sur les schémas

• Utilisez des champs required et additionalProperties: false.
• Utilisez des enums pour les options connues ("enum": ["plane", "train"]).
• Ajoutez de petites contraintes quand c’est utile (formats de chaîne, entiers minimum, etc.).

4. Tout valider et journaliser

• Validez toujours les arguments des tools côté serveur avant exécution.
• Journalisez les tool calls et les prompts en langage naturel pour le debugging.
• Envisagez des retries (éventuellement avec un court message système correctif) lorsque la validation échoue.

5. Chaîner les tools si nécessaire

Pour des workflows plus complexes (par ex. récupérer un utilisateur → récupérer ses commandes → les résumer), vous pouvez :

1. Laisser le modèle appeler plusieurs tools dans une même réponse (tool calls parallèles), ou
2. Orchestrer les étapes depuis votre backend, en réinjectant les résultats précédents dans le modèle.

Exemple concret multi‑étapes : calcul avec formats mixtes

Reprenons un exemple classique qui montre que le function calling est plus qu’un gadget.

“What’s the result of 22 plus 5 in decimal added to the hexadecimal number A?”

On peut résoudre cela en définissant deux tools :

• add_decimal(a: number, b: number)
• add_hex(a: string, b: string)

Workflow :

1. Le modèle appelle add_decimal avec les arguments { "a": 22, "b": 5 } → votre code renvoie 27.
2. Vous renvoyez le résultat et la question d’origine au modèle.
3. Le modèle appelle ensuite add_hex avec { "a": "27", "b": "A" }.
4. Votre code renvoie 31, et le modèle explique le résultat final à l’utilisateur.

Ce pattern se généralise à n’importe quel domaine : finance, analytics, data viz, DevOps, tableaux de bord BI, etc. Function calling + vos propres tools = un assistant IA flexible et conscient de votre domaine.

Vous voulez générer n’importe quel type de graphique facilement avec la puissance de ChatGPT ? Essayez VizGPT (opens in a new tab) — décrivez vos données et votre graphique en langage naturel et obtenez de superbes visualisations sans code.

(opens in a new tab)

(opens in a new tab)

Mises à jour OpenAI associées (vue d’ensemble)

OpenAI a continué d’améliorer l’expérience de function calling et de tools avec :

• Des context windows plus grands sur les modèles modernes, ce qui facilite la gestion de longues conversations, documents ou schémas.
• Les Structured Outputs pour les tools et formats de réponses, garantissant que la sortie du modèle respecte votre JSON Schema.
• Une Responses API et un écosystème de tools plus riches (web search, file search, exécution de code, etc.), ce qui facilite la création de workflows agentiques complets avec les mêmes concepts de function calling.

Pour les tarifs et la liste la plus récente des modèles, consultez toujours la documentation officielle et la page de pricing d’OpenAI.

Conclusion

Le function calling est l’un des moyens les plus puissants de transformer les LLMs en composants pratiques et fiables de votre stack :

• Vous décrivez ce que vos fonctions peuvent faire, en JSON Schema.
• Le modèle décide quand et comment les appeler.
• Votre backend exécute les appels et, avec le modèle, construit des expériences riches pour vos utilisateurs.

Que vous planifiiez des réunions, interrogiez des cours de bourse, réserviez des voyages ou alimentiez un tableau de bord BI complet avec des outils comme PyGWalker et VizGPT, le function calling est la colle entre le langage naturel et les actions réelles.

Commencez simplement avec une seule fonction, validez tout, puis évoluez vers des workflows agentiques multi‑étapes au fur et à mesure que votre application mûrit.

Foire aux questions

1. Qu’est-ce que la fonctionnalité de function calling d’OpenAI ?

   Le function calling vous permet de décrire des fonctions (tools) avec JSON Schema afin que le modèle renvoie un appel de fonction structuré plutôt que du texte libre. Le modèle n’exécute rien lui‑même ; votre application analyse le tool call et exécute la vraie fonction.

2. Quels modèles prennent en charge le function calling ?

   Les modèles modernes GPT‑4, GPT‑4.1, GPT‑4o, GPT‑4o-mini et les modèles plus récents de la série GPT‑5/o prennent en charge les tools/function calling via les APIs Chat Completions et Responses. Consultez la documentation OpenAI pour la liste la plus à jour des modèles pris en charge.

3. Dois‑je utiliser les anciens paramètres functions / function_call ?

   Non. Il s’agissait de la première génération de paramètres de function calling et ils sont désormais considérés comme legacy. Le nouveau code doit utiliser tools et tool_choice, qui sont plus flexibles et fonctionnent avec les modèles et APIs récents.

4. En quoi cela diffère‑t‑il du JSON Mode ou des Structured Outputs ?

   • JSON Mode (response_format: { "type": "json_object" }) garantit que le modèle renvoie du JSON valide, mais n’applique pas votre schéma.
   • Function calling avec Structured Outputs (strict: true dans la définition du tool) garantit que les arguments correspondent au JSON Schema que vous avez fourni.
   • Vous pouvez combiner function calling et JSON Mode pour un contrôle encore plus fin.

5. Quels sont les cas d’usage courants ?

   • Chatbots qui appellent des APIs externes (météo, CRM, ticketing, outils internes)
   • Langage naturel → appels d’API, requêtes SQL, filtres de recherche
   • Pipelines d’extraction de données transformant du texte non structuré en enregistrements structurés
   • Workflows “agents” multi‑étapes pour l’automatisation, l’analytics et la BI