Sorties structurées avec les LLM : mode JSON, appel de fonction et quand utiliser chacun

Sorties structurées avec les LLM : Mode JSON, Appel de fonctions et quand utiliser chaque approche

Les grands modèles de langage (LLM) sont devenus des outils indispensables pour les développeurs, mais extraire des données structurées fiables de leurs sorties textuelles libres reste un défi persistant. Que vous construisiez un chatbot, un pipeline de données automatisé ou un système d'aide à la décision, vous avez besoin que votre LLM retourne des données dans un format prévisible. Cet article explore deux techniques principales pour obtenir des sorties structurées : le Mode JSON et l'Appel de fonctions. Nous comparerons leur fonctionnement, leurs cas d'usage et fournirons des conseils pratiques sur quand utiliser chacune.

Comprendre le défi

Les LLM génèrent du texte token par token, ce qui rend leur sortie intrinsèquement non structurée. Une simple invite comme "Liste les capitales d'Europe" pourrait produire une liste à puces, un tableau ou un paragraphe selon l'entraînement du modèle et son caractère aléatoire. Pour les systèmes de production, cette variabilité est inacceptable. Vous avez besoin d'un schéma — une structure prédéfinie à laquelle le modèle doit adhérer. Le Mode JSON et l'Appel de fonctions sont deux méthodes qui imposent de tels schémas, mais elles fonctionnent différemment et conviennent à des scénarios distincts.

Prérequis

Avant de plonger dans l'implémentation, assurez-vous d'avoir les éléments suivants :

• Python 3.8 ou version ultérieure installé sur votre système.
• Accès à une API LLM prenant en charge les sorties structurées. Les GPT-4 et GPT-4 Turbo d'OpenAI sont les plus courants, mais d'autres fournisseurs (par exemple, Anthropic, Google) offrent des capacités similaires. Nous utiliserons OpenAI comme implémentation de référence.
• Une clé API de votre fournisseur LLM. Pour OpenAI, inscrivez-vous sur platform.openai.com et créez une clé.
• Une familiarité de base avec Python et les outils en ligne de commande.

Installation étape par étape

Nous allons configurer un environnement Python et installer les bibliothèques nécessaires. Ces étapes supposent que vous utilisez un terminal de type Unix (Linux, macOS ou WSL sur Windows).

1. Créer un environnement virtuel

L'isolation des dépendances évite les conflits avec d'autres projets. Exécutez les commandes suivantes :

python3 -m venv llm-structure
source llm-structure/bin/activate

La première commande crée un environnement virtuel nommé `llm-structure`. La seconde l'active, de sorte que tous les paquets Python que vous installerez seront contenus dans cet environnement.

2. Installer la bibliothèque Python OpenAI

La bibliothèque OpenAI fournit une interface propre pour interagir avec leur API. Installez-la avec pip :

pip install openai

Ceci installe la dernière version du paquet `openai`, qui inclut le support du Mode JSON et de l'Appel de fonctions.

3. Définir votre clé API

Vous devez vous authentifier auprès d'OpenAI. Définissez votre clé API comme variable d'environnement pour des raisons de sécurité :

export OPENAI_API_KEY="votre-cle-api-ici"

Remplacez `votre-cle-api-ici` par votre clé réelle. Pour une utilisation persistante, ajoutez cette ligne à votre fichier `.bashrc` ou `.zshrc`.

4. Vérifier l'installation

Testez que tout fonctionne en exécutant un script simple :

python3 -c "import openai; print('Bibliothèque OpenAI installée avec succès')"

Si aucune erreur n'apparaît, vous êtes prêt à continuer.

Mode JSON : Sorties structurées sans fonctions

Le Mode JSON demande au LLM de répondre avec un objet JSON valide qui correspond à un schéma que vous fournissez. C'est simple, flexible et fonctionne avec les complétions de chat standard.

Comment fonctionne le Mode JSON

Lorsque vous activez le Mode JSON, le modèle est contraint de générer une sortie qui est du JSON analysable. Vous spécifiez la structure attendue dans le message système ou l'invite utilisateur, généralement en utilisant une description de schéma. Le modèle n'exécute aucun code ; il formate simplement sa réponse en JSON.

Exemple d'utilisation : Extraction d'informations produit

Supposons que vous souhaitiez extraire les détails d'un produit à partir de la description d'un utilisateur. Voici un script Python complet :

