Blog
Exploiter l’appel de fonctions pour créer des applications LLM plus intelligentes

Exploiter l’appel de fonctions pour créer des applications LLM plus intelligentes

Sep 17, 202413 min read

Les grands modèles de langage (LLMs) ne se limitent plus à la génération de texte ; ils gèrent désormais des tâches plus complexes, guidées par le contexte. Une avancée clé dans ce domaine est l’appel de fonctions, qui permet aux LLMs d’interagir avec des outils externes, des bases de données et des APIs afin d’effectuer des opérations dynamiques. Cela leur permet d’aller au-delà de la génération de texte et de travailler avec des données et des services du monde réel.

Lors d’un récent Berlin Unstructured Data Meetup organisé par Zilliz, Nikolai Danylchyk, ingénieur client chez Google, a expliqué comment Gemini, un LLM moderne, utilise l’appel de fonctions pour étendre ses capacités. Ce blog récapitulera ses enseignements et montrera comment exploiter cette puissante fonctionnalité pour créer des applications LLM avancées. Si vous souhaitez en savoir plus, nous vous recommandons de regarder la rediffusion de la présentation de Nikolai sur YouTube.

Comprendre l’appel de fonctions avancé dans les LLMs

Les LLMs ont considérablement évolué, mais leur véritable potentiel se révèle lorsqu’ils interagissent avec des systèmes externes au moyen d’appels de fonctions. Cette capacité permet aux LLMs de dépasser les limites de leurs données d’entraînement statiques en interrogeant des bases de données en direct, en exécutant des commandes ou en effectuant des calculs en temps réel. En intégrant l’appel de fonctions, les LLMs peuvent se connecter de manière fluide à d’autres systèmes afin de fournir des réponses plus précises, actuelles et dynamiques. Décomposons le fonctionnement de l’appel de fonctions en prenant Gemini comme exemple.

Figure 1- Étapes de l’appel de fonctions et composants utilisés à l’exécution

Figure 1 : Étapes de l’appel de fonctions et composants utilisés à l’exécution.

Le processus commence lorsqu’un utilisateur soumet une requête à l’API Gemini. À ce stade, le développeur a déjà défini une ou plusieurs déclarations de fonctions dans l’outil, indiquant à Gemini les fonctions disponibles et la manière de les exécuter. Une fois l’entrée utilisateur reçue, l’API Gemini analyse le contenu et le prompt, puis renvoie une réponse de type « Function Call ». Cette réponse inclut des données structurées, telles que le nom de la fonction à appeler et les paramètres pertinents.
L’étape suivante se déroule en dehors du système Gemini : l’application utilise le nom de la fonction et les paramètres provenant de la réponse de Gemini pour effectuer une requête API vers un service externe. C’est là que le développeur intervient, en utilisant des outils comme la bibliothèque requests en Python pour appeler une API REST ou toute autre bibliothèque cliente adaptée à ses besoins.
Après que le système externe a renvoyé sa réponse, l’application renvoie ces données à Gemini. Le modèle utilise ensuite ces nouvelles informations pour générer une réponse finale pour l’utilisateur. Si des données supplémentaires sont nécessaires, Gemini peut émettre un autre appel de fonction, en poursuivant le cycle autant que nécessaire.

Pour comprendre l’importance de cette capacité avancée, considérons un LLM traditionnel sans fonctionnalité d’appel de fonctions. Ses réponses sont générées à partir des données sur lesquelles il a été entraîné, lesquelles peuvent être obsolètes ou limitées en portée. Cependant, avec les appels de fonctions, un LLM peut émettre des commandes pour extraire des informations en temps réel depuis une base de données, mettre à jour un enregistrement dans un système de gestion de la relation client (CRM), ou même déclencher des actions comme réserver un billet ou passer une commande. Cette approche étend l’utilité du modèle, qui ne se contente plus de générer des réponses, mais exécute aussi des tâches.

En termes techniques, un appel de fonction dans un LLM implique une interaction structurée entre le modèle et une API ou un service externe. Le modèle identifie un scénario approprié dans lequel un appel de fonction est nécessaire, formule les paramètres de l’appel et l’exécute.

Par exemple, si un utilisateur demande : « Quel temps fait-il à Berlin ?” L’appel de fonction déclencherait une API météo, récupérant des données en temps réel pour générer la réponse. Dans ce cas, le LLM agit comme un intermédiaire intelligent entre l’utilisateur et le système externe, orchestrant une interaction plus précise et plus utile.

