Guide

NeMo Guardrails, une couche de contrôle entre appli et modèle

NVIDIA NeMo Guardrails place des rails d'entrée, de dialogue et de sortie entre ton application et un LLM. Colang, coût en latence, limites et alternatives.

L'équipe CodeWorlds14 min de lecture ·

Pratique Python dans des leçons interactives avec un éditeur de code.

Crée un compte gratuit→
Dans cet article10

Un modèle de langage à l'intérieur d'un produit d'entreprise crée un problème que le code ordinaire n'a pas : on ne peut pas prévoir à l'avance ce qu'il répondra. Une instruction système décrit comment il devrait se comporter et reste une suggestion plutôt qu'une contrainte.

NeMo Guardrails ajoute une couche qui introduit cette contrainte. Elle se place entre ton application et le modèle, fait passer le trafic dans les deux sens et le vérifie par rapport à des règles que tu décris.

Le projet est ouvert sous une licence permissive et développé par NVIDIA. Il fonctionne avec des modèles de divers fournisseurs, donc il ne t'attache pas au matériel ni aux services de son créateur, bien qu'il en vienne.

Cinq types de rails

La construction repose sur des rails placés à différents points du flux, et il est utile de les distinguer, car chacun résout un problème différent.

Un rail d'entrée vérifie ce qui arrive de l'utilisateur avant que cela atteigne le modèle. C'est là que sont attrapées les tentatives de contourner les instructions, les contenus interdits et les données qui ne doivent pas quitter ton infrastructure.

Un rail de dialogue gouverne le déroulement de la conversation. Il te permet d'indiquer de quoi l'assistant parle et de quoi il ne parle pas, et ce qui se passe quand une question sort du périmètre. C'est l'élément différenciant de cet outil, car la plupart des concurrents filtrent des messages individuels plutôt que de diriger une conversation.

Un rail de récupération vérifie le contenu tiré de sources externes avant qu'il entre dans le contexte du modèle. Cela répond au problème traité dans l'article sur le serveur de système de fichiers : un document peut contenir une instruction, et un modèle ne la distingue pas des données.

Un rail d'exécution contrôle les appels d'outils. Un rail de sortie vérifie la réponse avant que l'utilisateur ne la voie. La détection des tentatives de contournement des protections n'est pas un sixième type de rail mais l'un des usages du rail d'entrée, à côté du contrôle des sujets et du masquage des données personnelles.

Un conseil pratique : n'active pas les cinq au départ. Chacun ajoute de la latence et du coût, et la plupart des usages en demandent deux ou trois. Commence par l'entrée et la sortie, et ajoute le reste une fois que tu as mesuré qu'il est nécessaire.

Colang, ou des règles décrites dans un langage à part

Les règles s'écrivent dans un langage conçu pour cet usage plutôt que dans du code ordinaire. Cette décision a des avantages et un prix.

define user ask about competitors
  "what do you think of competing products"
  "is X better than you"
  "compare yourself with Y"

define bot decline competitor comparison
  "I do not compare us with other products. I am happy to describe what we do."

define flow
  user ask about competitors
  bot decline competitor comparison

L'avantage est réel : les règles sont lisibles par une personne non technique et peuvent être relues comme un document plutôt que comme du code. Dans une organisation où le service juridique ou la conformité a son mot à dire sur ce que dit l'assistant, c'est parfois décisif.

Le prix est un autre langage à apprendre. Avec des règles simples, la syntaxe est claire ; avec des flux complexes à plusieurs branches, elle cesse de l'être, et une erreur dans une règle se manifeste par un comportement que personne n'avait prévu plutôt que par un message d'erreur.

Remarque aussi que deux versions de ce langage existent et que les contenus en ligne décrivent les deux. Vérifie laquelle un exemple utilise avant de passer une soirée à comprendre pourquoi il ne s'exécute pas.

Le coût réel

