nvidia-nemo/guardrailsGarde-fous programmables pour les applications de chat LLM : appliquer des rails d'entrée/sortie, bloquer les jailbreaks et les injections de prompt, détecter les hallucinations et masquer les données sensibles.
DERNIÈRE VERSION / VERSION DE DÉVELOPPEMENT : La branche develop suit les derniers développements en tête d'arbre. La dernière version publiée est la 0.23.0.
✨✨✨
📌 La documentation officielle de la bibliothèque NeMo Guardrails est disponible sur docs.nvidia.com/nemo/guardrails.
✨✨✨
La bibliothèque NVIDIA NeMo Guardrails est une boîte à outils open source permettant d'ajouter facilement des garde-fous programmables aux applications conversationnelles basées sur les LLM. Les garde-fous (ou « rails » en abrégé) sont des moyens spécifiques de contrôler la sortie d'un grand modèle de langage, comme ne pas parler de politique, répondre d'une manière particulière à des demandes utilisateur spécifiques, suivre un chemin de dialogue prédéfini, utiliser un style de langage particulier, extraire des données structurées, et plus encore.
Cet article présente la bibliothèque NeMo Guardrails et contient un aperçu technique du système ainsi que l'évaluation actuelle.
Python 3.10, 3.11, 3.12 ou 3.13.
Pour installer avec pip :```bash
pip install nemoguardrails
Pour des instructions plus détaillées, consultez le [Guide d'installation](https://docs.nvidia.com/nemo/guardrails/get-started/installation-guide).
## Vue d'ensemble
<!-- start-documentation-reuse -->
La bibliothèque NeMo Guardrails permet aux développeurs créant des applications basées sur des LLM d'ajouter des **garde-fous programmables** entre le code de l'application et le LLM.
<div align="center">
<img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/programmable_guardrails.png" width="75%" alt="Garde-fous programmables">
</div>
Les principaux avantages de l'ajout de *garde-fous programmables* sont les suivants :
- **Créer des applications basées sur des LLM fiables, sûres et sécurisées :** vous pouvez définir des rails pour guider et protéger les conversations ; vous pouvez choisir de définir le comportement de votre application basée sur un LLM sur des sujets spécifiques et l'empêcher de s'engager dans des discussions sur des sujets indésirables.
- **Connecter des modèles, des chaînes et d'autres services en toute sécurité :** vous pouvez connecter un LLM à d'autres services (également appelés outils) de manière transparente et sécurisée.
- **Dialogue contrôlable :** vous pouvez orienter le LLM pour qu'il suive des chemins conversationnels prédéfinis, ce qui vous permet de concevoir l'interaction en suivant les bonnes pratiques de conception de conversation et d'appliquer des procédures opérationnelles standard (par exemple, authentification, support).
<!-- end-documentation-reuse -->
### Protection contre les vulnérabilités des LLM
La bibliothèque NeMo Guardrails fournit plusieurs mécanismes pour protéger une application de chat propulsée par un LLM contre les vulnérabilités courantes des LLM, telles que les jailbreaks et les injections de prompts. Vous trouverez ci-dessous un aperçu de la protection offerte par différentes configurations de garde-fous pour l'exemple [ABC Bot](https://github.com/nvidia-nemo/guardrails/blob/develop/examples/bots/abc) inclus dans ce dépôt. Pour plus de détails, veuillez consulter la page [Analyse des vulnérabilités des LLM](https://docs.nvidia.com/nemo/guardrails/evaluation/llm-vulnerability-scanning.html).
<div align="center">
<img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/abc-llm-vulnerability-scan-results.png" width="500">
</div>
### Cas d'utilisation
Vous pouvez utiliser des garde-fous programmables dans différents types de cas d'utilisation :
1. **Réponses aux questions** sur un ensemble de documents (également appelé génération augmentée par récupération) : imposer la vérification des faits et la modération des sorties.
2. **Assistants spécialisés par domaine** (également appelés chatbots) : garantir que l'assistant reste sur le sujet et suit les flux conversationnels conçus.
3. **Points de terminaison LLM** : ajoutez des garde-fous à votre LLM personnalisé pour des interactions clients plus sûres.
4. **Chaînes LangChain** (facultatif) : si vous utilisez LangChain pour un cas d'utilisation quelconque, vous pouvez ajouter une couche de garde-fous autour de vos chaînes. Pour activer cette intégration, définissez la variable d'environnement `NEMOGUARDRAILS_LLM_FRAMEWORK=langchain` ou appelez `set_default_framework("langchain")`.
### Utilisation
Pour ajouter des garde-fous programmables à votre application, vous pouvez utiliser l'API Python ou un serveur de garde-fous (voir le [Guide du serveur](https://docs.nvidia.com/nemo/guardrails/get-started/integrate-into-application) pour plus de détails). L'utilisation de l'API Python est similaire à l'utilisation directe du LLM. Appeler la couche de garde-fous au lieu du LLM ne nécessite que des modifications minimes de la base de code et implique deux étapes simples :
1. Charger une configuration de garde-fous et créer une instance `LLMRails`.
2. Effectuer les appels au LLM à l'aide des méthodes `generate`/`generate_async`.```python
from nemoguardrails import LLMRails, RailsConfig
# Load a guardrails configuration from the specified path.
config = RailsConfig.from_path("PATH/TO/CONFIG")
rails = LLMRails(config)
completion = rails.generate(
messages=[{"role": "user", "content": "Hello world!"}]
)
Exemple de sortie :```json {"role": "assistant", "content": "Hi! How can I help you?"}
Le format d'entrée et de sortie de la méthode `generate` est similaire à l'[API Chat Completions](https://platform.openai.com/docs/guides/gpt/chat-completions-api) d'OpenAI.
#### API asynchrone
La bibliothèque NeMo Guardrails est une boîte à outils conçue en priorité pour l'asynchrone, car ses mécanismes centraux sont implémentés à l'aide du modèle asynchrone de Python. Les méthodes publiques ont à la fois une version synchrone et une version asynchrone. Par exemple : `LLMRails.generate` et `LLMRails.generate_async`.
### LLM pris en charge
Vous pouvez utiliser NeMo Guardrails avec plusieurs LLM comme OpenAI GPT-3.5, GPT-4, LLaMa-2, Falcon, Vicuna ou Mosaic. Pour plus de détails, consultez la section [Modèles LLM pris en charge](https://docs.nvidia.com/nemo/guardrails/about-nemo-guardrails-library/supported-llms) du guide de configuration.
### Types de garde-fous
La bibliothèque NeMo Guardrails prend en charge cinq principaux types de garde-fous :
<div align="center">
<img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/programmable_guardrails_flow.png" width="75%" alt="Flux des garde-fous programmables">
</div>
1. **Rails d'entrée** : appliqués à l'entrée de l'utilisateur ; un rail d'entrée peut rejeter l'entrée, arrêtant tout traitement supplémentaire, ou modifier l'entrée (par exemple, pour masquer des données potentiellement sensibles, pour reformuler).
2. **Rails de dialogue** : influencent la façon dont le LLM est invité ; les rails de dialogue opèrent sur des messages sous forme canonique (pour plus de détails, voir [Guide Colang](https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang)) et déterminent si une action doit être exécutée, si le LLM doit être appelé pour générer l'étape suivante ou une réponse, si une réponse prédéfinie doit être utilisée à la place, etc.
3. **Rails de récupération** : appliqués aux segments récupérés dans le cas d'un scénario RAG (Retrieval Augmented Generation) ; un rail de récupération peut rejeter un segment, l'empêchant d'être utilisé pour solliciter le LLM, ou modifier les segments pertinents (par exemple, pour masquer des données potentiellement sensibles).
4. **Rails d'exécution** : appliqués aux entrées/sorties des actions personnalisées (également appelées outils), qui doivent être appelées par le LLM.
5. **Rails de sortie** : appliqués à la sortie générée par le LLM ; un rail de sortie peut rejeter la sortie, l'empêchant d'être renvoyée à l'utilisateur, ou la modifier (par exemple, en supprimant les données sensibles).
### Configuration des garde-fous
Une configuration de garde-fous définit le ou les **LLM** à utiliser et **un ou plusieurs garde-fous**. Une configuration de garde-fous peut inclure un nombre quelconque de rails d'entrée/dialogue/sortie/récupération/exécution. Une configuration sans rails configurés transmettra essentiellement les requêtes au LLM.
La structure standard d'un dossier de configuration de garde-fous ressemble à ceci :```
.
├── config
│ ├── actions.py
│ ├── config.py
│ ├── config.yml
│ ├── rails.co
│ ├── ...
Le config.yml contient toutes les options de configuration générales, telles que les modèles LLM, les rails actifs et les données de configuration personnalisées". Le fichier config.py contient tout code d'initialisation personnalisé et le actions.py contient toutes les actions Python personnalisées. Pour une vue d'ensemble complète, consultez le Guide de configuration.
Voici un exemple de config.yml :```yaml
models:
rails:
input: flows: - check jailbreak - mask sensitive data on input
output: flows: - self check facts - self check hallucination - activefence moderation on input
config: # Configure the types of entities that should be masked on user input. sensitive_data_detection: input: entities: - PERSON - EMAIL_ADDRESS
Les fichiers `.co` inclus dans une configuration de guardrails contiennent les définitions Colang (voir la section suivante pour un aperçu rapide de ce qu'est Colang) qui définissent différents types de rails. Vous trouverez ci-dessous un exemple de fichier `greeting.co` qui définit les rails de dialogue pour saluer l'utilisateur.```colang
define user express greeting
"Hello!"
"Good afternoon!"
define flow
user express greeting
bot express greeting
bot offer to help
define bot express greeting
"Hello there!"
define bot offer to help
"How can I help you today?"
Voici un exemple supplémentaire de définitions Colang pour un rail de dialogue contre les insultes :```colang define user express insult "You are stupid"
define flow user express insult bot express calmly willingness to help
### Colang
Pour configurer et mettre en œuvre différents types de garde-fous, cette boîte à outils introduit **Colang**, un langage de modélisation spécialement créé pour concevoir des flux de dialogue flexibles, mais contrôlables. Colang possède une syntaxe de type Python et est conçu pour être simple et intuitif, en particulier pour les développeurs.```{note}
Two versions of Colang, 1.0 and 2.0, are supported and Colang 1.0 is the default.
Pour une brève introduction à la syntaxe Colang 1.0, consultez le Guide de syntaxe du langage Colang 1.0.
Pour commencer avec Colang 2.0, consultez la Documentation Colang 2.0.
NeMo Guardrails est fourni avec un ensemble de garde-fous intégrés.```{note} The built-in guardrails may or may not be suitable for a given production use case. As always, developers should work with their internal application team to ensure guardrails meets requirements for the relevant industry and use case and address unforeseen product misuse.
La bibliothèque inclut des garde-fous pour l'auto-vérification des LLM (modération des entrées/sorties, vérification des faits, détection des hallucinations), des modèles de sécurité NVIDIA (sécurité du contenu, sécurité des sujets), la détection de jailbreak et d'injection, ainsi que des intégrations avec des modèles communautaires et des API tierces. Pour la liste complète, consultez la [documentation de la bibliothèque de garde-fous](https://docs.nvidia.com/nemo/guardrails/user-guides/guardrails-library.html).
## CLI
La bibliothèque NeMo Guardrails est également fournie avec une interface en ligne de commande intégrée.```bash
$ nemoguardrails --help
Usage: nemoguardrails [OPTIONS] COMMAND [ARGS]...
actions-server Start a NeMo Guardrails actions server.
chat Start an interactive chat session.
evaluate Run an evaluation task.
server Start a NeMo Guardrails server.
Vous pouvez utiliser la CLI de la bibliothèque NeMo Guardrails pour démarrer un serveur guardrails. Le serveur peut charger une ou plusieurs configurations à partir du dossier spécifié et exposer une API HTTP pour les utiliser.``` nemoguardrails server [--config PATH/TO/CONFIGS] [--port PORT]
Par exemple, pour obtenir une complétion de chat pour une config `sample`, vous pouvez utiliser l'endpoint `/v1/chat/completions` :```
POST /v1/chat/completions
Please provide the Markdown content to translate.```json { "config_id": "sample", "messages": [{ "role":"user", "content":"Hello! What can you do for me?" }] }
Exemple de sortie :```json
{"role": "assistant", "content": "Hi! How can I help you?"}
Pour démarrer un serveur guardrails, vous pouvez également utiliser un conteneur Docker. La bibliothèque NeMo Guardrails fournit un Dockerfile que vous pouvez utiliser pour créer une image nemoguardrails. Pour plus d'informations, consultez la section utiliser Docker.
L'intégration de LangChain est facultative. Pour l'activer, définissez la variable d'environnement NEMOGUARDRAILS_LLM_FRAMEWORK=langchain ou appelez set_default_framework("langchain"). Installez ensuite les paquets LangChain requis par votre configuration. Après avoir activé l'intégration, vous pouvez envelopper une configuration de guardrails autour d'une chaîne LangChain (ou de tout Runnable), et vous pouvez appeler une chaîne LangChain depuis une configuration de guardrails. Pour plus d'informations, consultez la documentation sur l'intégration LangChain.
Évaluer la sécurité d'une application conversationnelle basée sur un LLM est une tâche complexe et reste une question de recherche ouverte. Pour faciliter une évaluation appropriée, la bibliothèque NeMo Guardrails fournit les éléments suivants :
nemoguardrails evaluate, prenant en charge les rails thématiques, la vérification des faits, la modération (jailbreak et modération des sorties) et l'hallucination.Il existe de nombreuses façons d'ajouter des guardrails à une application conversationnelle basée sur un LLM. Par exemple : des points de terminaison de modération explicites (par exemple, OpenAI, ActiveFence, PolicyAI), des chaînes de critique (par exemple, la chaîne constitutionnelle), l'analyse syntaxique de la sortie (par exemple, guardrails.ai), des guardrails individuels (par exemple, LLM-Guard), la détection d'hallucinations pour les applications RAG (par exemple, Got It AI, Patronus Lynx).
La bibliothèque NeMo Guardrails vise à fournir une boîte à outils flexible capable d'intégrer toutes ces approches complémentaires dans une couche de guardrails LLM cohérente. Par exemple, la boîte à outils fournit une intégration prête à l'emploi avec ActiveFence, PolicyAI, AlignScore et les chaînes LangChain.
À notre connaissance, la bibliothèque NeMo Guardrails est la seule boîte à outils de guardrails qui offre également une solution pour modéliser le dialogue entre l'utilisateur et le LLM. Cela permet d'une part de guider le dialogue avec précision. D'autre part, cela permet un contrôle fin pour déterminer quand certains guardrails doivent être utilisés, par exemple, n'utiliser la vérification des faits que pour certains types de questions.
La bibliothèque NVIDIA NeMo Guardrails collecte une télémétrie anonyme pour aider NVIDIA à comprendre quels schémas de déploiement et quelles fonctionnalités de sécurité sont les plus utilisés. La bibliothèque émet un événement d'utilisation lorsque vous instanciez LLMRails, IORails ou Guardrails, puis émet des battements de cœur périodiques à partir d'un seul thread démon par processus. Cette télémétrie est distincte du tracing par requête. Vous configurez le tracing dans votre configuration guardrails et l'envoyez à votre propre backend d'observabilité. La télémétrie est un ping anonyme minimal envoyé à NVIDIA.
Utilisation anonyme agrégée sur les versions exactes 0.22.0 et 0.23.0, du 22 mai au 18 août 2026 :
Dernière mise à jour le 18 août 2026
La télémétrie comprend :
openai, nim ou nvidia_ai_endpoints, jamais les noms de modèles ni les identifiantsjailbreak_detection, content_safety ou topic_safetylibrary, api ou cli)LLMRails ou IORails)Aucun contenu utilisateur n'est collecté dans la charge utile des événements. La charge utile n'inclut pas les noms de modèles, les clés API, les points de terminaison, les invites, les complétions, les compteurs de jetons, les métriques par requête, les chemins de fichiers, les noms d'utilisateur ni les adresses IP. NVIDIA utilise les données de manière agrégée pour prioriser les travaux d'ingénierie et partagera les tendances d'adoption avec la communauté.
La bibliothèque tente également d'écrire chaque charge utile d'événement dans un fichier d'audit local à l'emplacement ~/.config/nemoguardrails/usage_stats.json. Le fichier d'audit stocke le JSONL des événements, et non l'enveloppe complète de télémétrie NVIDIA. Les écritures d'audit sont effectuées au mieux (best effort) et la transmission de la télémétrie se poursuit même si l'écriture de l'audit local échoue.
Définissez l'une des options suivantes pour désactiver la télémétrie :```bash export NEMO_GUARDRAILS_NO_USAGE_STATS=1
export DO_NOT_TRACK=1
mkdir -p ~/.config/nemoguardrails && touch ~/.config/nemoguardrails/do_not_track
Configurez le désengagement avant le démarrage de la bibliothèque NVIDIA NeMo Guardrails. Modifier les variables d'environnement ou créer `do_not_track` après le démarrage de la télémétrie n'arrête pas un thread heartbeat déjà en cours d'exécution.
Reportez-vous à [docs/telemetry.md](https://docs.nvidia.com/nemo/guardrails/latest/telemetry.html) pour le schéma complet et les descriptions champ par champ.
Vous pouvez vous désengager de la collecte de télémétrie à tout moment. Le désengagement ne s'applique qu'à la collecte de données par la bibliothèque NVIDIA NeMo Guardrails elle-même.
Les points de terminaison tiers ont des conditions d'utilisation et des pratiques de confidentialité distinctes. La bibliothèque NVIDIA NeMo Guardrails peut utiliser des points de terminaison d'inférence tels que NVIDIA Build (`build.nvidia.com`). Si vous utilisez NVIDIA Build ou un autre point de terminaison tiers, les conditions d'utilisation et les pratiques de confidentialité de ce point de terminaison s'appliquent indépendamment de la bibliothèque. Tout désengagement de télémétrie dans la bibliothèque NVIDIA NeMo Guardrails ne s'étend pas au point de terminaison que vous choisissez. NVIDIA Build est destiné uniquement à l'évaluation et aux tests et ne doit pas être utilisé dans des environnements de production. Ne soumettez pas d'informations confidentielles ni de données personnelles lorsque vous utilisez NVIDIA Build.
## Inviter la communauté à contribuer
Les exemples de rails présents dans le dépôt constituent d'excellents points de départ. Nous invitons avec enthousiasme la communauté à contribuer pour rendre la puissance des LLM fiables, sûrs et sécurisés accessible à tous. Pour des conseils sur la configuration d'un environnement de développement et sur la façon de contribuer à la bibliothèque NeMo Guardrails, consultez les [directives de contribution](https://github.com/nvidia-nemo/guardrails/blob/develop/CONTRIBUTING.md).
## Licence
La bibliothèque NeMo Guardrails est sous licence [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
## Comment citer
Si vous utilisez la bibliothèque NeMo Guardrails, citez l'[article EMNLP 2023](https://aclanthology.org/2023.emnlp-demo.40) qui la présente.```bibtex
@inproceedings{rebedea-etal-2023-nemo,
title = "{N}e{M}o Guardrails: A Toolkit for Controllable and Safe {LLM} Applications with Programmable Rails",
author = "Rebedea, Traian and
Dinu, Razvan and
Sreedhar, Makesh Narsimhan and
Parisien, Christopher and
Cohen, Jonathan",
editor = "Feng, Yansong and
Lefever, Els",
booktitle = "Proceedings of the 2023 Conference on Empirical Methods in Natural Language Processing: System Demonstrations",
month = dec,
year = "2023",
address = "Singapore",
publisher = "Association for Computational Linguistics",
url = "https://aclanthology.org/2023.emnlp-demo.40",
doi = "10.18653/v1/2023.emnlp-demo.40",
pages = "431--445",
}