Maintenant que nous avons exploré le concept de base de l’appel de fonction, examinons une implémentation pratique utilisant Gemini pour interagir avec une API réelle — la récupération des taux de change.

Exemple : Utiliser l’appel de fonction pour récupérer les taux de change

Voyons comment nous pouvons utiliser une API de taux de change via l’appel de fonction Gemini :

Installation des bibliothèques nécessaires et définition des variables du projet

Commençons par mettre à niveau et installer la bibliothèque google-cloud-aiplatform, qui est nécessaire pour interagir avec la plateforme Vertex AI de Google Cloud. Ensuite, fournissez votre ID de projet et votre emplacement sous forme de variables.

!pip3 install --upgrade --user --quiet google-cloud-aiplatform

PROJECT_ID = "[your-project-id]"  # @param {type:"string"}
LOCATION = "us-central1"  # @param {type:"string"}

Ce sont des espaces réservés permettant d’identifier le projet et la région dans Google Cloud avec lesquels vous travaillez.

Importation des modules nécessaires et définition du modèle génératif

Ensuite, importez les modules requis pour définir et utiliser un modèle génératif depuis Vertex AI. La bibliothèque requests sera utilisée plus tard pour récupérer des données à partir d’une API externe.

import requests
from vertexai.generative_models import (
    Content,
    FunctionDeclaration,
    GenerativeModel,
    Part,
    Tool,
)

model = GenerativeModel("gemini-1.5-pro-001")

La dernière ligne initialise un modèle génératif, dans ce cas, gemini-1.5-pro-001. Vous utiliserez plus tard le modèle pour générer des réponses en fonction du prompt d’entrée.

Définition d’une fonction pour les taux de change et création d’un outil

Ensuite, créez une fonction qui décrit les paramètres nécessaires pour obtenir un taux de change entre deux devises et encapsulez-la dans un outil.

get_exchange_rate_func = FunctionDeclaration(
    name="get_exchange_rate",
    description="Get the exchange rate for currencies between countries",
    parameters={
    "type": "object",
    "properties": {
        "currency_date": {
            "type": "string",
            "description": "A date that must always be in YYYY-MM-DD format or the value 'latest' if a time period is not specified"
        },
        "currency_from": {
            "type": "string",
            "description": "The currency to convert from in ISO 4217 format"
        },
        "currency_to": {
            "type": "string",
            "description": "The currency to convert to in ISO 4217 format"
        }
    },
         "required": [
            "currency_from",
            "currency_date",
      ]
  },
)

exchange_rate_tool = Tool(
    function_declarations=[get_exchange_rate_func],
)

Les paramètres incluent currency_date (au format YYYY-MM-DD ou le mot-clé latest), currency_from (le code ISO 4217 de la devise à convertir) et currency_to (le code ISO 4217 de la devise vers laquelle convertir). La section required précise que currency_from et currency_date sont obligatoires. Nous définissons ensuite un outil nommé exchange_rate_tool, qui encapsule la déclaration de fonction get_exchange_rate. Nous transmettrons plus tard cet outil au modèle pour gérer la récupération des taux de change.

Génération d’une réponse avec le modèle et extraction des paramètres de la réponse

Invoquons maintenant une réponse en transmettant un prompt au modèle. Nous nous attendons à ce que le modèle produise une réponse contenant un appel de fonction avec des paramètres.

prompt = """What is the exchange rate from Australian dollars to Swedish krona?
How much is 500 Australian dollars worth in Swedish krona?"""

response = model.generate_content(
    prompt,
    tools=[exchange_rate_tool],
)

response.candidates[0].content

params = {}
for key, value in response.candidates[0].content.parts[0].function_call.args.items():
    params[key[9:]] = value
params

Le code ci-dessus définit un prompt demandant le taux de change entre les dollars australiens et les couronnes suédoises. Le modèle est ensuite appelé à l’aide de generate_content, en transmettant le prompt avec exchange_rate_tool. Le modèle tentera de générer une réponse.

La réponse est ensuite analysée. Le dictionnaire params est rempli en parcourant les clés et les valeurs de function_call.args et en supprimant les 9 premiers caractères de la clé afin de correspondre aux noms de paramètres attendus.

Récupérer des taux de change depuis une API et donner une réponse à l’utilisateur