Cette section compte le plus dans la décision et c'est la plus souvent sautée dans les contenus sur les outils de cette classe.

Les rails fondés sur la correspondance de motifs sont peu coûteux. Vérifier une entrée par rapport à des tentatives de contournement connues ajoute quelques dizaines de millisecondes, qui se perdent dans le temps de réponse de tout le reste.

Les rails fondés sur un modèle forment une catégorie tout à fait différente. Vérifier du contenu par un modèle de langage séparé ajoute deux cents à cinq cents millisecondes par passage, et vérifier l'entrée et la sortie fait deux passages.

Avec un rail qui utilise un modèle puissant comme juge, l'arithmétique devient sérieuse. Une latence supérieure à une seconde dans chaque sens signifie qu'une réponse qui prenait deux secondes en prend désormais quatre ou cinq.

Le coût financier suit le même chemin. Chaque vérification est un appel au modèle avec son propre prompt, donc un ensemble élaboré de rails peut doubler ou tripler la facture de la conversation elle-même.

La conclusion n'est pas « ne l'utilise pas » mais une question d'ordre. Commence par les rails peu coûteux et mesure combien de problèmes ils attrapent. Ajoute les rails coûteux là où les peu coûteux sont insuffisants plutôt que partout à tout hasard.

Les limites de cette approche

Elles méritent d'être nommées clairement, car le nom de l'outil suggère une étanchéité qu'aucune solution de cette classe n'offre.

La première concerne les agents à plusieurs étapes. Un rail d'exécution couvre les actions invoquées à l'intérieur de cette couche, pas les étapes que ton agent effectue de son côté. Un moteur expérimental a été ajouté depuis, qui vérifie les appels d'outils et les résultats renvoyés, mais de façon purement structurelle : l'outil est-il déclaré, les arguments correspondent-ils au schéma, et un résultat répond-il à un appel antérieur. Rien là-dedans ne juge le contenu des arguments. Avec un agent qui effectue dix étapes, l'essentiel du trafic se déroule encore hors de portée de cette couche.

La deuxième concerne l'efficacité. Les rails attrapent des motifs connus et des tentatives courantes plutôt que toutes les possibilités. Une formulation que personne n'avait anticipée passe, et ce n'est pas un défaut d'implémentation mais une propriété du problème.

La troisième concerne les fausses alertes. Un rail trop sensible bloque des questions innocentes, et l'utilisateur reçoit un refus sans raison compréhensible. C'est parfois pire pour un produit que de laisser passer un contenu qui aurait pu être filtré.

La quatrième concerne l'entretien. Il n'y a pas de variante hébergée par le créateur : il existe une variante en microservice payante avec support dans l'offre entreprise, mais elle se trouve quand même sur ton infrastructure, avec les modèles auxiliaires, un magasin vectoriel et la supervision. Le paquet avec ses dépendances occupe beaucoup de place, ce qui peut bloquer dans un déploiement serverless.

La conclusion honnête est la suivante : c'est une couche qui réduit le risque plutôt qu'elle ne le supprime. Pour les usages où une erreur coûte cher, il faut encore une personne qui valide les opérations et des contraintes du côté des permissions, pas seulement un contrôle du contenu.

NeMo Guardrails face aux alternatives

OptionPoint fortPoint faibleÀ choisir quand
NeMo GuardrailsContrôle du flux de la conversation, licence permissive, auto-hébergementL'entretien est à ta charge, un langage séparé à apprendreUn assistant qui parle à des utilisateurs, exigences de conformité
Rails du fournisseur de modèleAucun entretien, intégrés à l'appelPérimètre fixé par le fournisseur, pas de contrôle du fluxModération de contenu simple
Tes propres vérifications dans le codeContrôle total, aucune dépendanceTu écris et maintiens chaque règleQuelques règles métier précises
Contraintes côté permissionsFonctionne quel que soit le contenuNe filtre pas ce que dit le modèleToujours, comme couche de base

