Pāriet uz galveno saturu
Latviešu— Izvēlēties valodu
Izvēlne

Function Calling : connecte l'IA à tes systèmes

Nodarbība 10 no 22 Atjaunota 2026. gada 29. jūlijs Programmētājs
Šajā lapā
  1. Function Calling : connecte l’IA à tes systèmes
  2. Le flux complet, étape par étape
  3. Laisser le modèle choisir parmi plusieurs outils
  4. La boucle de l’agent
  5. Verrouiller les arguments avec le mode strict
  6. Galvenās atziņas

Function Calling : connecte l’IA à tes systèmes

Le function calling permet au modèle d’invoquer des fonctions que tu définis. Garde une règle essentielle en tête, car tout le reste en découle : le modèle ne les exécute pas. Il t’indique quelle fonction appeler et avec quels arguments ; c’est ton code qui effectue l’exécution et renvoie le résultat. Ta base de données, tes identifiants et ta logique métier ne quittent jamais ton infrastructure.

Le flux complet, étape par étape

L’échange se déroule en quatre phases :

  1. Tu déclares les fonctions disponibles ainsi que leurs paramètres
  2. Le modèle analyse la demande et décide d’appeler une fonction
  3. Ton code exécute la fonction et obtient le résultat
  4. Tu renvoies le résultat au modèle pour qu’il puisse formuler sa réponse

La déclaration mérite une attention particulière : la description de la fonction et la description de chaque paramètre sont les seules documentation dont dispose le modèle pour prendre sa décision. Des descriptions vagues entraînent des appels approximatifs. Note également comment boucler la boucle : le résultat est renvoyé avec le call_id que tu as reçu, ce qui sert d’accusé de réception et permet à l’API d’associer la réponse à la demande.

from openai import OpenAI
import json

client = OpenAI()

# Étape 1 : Déclarer les fonctions disponibles
tools = [{
    "type": "function",
    "name": "get_meteo",
    "description": "Get the current weather for a city",
    "parameters": {
        "type": "object",
        "properties": {
            "ville": {
                "type": "string",
                "description": "The name of the city"
            },
            "unite": {
                "type": "string",
                "enum": ["celsius", "fahrenheit"],
                "description": "Temperature unit"
            }
        },
        "required": ["ville"]
    }
}]

# Étape 2 : Le modèle décide d'appeler la fonction
response = client.responses.create(
    model="gpt-5.6-terra",
    input="What's the weather like in Marseille?",
    tools=tools
)

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

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

        # Étape 4 : Renvoyer le résultat au modèle
        final = client.responses.create(
            model="gpt-5.6-terra",
            input=[
                {"role": "user", "content": "What's the weather like in Marseille?"},
                {
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": json.dumps(resultat_meteo)
                }
            ],
            tools=tools
        )
        print(f"Response: {final.output_text}")

# Résultat :
# Function: get_meteo
# Arguments: {"ville": "Marseille"}
# Response: It is currently 22 C in Marseille with sunny weather.

Laisser le modèle choisir parmi plusieurs outils

La véritable valeur apparaît lorsque tu exposes un catalogue entier de capacités. Dans un assistant e-commerce, tu déclarerais la recherche de produits, la vérification du stock et la passation de commande, puis tu laisserais le modèle arbitrer. Face à « Le PC portable gaming XPS est-il disponible ? », il ne lancera pas une recherche mais interrogera directement le stock : ce sont tes descriptions de fonctions, et non une règle codée en dur, qui ont piloté ce choix.

tools = [
    {
        "type": "function",
        "name": "rechercher_produit",
        "description": "Search for a product in the catalog",
        "parameters": {
            "type": "object",
            "properties": {
                "requête": {"type": "string", "description": "Search terms"},
                "categorie": {"type": "string", "description": "Category (optional)"}
            },
            "required": ["requête"]
        }
    },
    {
        "type": "function",
        "name": "verifier_stock",
        "description": "Check product availability",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string", "description": "Product ID"}
            },
            "required": ["produit_id"]
        }
    },
    {
        "type": "function",
        "name": "passer_commande",
        "description": "Place an order for a product",
        "parameters": {
            "type": "object",
            "properties": {
                "produit_id": {"type": "string"},
                "quantite": {"type": "integer", "description": "Number of units"}
            },
            "required": ["produit_id", "quantite"]
        }
    }
]