import openai
import json

client = openai.OpenAI()

reponse = client.chat.completions.create(
    model="gpt-4-turbo",
    response_format={"type": "json_object"},
    messages=[
        {"role": "system", "content": "Extrais les informations produit en JSON avec les clés : nom, prix, catégorie, en_stock."},
        {"role": "user", "content": "J'ai acheté une souris sans fil premium à 49,99€ dans la section électronique. Elle est actuellement en stock."}
    ]
)

# Analyser la réponse JSON
donnees_produit = json.loads(reponse.choices[0].message.content)
print(donnees_produit)

**Explication :**

• Le paramètre `response_format={"type": "json_object"}` active le Mode JSON.
• Le message système indique au modèle la structure JSON attendue.
• Le modèle retourne une chaîne que vous pouvez analyser avec `json.loads`.

Quand utiliser le Mode JSON

Le Mode JSON est idéal lorsque :

• Vous avez besoin d'une structure de données simple et plate (par exemple, un seul objet avec quelques champs).
• Le schéma de sortie est statique et ne dépend pas de l'entrée utilisateur.
• Vous voulez un minimum de surcharge — pas besoin de définir des fonctions ou de gérer des appels d'outils.
• La réponse du modèle est la sortie finale, pas une étape intermédiaire.

**Limitations :** Le Mode JSON ne peut pas imposer des schémas complexes comme des objets imbriqués ou des tableaux avec des structures conditionnelles. Le modèle peut occasionnellement produire du JSON mal formé, nécessitant une gestion des erreurs.

Appel de fonctions : Exécution d'actions structurées

L'Appel de fonctions (également connu sous le nom d'utilisation d'outils) permet au LLM de demander l'exécution de fonctions prédéfinies. Le modèle retourne un objet JSON structuré qui spécifie quelle fonction appeler et avec quels arguments. C'est plus puissant que le Mode JSON car le modèle peut décider quand invoquer une fonction en fonction du contexte de la conversation.

Comment fonctionne l'Appel de fonctions

Vous définissez des fonctions avec des paramètres et des descriptions. Le modèle évalue la conversation et, si approprié, retourne une demande d'appel de fonction. Votre code exécute ensuite la fonction et passe le résultat au modèle pour un traitement ultérieur.

Exemple d'utilisation : Récupération de données météo

Créons un assistant météo qui utilise l'Appel de fonctions :

import openai
import json

client = openai.OpenAI()

# Définir une fonction pour que le modèle puisse l'appeler
fonctions = [
    {
        "name": "obtenir_meteo",
        "description": "Obtenir la météo actuelle pour une ville",
        "parameters": {
            "type": "object",
            "properties": {
                "ville": {
                    "type": "string",
                    "description": "Le nom de la ville, par exemple Paris"
                },
                "unite": {
                    "type": "string",
                    "enum": ["celsius", "fahrenheit"],
                    "description": "Unité de température"
                }
            },
            "required": ["ville"]
        }
    }
]

def obtenir_meteo(ville, unite="celsius"):
    """Simuler un appel API météo"""
    return f"La météo à {ville} est de 22° {unite}."

# Envoyer la conversation
reponse = client.chat.completions.create(
    model="gpt-4-turbo",
    messages=[
        {"role": "user", "content": "Quel temps fait-il à Paris ?"}
    ],
    functions=fonctions,
    function_call="auto"
)

message = reponse.choices[0].message

# Vérifier si le modèle veut appeler une fonction
if message.function_call:
    nom_fonction = message.function_call.name
    arguments = json.loads(message.function_call.arguments)
    
    # Exécuter la fonction
    resultat = obtenir_meteo(arguments["ville"], arguments.get("unite", "celsius"))
    
    # Renvoyer le résultat de la fonction au modèle
    seconde_reponse = client.chat.completions.create(
        model="gpt-4-turbo",
        messages=[
            {"role": "user", "content": "Quel temps fait-il à Paris ?"},
            message,
            {
                "role": "function",
                "name": nom_fonction,
                "content": resultat
            }
        ],
        functions=fonctions
    )
    
    print(seconde_reponse.choices[0].message.content)
else:
    print(message.content)

**Explication :**

