Les grands modèles de langage (LLM) n'ont pas accès aux données en temps réel ni aux systèmes externes. Le Function Calling permet à ces modèles d'appeler des outils externes tels que des API, des bases de données ou des fonctions définies par l'utilisateur. Ainsi, un modèle peut récupérer des informations ou exécuter des actions qui dépassent ses capacités natives.
Fonctionnement
Le Function Calling repose sur une interaction en plusieurs étapes entre votre application et le LLM :
- Effectuez le premier appel au modèle L'application transmet la question de l'utilisateur ainsi qu'une liste des outils disponibles au LLM.
-
Recevez les instructions d'appel d'outil du modèle
Si le modèle décide d'utiliser un outil externe, il renvoie une instruction JSON spécifiant le nom de la fonction et les paramètres d'entrée.
Si le modèle choisit de ne pas appeler d'outil, il fournit une réponse en langage naturel.
- Exécutez l'outil dans l'application L'application exécute l'outil indiqué et récupère le résultat.
- Effectuez le second appel au modèle Ajoutez la sortie de l'outil au tableau des messages, puis appelez de nouveau le modèle.
- Obtenez la réponse finale du modèle Le modèle combine le résultat de l'outil avec la question initiale pour générer une réponse en langage naturel.
Modèles pris en charge
- Qwen
- DeepSeek
- GLM
- Kimi
- MiniMax
-
Modèles de génération de texte
- Qwen-Max : série Qwen4-Max, séries Qwen3.8-Max, Qwen3.7-Max, Qwen3.6-Max, Qwen3-Max et Qwen-Max
- Qwen-Plus : séries Qwen3.7-Plus, Qwen3.6-Plus, Qwen3.5-Plus et Qwen-Plus.
- Qwen-Flash : séries Qwen3.7-Flash, Qwen3.6-Flash, Qwen3.5-Flash et Qwen-Flash
- Qwen-Coder : séries Qwen3-Coder, Qwen2.5-Coder et Qwen-Coder
- Qwen-Turbo : série Qwen-Turbo
- Série open source Qwen3.6
- Série open source Qwen3.5
- Série open source Qwen3
- Série open source Qwen2.5
-
Modèles multimodaux
- Qwen-VL : séries Qwen3-VL-Plus et Qwen3-VL-Flash
- Qwen-Omni : séries Qwen3.5-Omni-Plus, Qwen3.5-Omni-Flash et Qwen3-Omni-Flash
- Qwen-Omni-Realtime : séries Qwen3.5-Omni-Plus-Realtime et Qwen3.5-Omni-Flash-Realtime
- Série open source Qwen3-VL
-
Modèles de chat vocal
- Qwen-Audio-Realtime : séries Qwen-Audio-3.0-Realtime-Plus et Qwen-Audio-3.0-Realtime-Flash
Premiers pas
Avant de commencer, obtenez une clé API et configurez-la en tant que variable d'environnement. Si vous utilisez le SDK OpenAI ou le SDK DashScope, vous devez également installer le SDK.
L'exemple suivant illustre le flux complet de Function Calling pour un scénario de requête météorologique.
- Compatible OpenAI
- DashScope
python
Mode d'emploi
Function Calling prend en charge deux méthodes pour transmettre les informations relatives aux outils :
- Méthode 1 : Transmission via le paramètre tools (recommandée) Pour plus d'informations, consultez Mode d'emploi. Suivez les étapes pour définir les outils, créer un tableau messages, effectuer un Function Calling, exécuter la fonction de l'outil et demander au LLM de synthétiser le résultat de cette fonction.
-
Méthode 2 : Transmission via un System Message
Transmettre les informations via le paramètre
toolsoffre les meilleurs résultats, car le serveur s'adapte automatiquement au modèle de prompt optimal. Si vous utilisez un modèle Qwen et ne souhaitez pas recourir au paramètretools, reportez-vous à Transmettre les informations des outils via un System Message.
tools.
Prenons un scénario métier recevant deux types de requêtes : des questions sur la météo et des demandes d'heure.
1. Définir les outils
Les outils connectent les LLM à des services externes. Vous devez d'abord les définir.
1.1. Créer les fonctions des outils
Créez deux fonctions d'outils : une pour la météo et une pour l'heure.
-
Outil de requête météo
Cet outil reçoit le paramètre
arguments. Le format deargumentsest{"location": "queried location"}. La sortie de l'outil est une chaîne au format :"{location} today is {weather}".À des fins de démonstration, l'outil de requête météo défini ici n'interroge pas réellement la météo. Il sélectionne aléatoirement entre ensoleillé, nuageux ou pluvieux. Dans un scénario réel, vous pouvez le remplacer par un outil tel que Amap Weather .
-
Outil de requête d'heure
L'outil de requête d'heure ne nécessite aucun paramètre d'entrée. Sa sortie est une chaîne au format :
"Current time: {queried time}.".Si vous utilisez Node.js, exécutez
npm install date-fnspour installer le package date-fns afin d'obtenir l'heure.
python
1.2. Créer le tableau tools
Avant de pouvoir choisir un outil, un humain doit comprendre sa fonction, ses cas d'usage et ses paramètres d'entrée. Il en va de même pour les LLM. Le modèle sélectionne l'outil approprié en se basant sur ces informations. Fournissez les informations de l'outil au format JSON suivant.
| Pour l'outil de requête météo, le format des informations de description est le suivant : |
tools). Ce tableau inclut le nom de la fonction, la description et la définition des paramètres pour chaque outil. Il sera transmis comme paramètre lors des requêtes ultérieures.
python
2. Créer le tableau messages
Function Calling transmet les instructions et le contexte au LLM via le tableau messages. Avant d'effectuer un appel, ce tableau doit contenir un System Message et un User Message.
System Message
Bien que la fonction et les cas d'usage des outils aient été décrits lors de la création du tableau tools, préciser davantage quand appeler les outils dans le System Message améliore généralement la précision des appels. Pour le scénario actuel, vous pouvez définir le System Prompt ainsi :
User Message
Le User Message sert à transmettre la question de l'utilisateur. En supposant que l'utilisateur demande « Météo à Shanghai », le tableau messages se présente alors comme suit :
python
Puisque les outils disponibles incluent la météo et l'heure, vous pouvez également poser des questions sur l'heure actuelle.
3. Effectuer un Function Calling
Transmettez les tableaux toolsetmessages créés au LLM pour effectuer un Function Calling. Le LLM détermine s'il doit appeler un outil. Le cas échéant, il renvoie le nom de la fonction de l'outil ainsi que ses paramètres.
Pour consulter la liste des modèles pris en charge, voir Modèles pris en charge .
python
"get_current_weather" avec le paramètre d'entrée "{\"location\": \"Shanghai\"}".
content. Lorsque vous saisissez « Hello », le paramètre tool_calls est vide et l'objet renvoyé se présente ainsi :
Si le paramètretool_callsest vide, votre programme peut renvoyer directement le contenu decontentsans exécuter les étapes suivantes.
Pour forcer le LLM à sélectionner un outil spécifique à chaque Function Calling, consultez Appel d'outil forcé .
4. Exécuter la fonction de l'outil
L'exécution de la fonction de l'outil concrétise la décision du modèle par une opération réelle.
C'est votre environnement de calcul qui exécute la fonction de l'outil, et non le LLM.Le LLM ne produit qu'une chaîne de caractères. Avant d'exécuter la fonction, vous devez analyser séparément le nom de la fonction de l'outil et ses paramètres d'entrée.
-
Fonction de l'outil
Créez un mappage
function_mapperassociant le nom de la fonction de l'outil à l'entité de la fonction, afin de convertir la chaîne renvoyée en entité fonctionnelle exécutable. - Paramètres d'entrée Les paramètres d'entrée renvoyés par Function Calling sont une chaîne JSON. Utilisez un outil pour l'analyser en objet JSON afin d'en extraire les informations.
python
Dans des scénarios réels, de nombreux outils effectuent des actions spécifiques (comme envoyer des e-mails ou télécharger des fichiers) plutôt que d'interroger des données, et ne renvoient pas de chaîne de caractères. Nous recommandons d'ajouter une description d'état (par exemple « E-mail envoyé avec succès » ou « Échec de l'opération ») pour ces outils afin d'aider le LLM à comprendre le statut d'exécution.
5. Demander au LLM de synthétiser la sortie de la fonction
Le format de sortie de la fonction de l'outil étant relativement fixe, le renvoyer tel quel à l'utilisateur peut paraître robotique. Soumettez donc la sortie de l'outil au contexte du modèle et appelez-le à nouveau pour générer une réponse en langage naturel.
-
Ajouter un Assistant Message
Après avoir effectué un Function Calling, vous obtenez un Assistant Message via
completion.choices[0].message. Ajoutez-le d'abord au tableaumessages. -
Ajouter un Tool Message
Ajoutez la sortie de l'outil au tableau
messagesau format{"role": "tool", "content": "tool output", "tool_call_id": completion.choices[0].message.tool_calls[0].id}.- Assurez-vous que la sortie de l'outil est bien au format chaîne de caractères.
tool_call_idest un identifiant unique généré par le système pour chaque demande d'appel d'outil. Le modèle pouvant demander plusieurs appels simultanément,tool_call_idgarantit que chaque résultat renvoyé correspond bien à l'intention d'appel initiale.
python
messages contient :
messages, exécutez le code suivant.
python
content : « The weather in Shanghai today is cloudy. If you have any other questions, feel free to ask. »
Utilisation avancée
Spécifier la méthode d'appel des outils
Appels d'outils parallèles
Une requête météo pour une seule ville ne nécessite qu'un seul appel d'outil. Si une question exige plusieurs appels, comme « Quel temps fait-il à Pékin et à Shanghai ? » ou « Quelle est la météo à Hangzhou et quelle heure est-il ? », le modèle peut renvoyer plusieurs appels d'outils dans une seule réponse après avoir effectué un Function Calling, car parallel_tool_calls a pour valeur par défaut true. Par exemple, pour la question « Quel temps fait-il à Pékin et à Shanghai ? », le tableau tool_calls de l'objet renvoyé contient les paramètres pour Pékin et Shanghai :
parallel_tool_calls sur false lorsque vous effectuez un Function Calling :
python
Les appels parallèles conviennent aux tâches indépendantes. S'il existe des dépendances entre les tâches (l'entrée de l'outil A dépend de la sortie de l'outil B), consultez Premiers pas pour implémenter des appels séquentiels (un outil à la fois) via une boucle
while.Appel d'outil forcé
Les LLM générant du contenu avec une certaine incertitude, ils peuvent choisir le mauvais outil. Pour forcer l'utilisation ou la désactivation d'un outil spécifique selon le type de question, modifiez le paramètre tool_choice. Sa valeur par défaut est "auto", ce qui laisse le LLM décider lui-même comment procéder.
Lorsque le LLM synthétise la sortie de la fonction, supprimez le paramètre tool_choice . Sinon, l'API continuera de renvoyer des informations d'appel d'outil.
-
Forcer l'utilisation d'un outil spécifique
Si vous souhaitez que Function Calling impose systématiquement un outil donné pour un certain type de question, définissez le paramètre
tool_choicesur{"type": "function", "function": {"name": "the_function_to_call"}}. Le LLM ne participera plus à la sélection et se contentera de fournir les paramètres d'entrée. En supposant que le scénario actuel ne concerne que des questions météo, modifiez le codefunction_callingcomme suit :Quelle que soit la question posée, la fonction d'outil dans l'objet renvoyé sera toujourspythonget_current_weather.Avant d'appliquer cette stratégie, assurez-vous que la question est liée à l'outil sélectionné, faute de quoi des résultats inattendus pourraient survenir.
tool_calls de l'objet renvoyé n'est jamais vide), définissez le paramètre tool_choice sur "required". Function Calling renverra alors systématiquement des informations sur l'outil et ses paramètres.
Si toutes les questions du scénario actuel nécessitent un appel d'outil, modifiez le code function_calling ainsi :
python
tool_calls dans l'objet renvoyé ne sera jamais vide.
Avant d'utiliser cette stratégie, vérifiez que la question est bien liée aux outils disponibles pour éviter des résultats inattendus.
-
Interdire tout appel d'outil
Si vous avez besoin que Function Calling n'effectue jamais d'appel d'outil (l'objet renvoyé contient une réponse dans
contentet le paramètretool_callsest vide), définissez le paramètretool_choicesur"none"ou omettez simplement le paramètretools. Le paramètretool_callsretourné sera alors toujours vide. En supposant qu'aucune question du scénario actuel ne nécessite d'outil, modifiez le codefunction_callingcomme suit :python
Conversation multi-tours
Un utilisateur peut demander « Météo à Pékin » au premier tour, puis « Et à Shanghai ? » au second. Si le contexte du modèle ne conserve pas les informations du premier tour, il ne pourra pas déterminer quel outil appeler. Dans un scénario de conversation multi-tours, maintenez l'intégrité du tableau messages après chaque échange. Ajoutez le nouveau User Message à ce tableau, puis effectuez un Function Calling et poursuivez avec les étapes suivantes. La structure du tableau messages se présente ainsi :
Sortie en streaming
L'utilisation de la sortie en streaming permet d'obtenir le nom de la fonction outil et les informations sur les paramètres d'entrée en temps réel, ce qui améliore l'expérience utilisateur. Dans ce cas :
- Les informations relatives aux paramètres de l'appel d'outil sont retournées par fragments sous forme de flux de données.
- Le nom de la fonction outil est retourné dans le premier fragment de données de la réponse du flux.
python
arguments) :
python
tool_calls ci-dessous par le contenu obtenu précédemment.
Appels d'outils avec l'API Responses
Les exemples précédents reposent sur les API OpenAI Chat Completions et DashScope. Si vous utilisez l'API OpenAI Responses, le processus global reste identique, mais le format de l'API présente les différences suivantes :
| Dimension | Chat Completions | Responses API |
|---|---|---|
| Format de définition de l'outil | ||
| Sortie de l'appel d'outil | response.choices[0].message.tool_calls | Éléments dans response.output où type est function_call |
| Transmission du résultat de l'outil | ||
| Réponse finale | response.choices[0].message.content | response.output_text |
python
Appels d'outils pour les modèles omni-modaux
Les modèles omni-modaux prennent en charge les appels d'outils. Les méthodes d'appel diffèrent entre la série Qwen-Omni et la série Qwen-Omni-Realtime.
Série Qwen-Omni
Les séries Qwen3.5-Omni-Plus, Qwen3.5-Omni-Flash et Qwen3-Omni-Flash prennent en charge les appels d'outils via l'API compatible OpenAI. L'étape d'obtention des informations sur les outils diffère des autres modèles sur les points suivants :
- La sortie en streaming est obligatoire : Qwen-Omni prend uniquement en charge la sortie en streaming. Pour obtenir les informations sur les outils, vous devez également définir
stream=True. - Une sortie texte uniquement est recommandée : Le modèle n'a besoin que d'informations textuelles pour obtenir les détails de l'outil (nom de la fonction et paramètres). Afin d'éviter la génération inutile de données audio, nous recommandons de définir
modalities=["text"]. Si la sortie inclut à la fois des modalités texte et audio, vous devrez ignorer les fragments de données audio lors de la récupération des informations sur les outils.
Pour plus d'informations sur Qwen-Omni, consultez Non temps réel (Qwen-Omni) .
python
arguments), consultez Sortie en streaming.
Série Qwen-Omni-Realtime
Les séries Qwen3.5-Omni-Plus-Realtime et Qwen3.5-Omni-Flash-Realtime prennent en charge l'appel d'outils et conviennent aux scénarios de conversation vocale. Vous pouvez les appeler via le SDK DashScope ou le protocole WebSocket natif.
Flux de travail :
Une fois la connexion WebSocket établie, transmettez la définition de l'outil via session.update pour entrer dans le flux d'interaction suivant :
Phase 1 : Entrée vocale et appel d'outil
-
L'utilisateur pose une question à la voix. Le client collecte l'audio et l'envoie au serveur (ce qui correspond à la méthode
append_audio()). Lorsque le VAD du serveur détecte la fin de la parole, il exécute l'inférence du modèle et détermine qu'un outil doit être appelé. -
Le serveur renvoie les informations d'appel d'outil au client (correspondant à l'événement
response.function_call_arguments.done), y compris le nom de la fonction (name), les paramètres d'entrée de la fonction (arguments) et l'identifiant d'appel (call_id). Voici un exemple : - Exécutez localement la fonction d'outil correspondante sur le client, en utilisant le nom de la fonction et les paramètres d'entrée, afin d'obtenir le résultat d'exécution.
-
Renvoyez le résultat d'exécution de l'outil au serveur (correspondant à l'événement
conversation.item.create), en incluant l'identifiant d'appel (call_id) et le résultat d'exécution (output). Voici un exemple : -
Envoyez ensuite un événement
response.createpour demander au serveur de générer la réponse vocale finale basée sur le résultat d'exécution de l'outil. -
Recevez la voix et le texte renvoyés par le serveur (correspondant aux événements
response.audio.deltaetresponse.audio_transcript.delta) et jouez la réponse vocale à l'utilisateur.
La série Qwen-Omni-Realtime ne prend pas en charge les paramètrestool_choiceetparallel_tool_calls.
Pour plus d'informations sur Qwen-Omni-Realtime, consultez Temps réel (Qwen-Omni-Realtime) , Événements client et Événements côté serveur .
DashScope Python SDK
Appel d'outils pour les modèles de réflexion approfondie
Les modèles de réflexion approfondie effectuent un raisonnement avant de générer les informations d'appel d'outil, ce qui améliore l'interprétabilité et la fiabilité des décisions.
- Processus de réflexion Le modèle analyse l'intention de l'utilisateur, identifie les outils nécessaires, vérifie la validité des paramètres et planifie étape par étape la stratégie d'appel.
-
Appel d'outil
Le modèle produit une ou plusieurs requêtes d'appel de fonction dans un format structuré.
L'appel parallèle d'outils est pris en charge.
Pour plus d'informations sur les modèles de réflexion pour la génération de texte, consultez Réflexion approfondie . Pour plus d'informations sur les modèles de réflexion multimodaux, consultez Compréhension d'images et de vidéos et Non temps réel (Qwen-Omni) .
Le paramètretool_choiceaccepte uniquement les valeurs"auto"(valeur par défaut, le modèle sélectionne alors l'outil de manière autonome) ou"none"(force le modèle à ne sélectionner aucun outil).
- Compatible OpenAI
- DashScope
- Python
- Node.js
- HTTP
Exemple de code
Résultat retourné
Saisissez « Météo dans les quatre municipalités » pour obtenir le résultat suivant :Mise en production
Tester la précision des appels d'outils
- Mettre en place un système d'évaluation : Constituez un jeu de données de test représentatif des scénarios métier réels et définissez des métriques d'évaluation claires, telles que la précision de sélection des outils, l'exactitude de l'extraction des paramètres et le taux de réussite de bout en bout.
- Optimiser les prompts En fonction des problèmes identifiés lors des tests, comme des sélections d'outils ou des paramètres incorrects, ajustez les prompts système ainsi que les descriptions des outils et des paramètres.
-
Mettre à niveau le modèle
Si l'ajustement des prompts ne suffit pas à améliorer les performances, passer à une version de modèle plus puissante, telle que
qwen3.6-plus, constitue la méthode la plus directe et la plus efficace.
Contrôler dynamiquement le nombre d'outils
Lorsqu'une application intègre des dizaines, voire des centaines d'outils, les fournir tous au modèle peut entraîner les problèmes suivants :
- Dégradation des performances : la difficulté pour le modèle de sélectionner l'outil approprié parmi un vaste ensemble augmente considérablement.
- Coût et latence : de nombreuses descriptions d'outils consomment une grande quantité de tokens d'entrée, ce qui accroît les coûts et ralentit les réponses.
-
Récupération sémantique
Convertissez les descriptions d'outils (
description) en vecteurs à l'aide d'un modèle d'embedding, puis stockez-les dans une base de données vectorielle. Lorsqu'un utilisateur soumet une requête, effectuez une recherche de similarité vectorielle sur le vecteur de cette requête pour récupérer les K outils les plus pertinents. -
Récupération hybride
Cette approche combine la correspondance floue de la récupération sémantique avec la correspondance exacte des mots-clés traditionnels ou des tags de métadonnées. Pour ce faire, ajoutez des champs
tagsoukeywordsaux outils. Lors de la récupération, l'exécution conjointe d'une recherche vectorielle et d'un filtrage par mots-clés améliore significativement la précision du rappel, en particulier pour les scénarios fréquents ou spécifiques. - Routeur LLM léger Pour une logique de routage plus complexe, utilisez un modèle plus petit, plus rapide et moins coûteux, tel que Qwen-Flash, comme routeur. Ce modèle a pour tâche de produire une liste de noms d'outils pertinents en fonction de la requête utilisateur.
- Maintenir un ensemble de candidats concis : quelle que soit la méthode employée, nous recommandons de ne fournir pas plus de 20 outils au modèle principal. Cela garantit un équilibre optimal entre la charge cognitive du modèle, le coût, la latence et la précision.
- Stratégie de filtrage par niveaux : mettez en place une stratégie de routage en entonnoir. Par exemple, commencez par un filtrage peu coûteux basé sur des mots-clés ou des règles pour écarter les outils manifestement non pertinents, puis appliquez une récupération sémantique sur les outils restants afin d'améliorer l'efficacité et la qualité.
Principes de sécurité des outils
Lorsque vous accordez des capacités d'exécution d'outils à un LLM, la sécurité doit être la priorité absolue. Les principes fondamentaux sont le moindre privilège et la confirmation humaine.
- Principe du moindre privilège : l'ensemble d'outils fourni au modèle doit respecter strictement ce principe. Par défaut, les outils doivent être en lecture seule, comme ceux permettant de consulter la météo ou de rechercher des documents. Évitez d'accorder toute autorisation d'« écriture » impliquant des modifications d'état ou des opérations sur des ressources.
- Isoler les outils dangereux : ne mettez pas directement à disposition du LLM des outils risqués, tels que ceux exécutant du code arbitraire (
code interpreter), manipulant le système de fichiers (fs.delete), effectuant des suppressions ou mises à jour en base de données (db.drop_table), ou traitant des transactions financières (payment.transfer). - Intervention humaine : un processus de révision et de confirmation manuelle est indispensable pour toutes les opérations à privilèges élevés ou irréversibles. Le modèle peut préparer une demande d'opération, mais c'est l'utilisateur humain qui doit cliquer sur le bouton « exécuter » final. Par exemple, le modèle peut rédiger un e-mail, mais l'utilisateur doit confirmer l'envoi.
Optimisation de l'expérience utilisateur
Le processus d'appel de fonctions comporte plusieurs étapes, et un problème à n'importe quel stade peut dégrader l'expérience utilisateur.
Gérer les échecs d'exécution des outils
Les échecs d'exécution d'outils sont fréquents. Adoptez les stratégies suivantes :
- Nombre maximal de tentatives : fixez une limite raisonnable, par exemple 3, afin d'éviter une attente prolongée pour l'utilisateur ou un gaspillage de ressources système dus à des échecs répétés.
- Fournir des réponses de repli : si les tentatives sont épuisées ou si une erreur irrésolvable survient, retournez un message clair et convivial à l'utilisateur, tel que : « Désolé, je ne trouve pas les informations demandées pour le moment. Le service est peut-être occupé. Veuillez réessayer plus tard. »
Gérer la latence de traitement
Une latence élevée peut réduire la satisfaction des utilisateurs. Des optimisations peuvent être appliquées tant côté frontend que backend.
- Définir un délai d'expiration : configurez un timeout spécifique et raisonnable pour chaque étape du processus d'appel de fonctions. En cas de dépassement, interrompez immédiatement l'opération et informez l'utilisateur.
- Offrir un retour d'information instantané : dès le début d'un appel de fonction, affichez une indication dans l'interface, telle que « Interrogation de la météo en cours... » ou « Recherche des informations pertinentes... ». Cela permet à l'utilisateur de suivre la progression en temps réel.
Facturation
Outre les tokens contenus dans le tableau messages, les descriptions d'outils sont également facturées en tant que tokens d'entrée.
Transmettre les informations d'outils via un message système
Transmettre les informations d'outils via un message système
Nous recommandons de transmettre les informations d'outils au grand modèle de langage (LLM) à l'aide du paramètre
tools, comme décrit dans la section Mode d'emploi. Pour transmettre ces informations via un message système, utilisez le modèle de prompt présenté dans le code suivant afin d'obtenir des performances optimales du modèle :- OpenAI compatible
- DashScope
- Python
- Node.js
Exemple de code
Après l'exécution du code ci-dessus, utilisez un analyseur XML pour extraire les informations d'appel d'outil, notamment le nom de la fonction et les paramètres d'entrée, situés entre les balises<tool_call>et</tool_call>.