La dernière ligne n'est pas une alternative mais une fondation, et cela mérite d'être dit clairement. Un modèle sans accès à un outil de suppression de données ne supprimera pas de données quoi que quelqu'un lui écrive. Aucune couche de contrôle de contenu ne remplace cette contrainte.

Le choix entre la première et la deuxième ligne dépend du besoin de contrôler le flux de la conversation. S'il s'agit purement de filtrer des contenus interdits, les mécanismes intégrés à l'appel d'un fournisseur de modèle sont moins chers et n'exigent aucun entretien.

La deuxième ligne représente des services précis, et les nommer aide. Bedrock Guardrails ajoute des sujets interdits et la vérification de règles métier par raisonnement automatisé en plus de la modération, ce que les rails décrits ici ne font pas. Azure AI Content Safety offre une modération et une détection d'injection plus mûres, mais dans quatre catégories de préjudice fixes. Aucun des deux ne conduit une conversation scénarisée, les deux facturent au texte traité, et les deux t'attachent à un seul cloud.

Comment adapter les rails à un usage

Puisque chacun a un coût, une méthode de sélection est rentable plutôt que d'activer tout et de voir ce qui se passe.

Commence par demander ce qui peut mal tourner et quelles en sont les conséquences. Un assistant qui répond aux questions sur un produit peut dire quelque chose de faux, ce qui coûte en réputation. Un assistant qui traite des retours peut en approuver un qu'il ne devrait pas, ce qui coûte de l'argent. Deux réponses différentes exigent deux rails différents.

Vérifie ensuite si le problème a une solution moins chère. Le périmètre des sujets est souvent contraint plus efficacement par les outils dont le modèle dispose que par une vérification du contenu après coup. Ancrer les faits dans la documentation plutôt que dans la mémoire du modèle résout le problème de la réponse fausse à la source.

La troisième étape est la mesure sur de vraies conversations. Prends cent vraies questions d'utilisateurs et vérifie combien le rail en a bloquées à raison et combien à tort. Sans ce chiffre, régler la sensibilité relève de la devinette, et les fausses alertes ne deviennent visibles qu'une fois que les plaintes commencent à arriver.

La quatrième est l'observation après le déploiement. L'outil expose des métriques qui indiquent à quelle fréquence chaque rail s'est déclenché, et elles méritent d'être suivies, car un rail qui ne s'est pas déclenché une seule fois en un mois coûte à chaque requête et ne donne rien.

Déploiement et entretien

Quelques points pratiques à connaître avant de l'exécuter en production.

L'outil fonctionne comme une couche intermédiaire, donc il doit tourner quelque part. Le dispositif le plus simple est un service séparé que l'application interroge, avec une seule copie des modèles auxiliaires en mémoire. Les charger à chaque requête est coûteux et lent.

Récupère les modèles auxiliaires à l'avance et intègre-les dans l'image plutôt que de les télécharger au démarrage. Dans un environnement sans accès à Internet ou lors d'une montée en charge soudaine, le téléchargement finit en échec de lancement au pire moment.

Prévois ce qui se passe quand la couche de contrôle cesse de répondre. Deux comportements raisonnables sont de laisser passer le trafic sans vérification ou de refuser le service, et le choix entre eux dépend de ce qui est pire dans ton cas. Vérifie la valeur par défaut plutôt que de la supposer.

Enregistre quels rails se sont déclenchés et sur quel contenu. C'est le seul moyen de répondre, un mois plus tard, à la question de savoir si l'ensemble de règles fonctionne, et la seule source d'exemples pour corriger celles qui fonctionnent mal.

Quand cela a du sens

Séparer les cas est rentable, car un outil de cette classe est ajouté par réflexe.

Cela a du sens avec un assistant qui parle à des clients externes. Là, une réponse imprévue atteint quelqu'un en dehors de l'organisation, et l'entreprise répond de ce que son produit a dit.