• La liste `fonctions` définit une fonction avec ses paramètres et descriptions.
• `function_call="auto"` laisse le modèle décider quand appeler la fonction.
• Le modèle retourne un objet `function_call` avec le nom de la fonction et les arguments.
• Vous exécutez la fonction et renvoyez le résultat au modèle pour une réponse lisible.

Quand utiliser l'Appel de fonctions

L'Appel de fonctions est préférable lorsque :

• Vous avez besoin que le modèle interagisse avec des systèmes externes (par exemple, API, bases de données).
• Le schéma de sortie est dynamique ou dépend du contexte de la conversation.
• Vous voulez que le modèle effectue un raisonnement en plusieurs étapes (par exemple, appeler une fonction, puis utiliser le résultat dans un appel ultérieur).
• La sortie structurée est une étape intermédiaire dans un flux de travail plus large.

**Limitations :** L'Appel de fonctions nécessite plus de code pour gérer le cycle appel-retour. Il ajoute également de la latence car vous effectuez plusieurs appels API.

Comparaison entre Mode JSON et Appel de fonctions

| Fonctionnalité | Mode JSON | Appel de fonctions | |-------------------------|------------------------------------|-------------------------------------| | Structure de sortie | Objet JSON unique | Objet JSON + exécution de fonction | | Application du schéma | Via les instructions de l'invite | Via des définitions de fonctions explicites | | Complexité | Faible | Moyenne à élevée | | Latence | Un appel API | Deux appels API ou plus | | Schémas dynamiques | Limité | Entièrement pris en charge | | Interactions externes | Non | Oui (via l'exécution de fonctions) | | Gestion des erreurs | Manuelle (analyse JSON) | Intégrée (validation d'appel de fonction) |

Choisir la bonne approche

La décision dépend de votre cas d'utilisation :

• **Utilisez le Mode JSON** pour des tâches simples d'extraction de données où la sortie est le produit final. Exemples : analyse de requêtes utilisateur, génération de fichiers de configuration, ou formatage de journaux.
• **Utilisez l'Appel de fonctions** lorsque le LLM doit déclencher des actions réelles ou lorsque le schéma de sortie dépend de l'entrée utilisateur. Exemples : construction d'un chatbot qui prend des rendez-vous, interrogation d'une base de données, ou orchestration de flux de travail en plusieurs étapes.

Approche hybride

Vous pouvez combiner les deux techniques. Par exemple, utilisez l'Appel de fonctions pour récupérer des données d'une API, puis demandez au modèle de formater le résultat comme une structure JSON spécifique en utilisant le Mode JSON. Cela vous donne le meilleur des deux mondes : interaction externe plus formatage cohérent.

Bonnes pratiques

1. **Validez toujours la sortie** : Même avec des modes structurés, les modèles peuvent faire des erreurs. Utilisez des blocs `try-except` lors de l'analyse JSON et validez les champs par rapport à votre schéma. 2. **Fournissez des instructions claires** : Plus vous êtes précis sur la structure attendue, plus la sortie sera fiable. Incluez des exemples dans le message système. 3. **Gérez les cas limites** : L'Appel de fonctions peut retourner plusieurs appels de fonction ou aucun. Votre code doit gérer tous les scénarios avec élégance. 4. **Surveillez les coûts** : L'Appel de fonctions nécessite plusieurs appels API, ce qui augmente l'utilisation des tokens. Profilez votre application pour vous assurer qu'elle reste dans le budget. 5. **Testez avec plusieurs modèles** : Différents modèles (par exemple, GPT-3.5 vs GPT-4) peuvent avoir une fiabilité variable. Testez minutieusement avant le déploiement en production.

Conclusion

Le Mode JSON et l'Appel de fonctions sont des outils puissants pour extraire des sorties structurées des LLM, mais ils servent des objectifs différents. Le Mode JSON offre simplicité et rapidité pour l'extraction de données statiques, tandis que l'Appel de fonctions fournit flexibilité et intégration externe pour des flux de travail dynamiques. En comprenant leurs forces et limitations, vous pouvez choisir la bonne approche pour votre application — ou les combiner pour un effet maximal. Commencez par le Mode JSON pour des tâches simples, et passez à l'Appel de fonctions lorsque votre système exige une interaction avec le monde extérieur. La clé est d'adapter la technique à la complexité de votre problème, garantissant des applications alimentées par l'IA fiables, maintenables et efficaces.