Demandons maintenant l’API Frankfurter (une API gratuite de taux de change) en utilisant les paramètres extraits de la réponse précédente et générons une réponse à l’utilisateur.

import requests
url = f"https://api.frankfurter.app/{params['date']}"
api_response = requests.get(url, params=params)
api_response.text

response = model.generate_content(
    [
    Content(role="user", parts=[
        Part.from_text(prompt + """Give your answer in steps with lots of detail
            and context, including the exchange rate and date."""),
    ]),
    Content(role="function", parts=[
        Part.from_dict({
            "function_call": {
                "name": "get_exchange_rate",
            }
        })
    ]),
    Content(role="function", parts=[
        Part.from_function_response(
            name="get_exchange_rate",
            response={
                "content": api_response.text,
            }
        )
    ]),
    ],
    tools=[exchange_rate_tool],
)

response.candidates[0].content.parts[0].text

Dans le code ci-dessus, une fois que nous obtenons une réponse de l’API de taux de change, nous appelons à nouveau la méthode generate_content, cette fois en transmettant plusieurs contenus : un provenant de l’utilisateur (demandant des étapes détaillées et du contexte), un appel de fonction à get_exchange_rate, et la réponse de l’API Frankfurter. Cette combinaison incite le modèle à fournir une réponse plus approfondie, étape par étape. Enfin, nous affichons la partie texte du contenu généré par le modèle. C’est la réponse que nous renvoyons à l’utilisateur.

Voici un exemple de réponse :

Figure 2- Sortie d’un programme montrant le taux de change des dollars australiens vers les couronnes suédoises

Figure 2 : Sortie d’un programme montrant le taux de change des dollars australiens vers les couronnes suédoises

La réponse montre que l’appel de fonction a fonctionné et nous a donné le taux de change actuel tel qu’indiqué par l’API Frankfurter.

Jusqu’à présent, nous avons couvert l’appel de fonction, la fonctionnalité avancée de Gemini et de nombreux autres LLM. Bien que l’appel de fonction seul puisse effectuer des tâches complexes comme la récupération de devises, son véritable potentiel se révèle lorsqu’il est combiné à d’autres techniques puissantes, telles que la Retrieval Augmented Generation (RAG).

Combiner l’appel de fonction avec la Retrieval-Augmented Generation (RAG) pour une interactivité améliorée

La génération augmentée par récupération (RAG) est devenue l’une des tendances les plus importantes du traitement du langage naturel (NLP). Les systèmes RAG combinent les capacités génératives des LLM avec l’efficacité des systèmes de récupération alimentés par des bases de données vectorielles telles que Milvus et Zilliz Cloud (le Milvus géré). Plus précisément, dans un système RAG, la base de données vectorielle récupère des informations contextuelles pour le LLM, puis le LLM génère une réponse plus précise à partir des informations récupérées. L’appel de fonctions améliore ce processus en permettant une interaction plus dynamique entre le LLM et les bases de données ou systèmes externes. Avec l’ajout d’appels de fonctions, les LLM peuvent étendre leurs capacités non seulement en récupérant des données pertinentes, mais aussi en les traitant et en interagissant avec elles en temps réel.

Par exemple, dans une application de support client utilisant à la fois RAG et l’appel de fonctions, le LLM offre une interaction plus riche et plus personnalisée. Lorsqu’un utilisateur demande : « Où est ma commande récente ?” Le système utilise d’abord RAG pour récupérer des informations générales sur le traitement des commandes depuis la base de données vectorielle Milvus, en fournissant du contexte. Par exemple, l’information récupérée est « les commandes prennent généralement 3 à 5 jours ouvrables pour être livrées.” Simultanément, grâce à l’appel de fonctions, il accède aux données en temps réel en interrogeant le compte du client. La réponse finale devient : « Votre commande #12345 a été expédiée le 10 septembre et devrait arriver le 15 septembre.”

Cette intégration de RAG avec l’appel de fonctions crée un système dynamique qui non seulement génère des réponses pertinentes et informatives, mais interagit aussi activement avec des données et des services en direct, apportant une dimension interactive. Cette combinaison rend les agents intelligents alimentés par des LLM capables de réaliser des interactions complexes dans le monde réel.

Consultez ce tutoriel pour un guide étape par étape sur la manière d’exploiter les capacités d’appel de fonctions des LLM afin d’améliorer les systèmes RAG.

