- Qu'est-ce que l'appel de fonction (Function Calling) ?
- Qu'est-ce que les sorties structurées (Structured Outputs) ?
- Appel de fonction vs Sorties structurées
- Comment vérifier l'appel de fonction et les sorties structurées sur Novita AI ?
- Comment utiliser l'appel de fonction sur Novita AI ?
- Comment utiliser les sorties structurées sur Novita AI ?
- Questions fréquentes
Les modèles d’IA modernes évoluent au-delà de la simple génération de texte. Avec des fonctionnalités comme l’appel de fonction (Function Calling) et les sorties structurées (Structured Outputs), les développeurs peuvent désormais créer des applications plus intelligentes et plus fiables. Sur Novita AI, vous pouvez désormais vérifier rapidement si un modèle prend en charge ces capacités directement dans la Console, ce qui rend l’intégration plus rapide et plus efficace.
Qu’est-ce que l’appel de fonction (Function Calling) ?
L’appel de fonction est une capacité de l’IA, en particulier avec les grands modèles de langage (LLM), qui permet au modèle d’interagir avec des fonctions, outils ou API externes pour effectuer des tâches spécifiques au-delà de la génération de réponses textuelles. Au lieu de simplement produire du texte, le modèle identifie quand une fonction particulière doit être appelée en fonction de la requête de l’utilisateur, détermine la fonction correcte à invoquer et spécifie les paramètres nécessaires pour cette fonction. L’exécution réelle de la fonction est gérée par un système ou une application externe, et non par le modèle lui-même.
https://www.youtube.com/watch?v=aqdWSYWC\_LI
Comment fonctionne l’appel de fonction ?
L’appel de fonction permet aux modèles d’IA d’interagir avec des outils externes, des API ou des fonctions internes pendant une conversation. Au lieu de simplement générer du texte, le modèle peut reconnaître quand une fonction est nécessaire, générer l’appel de fonction correct avec des arguments structurés et l’exécuter pour récupérer les résultats. Cela comble le fossé entre la compréhension du langage naturel et l’action dans le monde réel, permettant aux modèles d’effectuer des tâches comme la récupération de données en temps réel, la gestion de flux de travail ou le déclenchement automatique d’actions système.
Quels sont les avantages de l’appel de fonction ?
- Interaction avec le monde réel : les modèles peuvent déclencher des actions, pas seulement fournir des informations.
- Automatisation : rationalisez des processus comme la récupération de données, les réservations, les soumissions de formulaires, etc.
- Compréhension structurée : au lieu de se fier uniquement à la génération de texte, le modèle organise la sortie dans des formats prédéfinis, réduisant les erreurs.
- Cas d’utilisation améliorés : créez des applications, assistants et systèmes dynamiques plus fiables et efficaces.
- Efficacité du développeur : en sachant qu’un modèle prend en charge l’appel de fonction dès le départ, vous pouvez planifier les intégrations plus rapidement sans modifications lourdes.
Qu’est-ce que les sorties structurées (Structured Outputs) ?
Les sorties structurées désignent la capacité des grands modèles de langage (LLM) à générer des réponses conformes à un format prédéfini et spécifique, plutôt que de produire du texte libre. Ces sorties sont généralement dans des formats lisibles par machine tels que JSON, XML, des modèles remplis ou des données tabulaires, ce qui les rend plus faciles à analyser, valider et intégrer dans des systèmes logiciels ou des flux de travail.
Comment les sorties structurées sont générées
- Techniques d’invite (prompting) : le modèle est guidé par des invites soigneusement conçues pour produire une sortie dans le format souhaité.
- API d’appel de fonction : de manière plus robuste, les sorties structurées peuvent être générées en utilisant des interfaces d’appel de fonction où le modèle renvoie des arguments conformes strictement au schéma d’une fonction, souvent appliqué en définissant des paramètres comme
strict: true. - Guidage par machine à états finis (FSM) : en interne, la génération peut être contrainte de sorte que chaque jeton produit respecte les règles du format de sortie, réduisant les erreurs de structure.
Cas d’utilisation et avantages
- Extraction de données structurées à partir de texte non structuré, comme les détails d’événements, les informations utilisateur ou les paramètres de requête.
- Déclenchement d’API ou de fonctions externes avec des paramètres précis générés par le modèle.
- Construction de flux de travail complexes en plusieurs étapes reposant sur un échange de données cohérent et validé.
- Amélioration de la fiabilité dans des applications comme les chatbots, l’extraction de données et les systèmes d’automatisation en réduisant l’ambiguïté dans les sorties du modèle.
Appel de fonction vs Sorties structurées
| Aspect | 🛠️ Appel de fonction | 🗂️ Sorties structurées |
|---|---|---|
| Objectif | Déclencher une fonction externe | Retourner des informations structurées |
| Orientation | Axée sur l’action | Axée sur l’information |
| Sortie | Nom de la fonction + arguments | Données structurées prédéfinies (ex. JSON) |
| Exemple | Appeler une API météo pour obtenir les prévisions | Retourner un rapport météo au format JSON |
| Scénario d’utilisation | Quand le modèle doit effectuer une action | Quand vous voulez des données propres et analysables sans action |
Comment vérifier l’appel de fonction et les sorties structurées sur Novita AI ?
1 : Connectez-vous à Novita AI
Une fois sur la page d’accueil de Novita AI, cliquez simplement sur le bouton “Log In” ou “Get Started” en haut à droite. Vous pouvez vous connecter facilement avec Google, GitHub, Hugging Face ou simplement votre Email — à vous de choisir !
Essayez Novita AI maintenant !
Cliquez sur “Model API” dans la Console !
Une fois connecté, vous serez redirigé vers le tableau de bord de la Console Novita. En haut, cliquez sur “Model API”. Cette section vous donne accès à la liste complète des modèles disponibles, ainsi qu’à des informations détaillées sur leurs capacités — y compris s’ils prennent en charge l’appel de fonction (Function Calling) et les sorties structurées (Structured Outputs).
Choisissez votre modèle et vérifiez !
Il suffit de trouver le modèle qui vous intéresse, de cliquer dessus, et un panneau s’ouvrira à droite. Sous “Supported Capabilities”, vous verrez instantanément si l’appel de fonction et les sorties structurées sont pris en charge.
Comment utiliser l’appel de fonction sur Novita AI ?
1. 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",
# Obtenez la clé API Novita AI depuis : https://novita.ai/settings/key-management.
api_key="<VOTRE_CLÉ_API_Novita AI>",
)
model = "meta-llama/llama-4-maverick-17b-128e-instruct-fp8"
- 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 obtenir les informations météo.
# Exemple de fonction pour simuler la récupération de données météo.
def get_weather(location):
"""Récupère la météo actuelle pour un lieu donné."""
print("Appel de la fonction get_weather avec le lieu : ", location)
# Dans une application réelle, vous appelleriez une API météo externe ici.
# Ceci est un exemple simplifié renvoyant des données codées en dur.
return json.dumps({"location": location, "temperature": "60 degrés Fahrenheit"})
2. Construire la requête API avec les outils et le message utilisateur
Créez maintenant 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": "Obtenir la météo d'un lieu, l'utilisateur doit d'abord fournir un lieu",
"parameters": {
"type": "object",
"properties": {
"location": {
"type": "string",
"description": "La ville et l'état, ex. San Francisco, CA"
}
},
"required": ["location"]
},
}
},
]
messages = [
{
"role": "user",
"content": "Quel est le temps à San Francisco ?"
}
]
# Envoyons la requête et affichons la réponse.
response = client.chat.completions.create(
model=model,
messages=messages,
tools=tools,
)
# Veuillez vérifier si la réponse contient des appels d'outils si en production.
tool_call = response.choices[0].message.tool_calls[0]
print(tool_call.model_dump())
3. Sortie
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
4. 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.
# Assurez-vous que tool_call est défini depuis l'étape précédente
if tool_call:
# Étendre l'historique de la conversation avec le message d'appel d'outil de l'assistant
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)
# Exécuter la fonction et obtenir la réponse
function_response = get_weather(
location=function_args.get("location"))
# Ajouter la réponse de la fonction aux messages
messages.append(
{
"tool_call_id": tool_call.id,
"role": "tool",
"content": function_response,
}
)
# Obtenir la réponse finale du modèle, maintenant avec le résultat de la fonction
answer_response = client.chat.completions.create(
model=model,
messages=messages,
# Note : ne pas inclure le paramètre tools ici.
)
print(answer_response.choices[0].message)
5. Sortie
{'id': '0', 'function': {'arguments': '{"location": "San Francisco, CA"}', 'name': 'get_weather'}, 'type': 'function'}
Comment utiliser les sorties structurées sur Novita AI ?
1. Initialiser le client
Tout d’abord, vous devez initialiser le client avec votre clé API Novita.
from openai import OpenAI
client = OpenAI(
base_url="https://api.novita.ai/v3/openai",
# Obtenez la clé API Novita AI depuis : https://novita.ai/settings/key-management.
api_key="<VOTRE_CLÉ_API_Novita AI>",
)
# Allez sur la page [Modèles](https://novita.ai/models) pour voir les modèles qui prennent en charge `Structured Outputs`.
model = "mistralai/mistral-7b-instruct"
2. Définir le schéma JSON
Cet exemple crée un schéma pour extraire les informations de dépenses à partir de l’entrée de l’utilisateur.
# Définir l'invite système pour le suivi des dépenses.
system_prompt = """Vous êtes un assistant de suivi des dépenses.
Extrayez les informations de dépenses de l'entrée de l'utilisateur et formatez-les selon le schéma fourni."""
# Définir le schéma JSON pour la réponse structurée.
response_format = {
"type": "json_schema",
"json_schema": {
"name": "expense_tracking_schema",
"schema": {
"type": "object",
"properties": {
"expenses": {
"type": "array",
"items": {
"type": "object",
"properties": {
"description": {
"type": "string",
"description": "Description de la dépense"
},
"amount": {
"type": "number",
"description": "Montant dépensé en dollars"
},
"date": {
"type": "string",
"description": "Quand la dépense a eu lieu"
},
"category": {
"type": "string",
"description": "Catégorie de la dépense (ex. nourriture, bureau, voyage)"
}
},
"required": [
"description",
"amount"
]
}
},
"total": {
"type": "number",
"description": "Montant total de toutes les dépenses"
}
},
"required": [
"expenses",
"total"
],
},
},
}
3. Demander l’API de complétion de chat
Maintenant, faites la demande de complétion de chat vers le point de terminaison Novita.
Cette requête inclut le paramètre response_format, définissant le schéma JSON que nous avons défini à l’étape précédente.
chat_completion = client.chat.completions.create(
model=model,
messages=[
{
"role": "system",
"content": system_prompt,
},
{
"role": "user",
"content": """J'ai dépensé 120 $ pour un dîner dans un restaurant italien vendredi dernier avec mes collègues.
J'ai aussi acheté des fournitures de bureau pour 45 $ lundi.""",
},
],
max_tokens=1024,
temperature=0.8,
stream=False,
response_format=response_format,
)
response_content = chat_completion.choices[0].message.content
# Analyser et mettre en forme le JSON
try:
json_response = json.loads(response_content)
prettified_json = json.dumps(json_response, indent=2)
print(prettified_json)
except json.JSONDecodeError:
print("Impossible d'analyser la réponse en JSON. Réponse brute :")
print(response_content)
4. Sortie :
{
"expenses": [
{
"date": "2023-03-17",
"description": "Dîner au restaurant italien",
"amount": 120,
"category": "Alimentation"
},
{
"date": "2023-03-13",
"description": "Fournitures de bureau",
"amount": 45,
"category": "Fournitures de bureau"
}
],
"total": 165
}
L’appel de fonction et les sorties structurées étendent considérablement ce que les modèles d’IA peuvent faire. Que vous ayez besoin d’automatiser des flux de travail, de récupérer des données en temps réel ou d’extraire des informations structurées, Novita AI vous permet de trouver facilement des modèles qui correspondent à vos besoins. Commencez à créer des applications plus intelligentes dès aujourd’hui en explorant les modèles sur la Console Novita !
Questions fréquentes
Qu’est-ce que l’appel de fonction dans les modèles d’IA ?
Il permet aux modèles de déclencher des outils ou des API externes en générant des appels de fonction structurés basés sur les requêtes des utilisateurs.
Que sont les sorties structurées ?
Les sorties structurées désignent les réponses du modèle dans des formats stricts et lisibles par machine comme JSON, idéales pour une intégration facile.
En quoi l’appel de fonction et les sorties structurées diffèrent-ils ?
L’appel de fonction est axé sur l’action (ex. récupérer la météo), tandis que les sorties structurées se concentrent sur le renvoi de données propres et formatées.
Novita AI est la plateforme cloud tout-en-un qui alimente vos ambitions en IA. API intégrées, serverless, instances GPU — les outils rentables dont vous avez besoin. Éliminez l’infrastructure, commencez gratuitement et concrétisez votre vision de l’IA.
