Appel de fonction

Utilisez l'appel de fonction pour laisser le modèle demander des données ou des actions à partir de votre application lors d'un workflow d'API Réponses. Cela est utile lorsque le modèle a besoin d'informations ou d'opérations qui ne sont pas disponibles dans l'invite elle-même, telles que les données de calendrier, l'état de l'application interne ou le résultat d'une opération personnalisée.

Avec ce modèle, le modèle n'exécute pas la fonction directement. Au lieu de cela, il renvoie le nom et les arguments de la fonction, l'application exécute la fonction, puis l'application renvoie la sortie de la fonction afin que le modèle puisse continuer et produire la réponse utilisateur.

Ce qui permet

L'appel de fonction est utile lorsque votre application doit garder le contrôle de l'exécution tout en permettant au modèle de décider du moment où des informations externes sont nécessaires.

Exemples de cas d'emploi :

Recherche d'événements de calendrier
Extraction des données d'application
Appel d'API interne ou externe
Exécuter une logique métier ou des calculs

Dans votre fonction, vous pouvez appeler un service externe, une base de données, l'une de vos propres API de bibliothèque, une interface de ligne de commande ou un serveur MCP local.

Cette approche vous offre de la flexibilité tout en conservant le chemin d'exécution dans l'application.

Flux d'exécution

Une interaction d'appel de fonction typique fonctionne comme suit :

Le client envoie une demande qui inclut une ou plusieurs définitions d'outil de fonction.
Le modèle décide si l'un de ces outils est nécessaire.
Si un outil est nécessaire, le modèle renvoie le nom de la fonction et les arguments.
L'application exécute la fonction et prépare le résultat.
L'application renvoie ce résultat dans une demande de suivi.
Le modèle utilise ce résultat pour terminer la réponse.

Options de traitement par état

Il existe deux façons courantes de gérer l'état de ces demandes :

Etat géré par le service

Recommandé pour la plupart des cas d'utilisation. La demande de suivi inclut previous_response_id et le service suit l'échange précédent.
Etat géré par le client

L'application conserve l'historique complet des interactions et envoie le contexte cumulé à chaque demande.

Conseil

Gardez les définitions d'outils précises. Des noms clairs, des descriptions bien écrites et des paramètres bien définis aident le modèle à sélectionner le bon outil et à générer des arguments utilisables.

Définir un outil de fonction

Pour définir un outil de fonction, ajoutez une entrée dans la propriété tools avec "type": "function".

L'exemple suivant définit un outil qui extrait les événements de calendrier pour une date donnée :

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

Incluez ce tableau tools dans la demande client.responses.create().

Exemple : état géré par le service

Dans ce modèle, la première demande permet au modèle de décider si l'outil est nécessaire. La seconde demande renvoie le résultat de l'outil et référence la réponse précédente.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

# Initial request
response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input="Show the calendar events for 2026-04-02.",
)

# Execute the requested function
tool_outputs = []
for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        tool_outputs.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

# Follow-up request
final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=tool_outputs,
    previous_response_id=response.id,
)

print(final.output_text)

Exemple : état géré par le client

Dans ce modèle, l'application conserve l'échange complet et le soumet à nouveau avec la demande de suivi.

import json

tools = [
    {
        "type": "function",
        "name": "get_calendar_events",
        "description": "Return calendar events scheduled for a specific date.",
        "parameters": {
            "type": "object",
            "properties": {
                "date": {
                    "type": "string",
                    "description": "Date to query, for example 2026-04-02"
                }
            },
            "required": ["date"],
        },
    },
]

def get_calendar_events(date):
    # Replace this with actual calendar logic or an API call
    return [
        {"time": "09:00", "title": "Team standup"},
        {"time": "13:00", "title": "Design review"},
        {"time": "16:00", "title": "Project check-in"},
    ]

conversation = [
    {"role": "user", "content": "Show the calendar events for 2026-04-02."}
]

response = client.responses.create(
    model="openai.gpt-oss-120b",
    tools=tools,
    input=conversation,
)

conversation += response.output

for item in response.output:
    if item.type == "function_call" and item.name == "get_calendar_events":
        args = json.loads(item.arguments)
        events = get_calendar_events(**args)
        conversation.append({
            "type": "function_call_output",
            "call_id": item.call_id,
            "output": json.dumps({"events": events}),
        })

final = client.responses.create(
    model="openai.gpt-oss-120b",
    instructions="Summarize the schedule clearly for the user.",
    tools=tools,
    input=conversation,
)

print(final.output_text)

L'appel de fonction est une option puissante lorsque l'application doit rester responsable de l'exécution, du contrôle d'accès et de la logique d'intégration, tout en permettant au modèle de demander les informations dont il a besoin.