Appel de fonction

Utilisez l'appel de fonction pour laisser les données ou les actions de demande de modèle de votre application lors d'un flux de travail d'API de 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 directement la fonction. Au lieu de cela, il retourne le nom et les arguments de la fonction, votre 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 orientée utilisateur.

Ce que cela 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 quand des informations externes sont nécessaires.

Exemples de cas d'utilisation :

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

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 fonction typique appelant l'interaction fonctionne las :

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 et les arguments de la fonction.
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 d'état

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

État géré par le service

Recommandé pour la plupart des cas d'utilisation. La demande de suivi inclut previous_response_id et le service effectue le suivi de l'échange précédent.
État 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 l'outil approprié 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 des événements de calendrier pour une date spécifié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 deuxième demande renvoie le résultat de l'outil et fait 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 excellente option 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.