Cas d’utilisation de la combinaison de RAG et de l’appel de fonctions

Examinons plusieurs de ces interactions du monde réel.

Santé : récupération des dossiers médicaux et planification des rendez-vous

Dans le domaine de la santé, RAG combiné à l’appel de fonctions permet aux LLM de fournir une assistance hautement personnalisée et fondée sur les données, tant pour les patients que pour les prestataires de soins. Un médecin pourrait demander au système les données historiques d’un patient, tandis que le système récupère les dossiers médicaux pertinents à l’aide de RAG depuis une base de données vectorielle comme Milvus. En même temps, grâce à l’appel de fonctions, le LLM peut interagir avec des systèmes hospitaliers externes pour planifier des rendez-vous de suivi ou récupérer des données diagnostiques en temps réel.

Exemple : Un médecin demande : « Quel est le dernier résultat de test pour le patient X, et pouvez-vous réserver un rendez-vous de suivi la semaine prochaine ?” Le système interroge d’abord Milvus pour récupérer des documents connexes dans l’historique du patient, fournissant des informations sur les tendances et les affections. Ensuite, il utilise l’appel de fonctions pour accéder à l’API de planification de l’hôpital afin de réserver un rendez-vous pour le patient.

Finance : perspectives d’investissement personnalisées et transactions en temps réel

Dans le secteur financier, RAG est utilisé pour récupérer des informations de marché pertinentes et des données financières historiques stockées dans des bases de données vectorielles comme Milvus. En l’associant à l’appel de fonctions, un LLM peut également effectuer des actions en temps réel, comme acheter ou vendre des actions, transférer des fonds, ou générer des recommandations de portefeuille personnalisées basées sur des données en direct.

Exemple : Un utilisateur demande : « Comment mon portefeuille a-t-il performé au cours des six derniers mois, et peux-tu acheter pour 1000 $ d’actions Apple ? » Le système utilise d’abord le RAG pour récupérer l’historique du portefeuille de l’utilisateur depuis Milvus, fournissant un résumé des performances passées. Ensuite, à l’aide de l’appel de fonctions, il interagit avec une API de trading pour exécuter l’achat d’actions et confirmer la transaction à l’utilisateur.

E-commerce : recommandations de produits et suivi des commandes en temps réel

Dans l’e-commerce, le RAG peut aider à récupérer des informations sur les produits, des avis ou l’historique client depuis Milvus afin de personnaliser l’expérience d’achat. Lorsqu’il est combiné à l’appel de fonctions, le système peut interagir avec des systèmes d’inventaire en direct pour fournir la disponibilité des stocks, suivre les commandes en temps réel, ou même traiter les paiements.

Exemple : Un client demande : Peux-tu me recommander un ordinateur portable similaire à mon dernier achat, et me dire quand ma commande actuelle arrivera ? Le LLM récupère des informations sur les achats précédents du client depuis Milvus et recommande un produit similaire. L’appel de fonctions est ensuite utilisé pour interroger l’API de suivi des commandes afin de fournir des mises à jour en temps réel sur le statut de livraison de la commande actuelle.

Voyage : suggestions d’itinéraires et gestion des réservations

Dans le voyage et l’hôtellerie, le RAG peut récupérer des détails sur les destinations, les hôtels et les itinéraires de voyage stockés dans une base de données vectorielle comme Milvus. Associé à l’appel de fonctions, le système peut gérer les réservations, suggérer des itinéraires personnalisés ou offrir des mises à jour en temps réel sur les vols et les réservations.

Exemple : Un voyageur demande : Peux-tu suggérer un itinéraire de 5 jours en Italie, et reprogrammer ma réservation d’hôtel à une date plus proche ? Le système récupère d’abord des suggestions d’itinéraires depuis Milvus en fonction des préférences du voyageur et de ses voyages passés. Ensuite, il utilise l’appel de fonctions pour interagir avec le système de réservation de l’hôtel afin de modifier la réservation et de confirmer le changement à l’utilisateur.

À mesure que nous voyons comment l’appel de fonctions améliore des systèmes comme le RAG, il est important de reconnaître les défis pratiques et les avantages liés au déploiement de telles technologies dans des applications réelles.

Défis et avantages de l’appel de fonctions dans des cas d’utilisation réels

