Function calling : connecter l'IA à vos systèmes — Responses API — Fondamentaux OpenAI

Function calling : connecter l’IA à vos systèmes

Le function calling permet au modèle d’appeler des fonctions que vous avez définies. Le modèle ne les exécute pas lui-même : il indique quelle fonction appeler avec quels arguments. Votre code exécute la fonction et renvoie le résultat.

Le flux complet

Vous déclarez des fonctions disponibles avec leurs paramètres
Le modèle analyse la requête et décide d’appeler une fonction
Votre code exécute la fonction et obtient le résultat
Vous renvoyez le résultat au modèle pour qu’il formule sa réponse

from openai import OpenAI
import json

client = OpenAI()

# Etape 1 : Déclarer les fonctions disponibles
tools = [{
    "type": "function",
    "name": "get_meteo",
    "description": "Obtenir la météo actuelle d'une ville",
    "parameters": {
        "type": "object",
        "properties": {
            "ville": {
                "type": "string",
                "description": "Le nom de la ville"
            },
            "unite": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Unité de température"
            }
        },
        "required": ["ville"]
    }
}]

# Etape 2 : Le modèle décide d'appeler la fonction
response = client.responses.create(
    model="gpt-5.3",
    input="Quel temps fait-il à Marseille ?",
    tools=tools
)

# Etape 3 : Exécuter la fonction
for item in response.output:
    if item.type == "function_call":
        print(f"Fonction : {item.name}")
        print(f"Arguments : {item.arguments}")
        args = json.loads(item.arguments)

        # Votre implémentation réelle
        resultat_meteo = {"temperature": 22, "condition": "ensoleillé"}

        # Etape 4 : Renvoyer le résultat au modèle
        final = client.responses.create(
            model="gpt-5.3",
            input=[
                {"role": "user", "content": "Quel temps fait-il à Marseille ?"},
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": json.dumps(resultat_meteo)
                }
            ],
            tools=tools
        )
        print(f"Réponse : {final.output_text}")

# Résultat :
# Fonction : get_meteo
# Arguments : {"ville": "Marseille"}
# Réponse : Il fait actuellement 22 C a Marseille avec un temps ensoleillé.

Fonctions multiples

Vous pouvez déclarer plusieurs fonctions et le modèle choisira la bonne :

tools = [
    {
        "type": "function",
        "name": "rechercher_produit",
        "description": "Rechercher un produit dans le catalogue",
        "parameters": {
            "type": "object",
            "properties": {
                "requete": {"type": "string", "description": "Termes de recherche"},
                "categorie": {"type": "string", "description": "Catégorie (optionnel)"}
            },
            "required": ["requete"]
        }
    },
    {
        "type": "function",
        "name": "verifier_stock",
        "description": "Vérifier la disponibilité d'un produit",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string", "description": "ID du produit"}
            },
            "required": ["produit_id"]
        }
    },
    {
        "type": "function",
        "name": "passer_commande",
        "description": "Passer une commande pour un produit",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string"},
                "quantite": {"type": "integer", "description": "Nombre d'unités"}
            },
            "required": ["produit_id", "quantite"]
        }
    }
]

# Le modèle choisit automatiquement la bonne fonction
response = client.responses.create(
    model="gpt-5.3",
    input="Est-ce que le laptop gaming XPS est disponible ?",
    tools=tools
)

for item in response.output:
    if item.type == "function_call":
        print(f"Fonction choisie : {item.name}")
        print(f"Arguments : {item.arguments}")

# Résultat : Fonction choisie : verifier_stock
# Arguments : {"produit_id": "xps-gaming"}

Appels parallèles

Le modèle peut appeler plusieurs fonctions en une seule requête :

response = client.responses.create(
    model="gpt-5.3",
    input="Comparez la météo entre Paris et Lyon.",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Obtenir la météo d'une ville",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"]
        }
    }]
)

# Le modèle fait deux appels en parallèle
function_calls = [item for item in response.output if item.type == "function_call"]
print(f"Nombre d'appels : {len(function_calls)}")
for call in function_calls:
    args = json.loads(call.arguments)
    print(f"  - get_meteo({args['ville']})")

# Résultat :
# Nombre d'appels : 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

Boucle d’agent complet

Voici le pattern complet pour un agent qui boucle jusqu’à obtenir une réponse finale :

def executer_fonction(nom: str, arguments: str) -> str:
    """Exécute une fonction et retourne le résultat."""
    args = json.loads(arguments)

    if nom == "get_meteo":
        # Simulation — remplacez par votre vraie API
        return json.dumps({"temp": 18, "condition": "nuageux"})
    elif nom == "get_heure":
        return json.dumps({"heure": "14:30", "timezone": "CET"})

    return json.dumps({"error": "Fonction inconnue"})

def agent_loop(question: str, tools: list) -> str:
    """Boucle d'agent : appelle des fonctions jusqu'a la réponse finale."""
    input_messages = [{"role": "user", "content": question}]

    while True:
        response = client.responses.create(
            model="gpt-5.3",
            input=input_messages,
            tools=tools
        )

        # Vérifier s'il y a des appels de fonction
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Pas d'appel de fonction = réponse finale
            return response.output_text

        # Exécuter chaque fonction et ajouter les résultats
        for call in function_calls:
            resultat = executer_fonction(call.name, call.arguments)
            input_messages.append({
                "type": "function_call_output",
                "call_id": call.call_id,
                "output": resultat
            })

# Utilisation
reponse = agent_loop("Quel temps fait-il a Paris ?", tools)
print(reponse)

Strict mode pour les paramètres

Activez le mode strict pour garantir que les arguments respectent le schéma :

tools = [{
    "type": "function",
    "name": "creer_utilisateur",
    "description": "Créer un nouvel utilisateur",
    "strict": True,
    "parameters": {
        "type": "object",
        "properties": {
            "nom": {"type": "string"},
            "email": {"type": "string"},
            "age": {"type": "integer"}
        },
        "required": ["nom", "email", "age"],
        "additionalProperties": False
    }
}]

Points clés à retenir

Le function calling connecte le modèle à vos systèmes sans exposer vos données
Le modèle décide quelle fonction appeler, votre code l’exécute
Renvoyez le résultat avec function_call_output et le call_id
Le modèle peut appeler plusieurs fonctions en parallèle
Utilisez une boucle d’agent pour les conversations multi-tours avec fonctions
Activez strict: True pour garantir la conformité des arguments