# Le modèle choisit automatiquement la bonne fonction
response = client.responses.create(
    model="gpt-5.6-terra",
    input="Is the XPS gaming laptop available?",
    tools=tools
)

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

# Résultat : Function chosen: verifier_stock
# Arguments: {"produit_id": "xps-gaming"}

Une seule requête peut également déclencher plusieurs appels simultanément. Comparer la météo de deux villes produit deux appels indépendants : ton code doit donc itérer sur response.output et traiter tous les éléments function_call, jamais seulement le premier. C’est aussi l’occasion d’exécuter ces appels en parallèle et de diviser la latence par deux.

response = client.responses.create(
    model="gpt-5.6-terra",
    input="Compare the weather between Paris and Lyon.",
    tools=[{
        "type": "function",
        "name": "get_meteo",
        "description": "Get the weather for a city",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {"type": "string"}
            },
            "required": ["ville"]
        }
    }]
)

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

# Résultat :
# Number of calls: 2
#   - get_meteo(Paris)
#   - get_meteo(Lyon)

La boucle de l’agent

Un aller-retour unique suffit rarement : le résultat d’une fonction conduit souvent le modèle à en appeler une autre. Tu encapsules donc l’échange dans une boucle qui s’exécute tant que la réponse contient des appels de fonctions et s’arrête dès qu’il n’y en a plus, signe que le modèle a formulé sa réponse finale. C’est le squelette de tout agent, et tu le retrouveras sous diverses formes dans tous les frameworks d’agents.

def executer_fonction(nom: str, arguments: str) -> str:
    """Execute a function and return the result."""
    args = json.loads(arguments)

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

    return json.dumps({"error": "Unknown function"})

def agent_loop(question: str, tools: list) -> str:
    """Agent loop: call functions until the final response."""
    input_messages = [{"role": "user", "content": question}]

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

        # Vérifier les appels de fonctions
        function_calls = [i for i in response.output if i.type == "function_call"]

        if not function_calls:
            # Pas d'appels 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("What's the weather like in Paris?", tools)
print(reponse)

Un mot de prudence sur ce motif : la boucle while True n’a aucune garde-fou. En production, ajoute un compteur d’itérations maximal ; sinon, un modèle qui demanderait indéfiniment le même outil consumerait ton budget sans jamais conclure.

Verrouiller les arguments avec le mode strict

Le mode strict applique aux paramètres de fonction la même garantie que la sortie structurée applique aux réponses : les arguments adhèrent strictement au schéma déclaré. Pour une fonction qui crée un utilisateur, cela t’empêche de recevoir un âge sous forme de chaîne de caractères ou un champ supplémentaire que ton code n’attendait pas.

tools = [{
    "type": "function",
    "name": "creer_utilisateur",
    "description": "Create a new user",
    "strict": True,
    "parameters": {
        "type": "object",
        "properties": {
            "nom": {"type": "string"},
            "email": {"type": "string"},
            "age": {"type": "integer"}
        },
        "required": ["nom", "email", "age"],
        "additionalProperties": False
    }
}]

Galvenās atziņas

  • Le function calling connecte le modèle à tes systèmes sans exposer tes données
  • Le modèle décide quelle fonction appeler ; ton code l’exécute
  • Renvoie le résultat en utilisant function_call_output et le call_id
  • Le modèle peut appeler plusieurs fonctions en parallèle
  • Utilise une boucle d’agent pour les conversations multi-tours impliquant des fonctions
  • Active strict: True pour garantir la conformité des arguments