- Quels meilleurs résultats l'appel de fonctions peut-il aider GLM 4.5 à obtenir ?
- Tutoriel : Utiliser l'appel de fonctions dans GLM-4.5 pour les débutants
- Novita AI propose désormais la compatibilité avec le SDK Anthropic
- Comment améliorer la précision de l'appel de fonctions GLM-4.5
- Dépannage des erreurs d'appel de fonctions GLM-4.5
GLM 4.5, en tant que grand modèle linguistique (LLM) avancé doté de capacités d’agent, porte l’automatisation et la prise de décision intelligente à un niveau supérieur grâce à l’appel de fonctions. En exploitant l’appel de fonctions, GLM 4.5 peut interagir avec des outils et API externes, effectuer des actions, récupérer des données et automatiser des flux de travail complexes – ce qui en fait bien plus qu’un simple modèle conversationnel.
Cependant, l’intégration et le dépannage de l’appel de fonctions peuvent s’avérer complexes. Cet article fournit des conseils pratiques et des solutions aux problèmes courants que vous pouvez rencontrer lors de l’utilisation de l’appel de fonctions avec GLM 4.5, tels que des erreurs d’analyseur, des formats de sortie incorrects ou des pièges de conception de schéma. Grâce à des exemples clairs, des conseils de dépannage et des bonnes pratiques, cet article vous aide à identifier et résoudre rapidement les problèmes – vous permettant de libérer pleinement le potentiel agentique de GLM 4.5 dans vos applications réelles.
Quels meilleurs résultats l’appel de fonctions peut-il aider GLM 4.5 à obtenir ?
L’appel de fonctions est une fonctionnalité puissante introduite dans des grands modèles linguistiques tels que GLM 4.5. Il permet au modèle d’interagir avec des outils externes, des API ou du code structuré de manière contrôlée et fiable. Voici les principaux avantages et améliorations que l’appel de fonctions apporte à GLM 4.5 :
https://www.youtube.com/watch?v=KUEmEb71vzQ
1. Sorties plus précises et fiables
- Amélioration de la factualité : En déléguant des tâches telles que les calculs, les recherches de données ou les requêtes de base de données à des fonctions externes, GLM 4.5 peut éviter les erreurs courantes dans les réponses purement textuelles.
- Moins d’hallucinations : Le modèle s’appuie sur des résultats vérifiés provenant d’API ou de fonctions, réduisant ainsi le risque de générer des informations incorrectes ou fabriquées.
2. Automatisation des tâches complexes
- Chaînage de tâches : GLM 4.5 peut décomposer une demande utilisateur en plusieurs étapes, appelant les fonctions appropriées pour chaque étape et combinant les résultats.
- Automatisation des flux de travail : Il peut automatiser des processus métier multi-étapes, des traitements de données ou la génération de rapports en orchestrant des séquences d’appels de fonctions.
3. Amélioration de l’intégration avec les systèmes réels
- Accès à des données en temps réel : Grâce à l’appel de fonctions, le modèle peut récupérer des informations en temps réel à partir de bases de données, de services web ou d’appareils IoT, rendant ses réponses plus à jour et contextuelles.
- Actions personnalisées : Les entreprises peuvent définir des fonctions personnalisées (par exemple, l’envoi d’e-mails, la passation de commandes), permettant au modèle d’effectuer des actions spécifiques au domaine de manière sécurisée.
4. Amélioration de l’expérience utilisateur
- Applications interactives : Les utilisateurs peuvent interagir avec le modèle comme s’ils utilisaient une application, le modèle déclenchant les fonctions backend de manière transparente.
- Personnalisation : Les fonctions peuvent récupérer des données ou des paramètres spécifiques à l’utilisateur, permettant des réponses personnalisées.
5. Meilleure gestion des erreurs et explicabilité
- Raisonnement transparent : L’appel de fonctions permet de suivre quelles ressources ou outils externes ont été utilisés, rendant le processus de raisonnement du modèle plus auditable.
- Exécution contrôlée : Les développeurs peuvent surveiller et limiter les fonctions que le modèle peut appeler, améliorant ainsi la sécurité et la prévisibilité.
Quelles sont les limites de l’appel de fonctions dans GLM-4.5 ?
1. Appels excessifs
GLM-4.5 peut parfois effectuer des appels excessifs ou inutiles vers des outils ou API externes. Cela augmente l’utilisation de tokens et les coûts opérationnels, car davantage de ressources informatiques sont consommées sans toujours bénéficier au résultat final.
2. Cas limites en mode streaming
En mode streaming, si des données JSON partielles sont envoyées avant que la réponse complète ne soit terminée, les applications en aval peuvent recevoir des informations incomplètes. Sans une mise en mémoire tampon appropriée, cela peut entraîner des erreurs ou des échecs dans le traitement de la sortie.
3. Empreinte ressources
Pour l’appel de fonctions, cela signifie que des ressources matérielles limitées peuvent avoir un impact sur la capacité du modèle à traiter efficacement un grand nombre de requêtes, à traiter des données complexes ou à exécuter des chaînes complexes d’appels d’outils. Dans des environnements à ressources limitées, les performances et la précision de l’appel de fonctions peuvent être sensiblement réduites.
Avantages de l’utilisation de l’appel de fonctions avec GLM-4.5
Une évaluation indépendante des capacités de codage agentique de GLM-4.5 a été réalisée à l’aide de Claude Code, couvrant 52 tâches de codage diverses telles que le développement frontend, la création d’outils, l’analyse de données, les tests et l’implémentation d’algorithmes. GLM-4.5 a atteint un taux de succès d’appel d’outils leader de 90,6 %, surpassant Claude-4-Sonnet (89,5 %), Kimi K2 (86,2 %) et Qwen3-Coder (77,1 %).
Tutoriel : Utiliser l’appel de fonctions dans GLM-4.5 pour les débutants
Ce guide démontre comment utiliser l’appel de fonctions pour récupérer les informations météorologiques actuelles pour un lieu spécifié par l’utilisateur. Nous allons parcourir un exemple de code Python complet.
Pour le format API spécifique de l’appel de fonctions, veuillez consulter la documentation !
- Initialiser le client
Tout d’abord, vous devez initialiser le client avec votre clé API Novita.
from openai import OpenAI
import json
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Get the Novita AI API Key from: https://novita.ai/settings/key-management.
api_key="<YOUR Novita AI API Key>",
)
model = "zai-org/glm-4.5"
- Définir la fonction à appeler
Ensuite, définissez la fonction Python que le modèle peut appeler. Dans cet exemple, il s’agit d’une fonction pour récupérer les informations météorologiques.
# Example function to simulate fetching weather data.
def get_weather(location):
"""Retrieves the current weather for a given location."""
print("Calling get_weather function with location: ", location)
# In a real application, you would call an external weather API here.
# This is a simplified example returning hardcoded data.
return json.dumps({"location": location, "temperature": "60 degrees Fahrenheit"})
- Construire la requête API avec les outils et le message utilisateur
Maintenant, créez la requête API vers le point de terminaison Novita. Cette requête inclut le paramètre tools, définissant les fonctions que le modèle peut utiliser, et le message de l’utilisateur.
tools = [
{
"type": "function",
"function": {
"name": "get_weather",
"description": "Get weather of an location, the user shoud supply a location first",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "The city and state, e.g. San Francisco, CA",
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "What is the weather in San Francisco?"
}
]
# Let's send the request and print the response.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Please check if the response contains tool calls if in production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
- Sortie
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
- Répondre avec le résultat de l’appel de fonction et obtenir la réponse finale
L’étape suivante consiste à traiter l’appel de fonction, exécuter la fonction get_weather et renvoyer le résultat au modèle pour générer la réponse finale à l’utilisateur.
# Ensure tool_call is defined from the previous step
if tool_call:
# Extend conversation history with the assistant's tool call message
messages.append(response.choices[0].message)
function_name = tool_call.function.name
if function_name == "get_weather":
function_args = json.loads(tool_call.function.arguments)
# Execute the function and get the response
function_response = get_weather(
location=function_args.get("location"))
# Append the function response to the messages
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Get the final response from the model, now with the function result
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Note: Do not include tools parameter here.
)
print(answer_response.choices[0].message)
- Sortie
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
Novita AI propose désormais la compatibilité avec le SDK Anthropic
La combinaison de GLM-4.5 et Claude Code a rapidement attiré l’attention de la communauté IA, offrant des capacités agentiques avancées pour des applications réelles. Pour simplifier davantage cette intégration, Novita AI propose désormais une compatibilité avec le SDK Anthropic, vous permettant d’exploiter facilement la puissance de GLM-4.5 via l’interface familière de Claude Code.
Vous pouvez consulter cette documentation pour plus de détails !
1. Installer le SDK Anthropic
pip install anthropic
2. Initialiser le client
Les SDK Anthropic sont conçus pour récupérer la clé API et l’URL de base à partir des variables d’environnement : ANTHROPIC_API_KEY et ANTHROPIC_BASE_URL. Vous pouvez également fournir les paramètres au client Anthropic lors de son initialisation.
Vous pouvez consulter et gérer vos clés API sur la page des paramètres.
- Utiliser des variables d’environnement
export ANTHROPIC_BASE_URL="https://api.novita.ai/anthropic"
export ANTHROPIC_API_KEY="<YOUR_NOVITA_API_KEY>"
- Définir les paramètres lors de l’initialisation du client Anthropic
import anthropic
client = anthropic.Anthropic(
base_url="https://api.novita.ai/anthropic",
api_key="<YOUR_NOVITA_API_KEY>"
)
3. Appeler l’API
import anthropic
# Initialize the client, if you already set `ANTHROPIC_BASE_URL` and `ANTHROPIC_API_KEY`
# in the environment variables, you can omit the `api_key` and `base_url` parameters.
client = anthropic.Anthropic(
base_url="https://api.novita.ai/anthropic",
api_key="<YOUR_NOVITA_API_KEY>"
)
message = client.messages.create(
model="zai-org/glm-4.5",
max_tokens=1000,
temperature=1,
system="You are a world-class poet. Respond only with short poems.",
messages=[
{
"role": "user",
"content": [
{
"type": "text",
"text": "Why is the ocean salty?"
}
]
}
]
)
print(message.content)
Comment améliorer la précision de l’appel de fonctions GLM-4.5
1. Clarté du schéma
- Ce que cela signifie : Utilisez des noms de paramètres courts et uniques, et évitez les
anyOfimbriqués tant que l’analyseur n’est pas plus robuste. - Ce que cela résout :
- Empêche la confusion et les conflits de nommage des paramètres, facilitant pour le modèle le remplissage correct des arguments.
- Réduit les erreurs d’analyse et les échecs d’appels de fonctions causés par des schémas trop complexes.
2. Prompt système
- Ce que cela signifie : Demandez au modèle de « décider d’abord si un outil est nécessaire ; sinon, répondre directement ».
- Ce que cela résout :
- Réduit les appels d’outils/fonctions inutiles ou excessifs (appels excessifs).
- Permet d’économiser des ressources informatiques et des coûts opérationnels.
3. Température ≤ 0,2
- Ce que cela signifie : Définissez le paramètre de température sur 0,2 ou moins.
- Ce que cela résout :
- Réduit l’aléatoire de la sortie, garantissant un comportement plus prévisible et cohérent.
- Empêche la dérive de schéma, donc le modèle respecte la structure de paramètres prévue et réduit les erreurs.
4. Utiliser tool_choice="required"
- Ce que cela signifie : Définissez cette option lorsque l’utilisateur demande explicitement un appel de fonction.
- Ce que cela résout :
- Garantit que le modèle effectue toujours l’appel de fonction requis, améliorant la fiabilité et la satisfaction des utilisateurs.
5. Appels parallèles avec modération
- Ce que cela signifie : Ne parallélisez que les fonctions véritablement indépendantes ; sinon, générez les appels séquentiellement.
- Ce que cela résout :
- Empêche le mélange d’arguments ou l’incohérence logique entre les appels.
- Garantit que chaque appel reçoit le contexte et les entrées corrects, conduisant à des résultats plus précis.
Dépannage des erreurs d’appel de fonctions GLM-4.5
| Symptôme | Cause probable | Correction / Solution |
|---|---|---|
| IndexError : list index out of range dans l’analyseur | Utilisation de l’analyseur par défaut ; le format d’ID GLM diffère. | Démarrez le serveur avec --tool-call-parser glm4_moe. |
| Texte aléatoire mélangé au JSON | Température trop élevée ou tool_choice manquant. |
Baissez la température ; définissez tool_choice sur "auto" ou "required". |
| Récursion infinie d’outils | Le modèle hallucine des appels répétés. | Suivez les appels exécutés et interrompez les doublons dans la logique hôte. |
| OOM / Manque de ressources | La construction FP8 dépasse toujours la mémoire partagée des noyaux Triton. | Réduisez num_stages ou passez à la quantification Int4-Int8-Mix. |
| Aucun appel émis | Schéma d’outil trop vague. | Ajoutez une liste required stricte et des valeurs enum explicites. |
L’appel de fonctions transforme GLM 4.5 d’un modèle conversationnel en un agent intelligent capable d’exécuter des tâches et d’automatiser des processus en temps réel. En comprenant les problèmes typiques et leurs solutions – tels que les erreurs d’analyseur, le formatage JSON ou la conception de schéma – vous pouvez garantir une intégration fluide et libérer pleinement le potentiel agentique de GLM 4.5. Nous espérons que cet article a clarifié les questions courantes et vous a permis de déployer l’appel de fonctions GLM 4.5 en toute confiance.
Questions fréquemment posées
Pourquoi l’appel de fonctions est-il important pour GLM 4.5 en tant que LLM agentique ?
L’appel de fonctions permet à GLM 4.5 d’interagir par programmation avec des services externes, des bases de données et des outils. Cela permet l’automatisation, le raisonnement multi-étapes, la récupération d’informations et des actions réelles au-delà de la génération de texte.
Comment éviter la récursion infinie ou les appels d’outils répétés ?
Implémentez une logique côté hôte pour suivre et interrompre les appels de fonction en double, évitant ainsi les boucles infinies.
Quelles sont les bonnes pratiques de conception de schéma pour garantir l’émission d’appels de fonctions ?
Utilisez des noms de paramètres concis et uniques, fournissez des enum explicites et définissez les paramètres requis pour rendre le schéma clair pour le modèle.
Novita AI est la plateforme cloud tout-en-un qui concrétise vos ambitions IA. APIs intégrées, serverless, instances GPU – les outils rentables dont vous avez besoin. Éliminez l’infrastructure, commencez gratuitement et faites de votre vision IA une réalité.
