L'Atelier — Réseau francophone IA (produit, tech, business)

Function Calling avec l'API OpenAI

Le function calling (appel de fonctions) permet aux modèles GPT de générer des appels de fonctions structurés en JSON. Le modèle ne les exécute pas : il produit les arguments, et votre code se charge de l'exécution.

Fonctionnement

1. Vous décrivez les fonctions disponibles dans votre requête API 2. Le modèle décide s'il doit appeler une ou plusieurs fonctions 3. Il retourne un JSON structuré avec le nom et les arguments 4. Votre code exécute la fonction et renvoie le résultat 5. Le modèle formule sa réponse finale

Définir des fonctions

import OpenAI from "openai";

const client = new OpenAI();

const tools = [
  {
    type: "function",
    function: {
      name: "get_weather",
      description: "Obtient la météo actuelle pour une ville",
      parameters: {
        type: "object",
        properties: {
          location: {
            type: "string",
            description: "Ville et pays, ex: Paris, France"
          },
          unit: {
            type: "string",
            enum: ["celsius", "fahrenheit"]
          }
        },
        required: ["location"]
      }
    }
  }
];

Appel API avec function calling

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [
    { role: "user", content: "Quel temps fait-il à Lyon ?" }
  ],
  tools,
  tool_choice: "auto"
});

const toolCall = response.choices[0].message.tool_calls?.[0];
if (toolCall) {
  const args = JSON.parse(toolCall.function.arguments);
  const result = await getWeather(args.location, args.unit);

  // Renvoyer le résultat au modèle
  const finalResponse = await client.chat.completions.create({
    model: "gpt-4o",
    messages: [
      { role: "user", content: "Quel temps fait-il à Lyon ?" },
      response.choices[0].message,
      {
        role: "tool",
        tool_call_id: toolCall.id,
        content: JSON.stringify(result)
      }
    ]
  });
}

Structured Outputs avec function calling

Depuis 2024, OpenAI supporte les Structured Outputs qui garantissent que le JSON généré respecte exactement votre schéma :

const tools = [
  {
    type: "function",
    function: {
      name: "extract_info",
      description: "Extraire les informations d'un contact",
      strict: true,
      parameters: {
        type: "object",
        properties: {
          name: { type: "string" },
          email: { type: "string" },
          company: { type: "string" }
        },
        required: ["name", "email", "company"],
        additionalProperties: false
      }
    }
  }
];

Avec strict: true, le modèle respecte le schéma à 100% (pas de champs manquants, types corrects).

Appels parallèles

Le modèle peut appeler plusieurs fonctions en parallèle dans une seule réponse. Traitez tous les tool_calls et renvoyez chaque résultat.

Contrôler le comportement

tool_choice: "auto" : Le modèle décide (par défaut)
tool_choice: "none" : Pas d'appel de fonction
tool_choice: { type: "function", function: { name: "get_weather" } } : Forcer une fonction
tool_choice: "required" : Le modèle doit appeler au moins une fonction

Bonnes pratiques

Descriptions détaillées : Expliquez quand utiliser chaque fonction
Paramètres documentés : Ajoutez des descriptions et exemples
Validation côté serveur : Ne faites jamais confiance aveuglément au JSON généré
Gestion d'erreurs : Renvoyez des messages d'erreur clairs pour que le modèle puisse s'adapter
Limitez le nombre : 20 fonctions maximum pour de bons résultats

Function calling : structurer les sorties