Utiliser l’outil de fonctions

  • 5 minutes

L’outil de fonction permet à votre modèle d’appeler des fonctions définies par le développeur pour récupérer des données ou déclencher des actions pendant une réponse.

Qu’est-ce que l’outil de fonction ?

L’outil de fonction (appel de fonction) permet à un modèle de décider quand appeler des outils nommés que vous exposez dans votre application. Le modèle n’exécute pas directement votre logique métier. Au lieu de cela, il retourne un appel de fonction structuré, votre code exécute la fonction, puis vous passez la sortie de la fonction au modèle.

Ce modèle est idéal pour connecter le raisonnement du modèle aux systèmes réels tels que les API, les bases de données, les flux de travail métier et les fonctions utilitaires.

Les principales fonctionnalités sont les suivantes :

  • Appels d’outils structurés - Le modèle émet des demandes explicites d’appel de fonction
  • Exécution contrôlée par les développeurs - Votre application décide de la façon et de l’emplacement d’exécution des fonctions
  • Modèle d’intégration fiable - Appeler des API, des services internes ou des utilitaires d’assistance en toute sécurité
  • Orchestration à plusieurs tour - Retourner la sortie de l’outil et laisser le modèle continuer le raisonnement
  • Réponses basées sur des données réelles - Les réponses peuvent inclure des données en temps réel, générées par le système.

Cas d’utilisation courants

Cas d’usage Exemple
Intégration du système Appeler une API interne pour obtenir des détails de compte ou de commande
Automatisation des tâches Déclencher des flux de travail tels que la création de tickets ou les notifications
Recherche de données Interroger des règles métier ou des tables de référence avant de répondre

Un exemple simple

Voici un exemple qui expose une get_time fonction et permet au modèle de l’appeler si nécessaire :

import time
from openai import OpenAI

# Function to get the current time
def get_time():
    return f"The time is {time.strftime('%Y-%m-%d %H:%M:%S', time.localtime())}"


# Main function
def main():
    client = OpenAI(
        base_url={openai_endpoint},
        api_key={auth_key_or_token}
    )

    function_tools = [
        {
            "type": "function",
            "name": "get_time",
            "description": "Get the current time"
        }
    ]

    # Initialize messages with a system prompt
    messages = [
        {"role": "developer", "content": "You are an AI assistant that provides information."},
    ]

    # Loop until the user types 'quit'
    while True:
        prompt = input("\nEnter a prompt (or type 'quit' to exit)\n")
        if prompt.lower() == "quit":
            break

        # Append the user prompt to the messages
        messages.append({"role": "user", "content": prompt})

        # Get initial response
        response = client.responses.create(
            model=model_deployment,
            input=messages,
            tools=function_tools
        )

        # Append model output to the messages
        messages += response.output

        # Was there a function call?
        for item in response.output:
            if item.type == "function_call" and item.name == "get_time":
                current_time = get_time()
                messages.append({
                    "type": "function_call_output",
                    "call_id": item.call_id,
                    "output": current_time
                })

                # Get a follow up response using the tool output
                response = client.responses.create(
                    model=model_deployment,
                    instructions="Answer only with the tool output.",
                    input=messages,
                    tools=function_tools
                )

        print(response.output_text)


# Run the main function when the script starts
if __name__ == '__main__':
    main()

Dans ce flux, le modèle décide quand appeler get_time, votre code exécute la fonction, puis retourne une réponse finale fondée. Étant donné que l’utilisateur peut saisir n’importe quelle invite, le modèle doit déterminer quand il doit appeler la fonction. Si c’est le cas, la réponse à l’invite inclut un appel de fonction, que le code de l’application doit implémenter avant d’envoyer une nouvelle invite avec la sortie de la fonction pour que le modèle soit traité.

La sortie peut ressembler à ceci :

Enter a prompt (or type 'quit' to exit)
Hello

Hello! How can I help you today?

Enter a prompt (or type 'quit' to exit)
What time is it?

The time is 2026-03-19 17:17:41.

Enter a prompt (or type 'quit' to exit)

La première invite d’utilisateur (« Hello ») n’a pas besoin de l’utilisation de l’outil de fonction, de sorte que le modèle a répondu normalement. La deuxième invite (« Quelle est l’heure ? ») a déclenché le modèle pour sélectionner la get_time fonction, qu’elle a indiquée dans sa réponse. Le code de l’application a ensuite exécuté la fonction et renvoyé les résultats au modèle, qui a ensuite envoyé une deuxième réponse avec les résultats de la fonction.

Conseil / Astuce

Cet exemple utilise une fonction unique sans paramètre. Vous pouvez configurer l’outil pour utiliser plusieurs fonctions, avec ou sans paramètres. Pour plus d’informations sur la spécification des détails de la fonction, consultez le guide des développeurs OpenAI.

Comment fonctionne l'outil de fonction

Le processus général d’utilisation de l’outil de fonction est le suivant :

  1. Vous définissez des outils : fournissez une ou plusieurs définitions de fonction dans le tableau d’outils.
  2. Le modèle évalue l’invite : il détermine si un appel de fonction est nécessaire.
  3. Le modèle émet un appel de fonction : la réponse inclut le nom de la fonction et les métadonnées d’appel.
  4. Votre application exécute la logique : exécutez la fonction correspondante dans votre code.
  5. Vous retournez la sortie de la fonction : envoyez un function_call_output élément avec le résultat.
  6. Le modèle termine la réponse : il incorpore les résultats de l’outil dans la réponse finale.

Bonnes pratiques

  • Garder les outils concentrés - Les petites fonctions à usage unique sont plus faciles à contrôler et à tester
  • Valider les entrées de fonction - Ne faites jamais confiance aux arguments des outils aveuglément dans les systèmes de production
  • Gérer les erreurs en toute sécurité - Retourner des sorties d'erreur claires que le modèle peut interpréter
  • Utilisation des outils de suivi : suivre les appels, la latence et les taux d’échec pour le débogage et la gouvernance
  • Limiter les opérations sensibles - Exiger une autorisation explicite pour les actions à impact élevé

Limitations à connaître

  • Le modèle demande des appels de fonction, mais votre application doit les exécuter
  • Des arguments d’outil incorrects ou inattendus peuvent se produire et doivent être validés
  • La latence des outils peut augmenter le temps de réponse de bout en bout
  • L'appel de fonction améliore la fiabilité, mais les résultats finaux doivent toujours être examinés avant de prendre des décisions critiques.

Utilisé correctement, l’outil de fonction transforme un modèle d’un générateur de texte en orchestrateur capable d’interagir avec des systèmes réels de manière contrôlée et auditable.