Cela a du sens sous des exigences sectorielles. La finance, la santé et les domaines réglementés exigent de démontrer que des contrôles ont été introduits et pas seulement qu'un effort a été fourni. Des règles écrites séparément et ouvertes à la relecture sont un argument ici.

Cela a du sens avec du contenu venu de l'extérieur. Un assistant qui lit des tickets d'utilisateurs, des documents de fournisseurs ou des pages web travaille sur une matière que personne ne contrôle.

Cela n'a pas de sens pour un outil interne utilisé par l'équipe qui l'a construit. Le coût en latence et en entretien ne se rembourse pas quand les utilisateurs connaissent les limites et que personne ne subit de conséquences pour une mauvaise réponse.

Cela n'a pas non plus de sens comme seule protection autour d'opérations qui changent l'état. Envoyer un message, modifier des données et encaisser un paiement exigent une confirmation ou des permissions limitées plutôt qu'une vérification du contenu.

Erreurs fréquentes

La première est d'activer tous les rails au départ. Chacun ajoute de la latence et du coût, et la plupart des usages en demandent deux ou trois.

La deuxième est d'utiliser un modèle puissant comme juge à chaque vérification. La latence et la facture augmentent alors de plusieurs fois, alors qu'un modèle moins cher suffit pour la plupart des vérifications.

La troisième est de traiter les rails comme une protection étanche. Ils attrapent des motifs connus plutôt que toutes les formulations possibles.

La quatrième est de sauter les contraintes côté permissions. Le contrôle du contenu ne remplace pas le fait qu'un modèle n'ait tout simplement pas accès à un outil dangereux.

La cinquième est d'avoir des règles trop sensibles. Un refus sur une question innocente abîme plus un produit que de laisser passer un contenu qui aurait pu être filtré.

La sixième est de mélanger des contenus décrivant deux versions du langage de règles. Un exemple d'il y a deux ans peut ne pas s'exécuter avec la syntaxe actuelle.

La septième est de laisser des garde-fous qui ne se sont jamais déclenchés. Ils coûtent à chaque requête, et les mesures montrent clairement lesquels sont morts.

FAQ

En quoi diffère-t-il des filtres intégrés d'un fournisseur de modèle ?

Par le contrôle du flux de la conversation. Les filtres intégrés jugent des messages individuels, alors que cet outil te permet de décrire de quoi l'assistant parle et de quoi il ne parle pas, et ce qui se passe sur une question hors périmètre. Le prix est l'entretien et un langage séparé à apprendre.

Que coûte-t-il en latence ?

Cela dépend du type de rail. Les vérifications par motifs ajoutent quelques dizaines de millisecondes. Les vérifications qui utilisent un modèle séparé ajoutent deux cents à cinq cents millisecondes par passage, et avec un modèle puissant comme juge, la latence dépasse une seconde dans chaque sens.

Protège-t-il contre la prompt injection ?

Il réduit le risque plutôt qu'il ne le supprime. Un rail qui vérifie du contenu récupéré de l'extérieur attrape des motifs connus, tandis qu'une formulation imprévue passe. Pour les opérations qui changent l'état, il faut encore des contraintes de permissions et une confirmation humaine.

Fonctionne-t-il avec des agents à plusieurs étapes ?

En partie. Par défaut, il vérifie l'entrée et la sortie d'une conversation. Un moteur expérimental ajouté plus tard valide aussi les appels d'outils et leurs résultats, mais seulement pour la conformité au schéma et non pour le contenu des arguments. Avec un agent qui effectue de nombreuses étapes, une grande part du trafic reste hors de portée de cette couche.

Ai-je besoin du matériel de ce fabricant ?

Non. Le projet est ouvert et fonctionne avec des modèles de divers fournisseurs, y compris exécutés en local. Il s'intègre aussi avec des bibliothèques de construction de flux comme LangChain et LangGraph.

La documentation se trouve sur le site du fournisseur, et les métriques sont décrites dans une section séparée.

À lire aussi