Bien que le potentiel de l’appel de fonctions soit immense, il s’accompagne de son propre ensemble de défis. L’une des principales préoccupations consiste à garantir la sécurité et la confidentialité des interactions. Lorsqu’un LLM émet des appels de fonctions, il peut nécessiter l’accès à des données sensibles, telles que des comptes utilisateur ou des informations financières. Il est crucial de garantir que ces transactions soient sécurisées et conformes aux réglementations sur la confidentialité des données.

De plus, la complexité liée à la gestion de plusieurs appels de fonctions dans un seul flux de travail peut entraîner des problèmes de latence. Par exemple, si un LLM émet plusieurs appels de fonctions vers différents systèmes, le temps de réponse peut augmenter, ce qui peut affecter l’expérience utilisateur. Cela est particulièrement important dans les applications en temps réel où la rapidité est essentielle.

Du côté positif, l’appel de fonctions offre plusieurs avantages, notamment une automatisation accrue des tâches, des réponses en temps réel plus précises et une meilleure interaction utilisateur. Dans des secteurs tels que la santé, la finance et le service client, l’appel de fonctions peut rationaliser les opérations en automatisant les tâches routinières. Par exemple, dans le domaine de la santé, un LLM pourrait extraire les dossiers des patients, planifier des rendez-vous et envoyer des rappels via des appels de fonctions, libérant ainsi du temps pour que les professionnels de santé puissent se concentrer sur des cas plus complexes.

Au-delà des avantages et des défis pratiques, il existe des considérations éthiques et techniques qui ne doivent pas être négligées, en particulier en ce qui concerne la sécurité des données et la fiabilité des systèmes.

Considérations éthiques et techniques

D’un point de vue technique, nous, en tant que développeurs, devons gérer avec soin la manière dont les appels de fonctions sont implémentés afin d’éviter les écueils potentiels. Un problème courant est la dépendance excessive aux systèmes externes. Si un LLM émet constamment des appels de fonctions vers des services tiers, la fiabilité du système devient dépendante de la disponibilité et des performances de ces services. Une gestion appropriée des erreurs et des mécanismes de repli doivent être en place pour garantir que le système continue de fonctionner correctement, même lorsque les services externes sont indisponibles.

Sur le plan éthique, les appels de fonctions soulèvent des préoccupations concernant la transparence et le consentement de l’utilisateur. Si un LLM prend des décisions ou effectue des actions au nom d’un utilisateur, il est essentiel que l’utilisateur soit pleinement informé de ce que fait le système. Par exemple, dans les services financiers, si un LLM exécute des transactions ou transfère des fonds, les utilisateurs doivent être informés des actions entreprises et doivent avoir la possibilité d’intervenir si nécessaire. Une documentation claire et des mécanismes de consentement de l’utilisateur sont essentiels pour maintenir la confiance dans de tels systèmes.

Une autre préoccupation éthique concerne l’utilisation des données. Lorsque les appels de fonctions accèdent à des données personnelles ou sensibles, des mesures strictes doivent être mises en place pour protéger la confidentialité des utilisateurs. Les développeurs doivent veiller à ce que les données soient traitées de manière responsable et à ce que les appels de fonctions soient conformes aux réglementations relatives à la confidentialité, telles que le GDPR ou l’HIPAA.

Conclusion

Nikolai a fait un travail fantastique en mettant en lumière la manière dont les appels de fonctions apportent une amélioration essentielle aux grands modèles de langage, leur permettant d’effectuer des tâches concrètes en interagissant avec des systèmes et des données externes. Qu’il s’agisse de récupérer des taux de change ou d’alimenter des interactions plus complexes grâce à la génération augmentée par récupération (RAG), les appels de fonctions élargissent les horizons de ce que les LLM peuvent accomplir.

Lectures complémentaires

Mis à jour le Jul 13, 2026

Simon Mwaniki

Continuer à lire

Balancing Precision and Performance: How Zilliz Cloud's New Parameters Help You Optimize Vector Search

Optimize vector search with Zilliz Cloud’s level and recall features to tune accuracy, balance performance, and power AI applications.

Bringing AI to Legal Tech: The Role of Vector Databases in Enhancing LLM Guardrails

Discover how vector databases enhance AI reliability in legal tech, ensuring accurate, compliant, and trustworthy AI-powered legal solutions.

OpenAI o1: What Developers Need to Know

In this article, we will talk about the o1 series from a developer's perspective, exploring how these models can be implemented for sophisticated use cases.