nvidia-nemo/guardrailsProgrammierbare Guardrails für LLM-Chat-Apps: Eingabe-/Ausgabe-Regeln durchsetzen, Jailbreaks und Prompt-Injections blockieren, Halluzinationen erkennen und sensible Daten maskieren.
NEUSTE VERÖFFENTLICHUNG / ENTWICKLUNGSVERSION: Der develop-Branch verfolgt den neuesten Stand der Entwicklung. Die neueste veröffentlichte Version ist 0.23.0.
✨✨✨
📌 Die offizielle Dokumentation der NeMo Guardrails-Bibliothek ist verfügbar unter docs.nvidia.com/nemo/guardrails.
✨✨✨
Die NVIDIA NeMo Guardrails Bibliothek ist ein Open-Source-Toolkit, mit dem sich programmierbare Guardrails einfach zu LLM-basierten Konversationsanwendungen hinzufügen lassen. Guardrails (oder kurz „Rails") sind spezifische Methoden zur Steuerung der Ausgabe eines großen Sprachmodells, z. B. nicht über Politik zu sprechen, auf bestimmte Benutzeranfragen in einer bestimmten Weise zu antworten, einem vordefinierten Dialogpfad zu folgen, einen bestimmten Sprachstil zu verwenden, strukturierte Daten zu extrahieren und mehr.
Dieses Paper stellt die NeMo Guardrails Bibliothek vor und enthält einen technischen Überblick über das System und die aktuelle Bewertung.
Python 3.10, 3.11, 3.12 oder 3.13.
Zur Installation mit pip:```bash
pip install nemoguardrails
Für detailliertere Anweisungen siehe die [Installationsanleitung](https://docs.nvidia.com/nemo/guardrails/get-started/installation-guide).
## Übersicht
<!-- start-documentation-reuse -->
Die NeMo Guardrails-Bibliothek ermöglicht es Entwicklern, die LLM-basierte Anwendungen erstellen, **programmierbare Guardrails** zwischen dem Anwendungscode und dem LLM hinzuzufügen.
<div align="center">
<img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/programmable_guardrails.png" width="75%" alt="Programmierbare Guardrails">
</div>
Zu den wichtigsten Vorteilen der Hinzufügung *programmierbarer Guardrails* gehören:
- **Aufbau vertrauenswürdiger, sicherer und geschützter LLM-basierter Anwendungen:** Sie können Leitplanken definieren, um Gespräche zu lenken und abzusichern; Sie können das Verhalten Ihrer LLM-basierten Anwendung für bestimmte Themen festlegen und verhindern, dass sie sich auf unerwünschte Themen einlässt.
- **Sichere Verbindung von Modellen, Chains und anderen Diensten:** Sie können ein LLM nahtlos und sicher mit anderen Diensten (auch Tools genannt) verbinden.
- **Steuerbarer Dialog**: Sie können das LLM dazu bringen, vordefinierten Gesprächspfaden zu folgen, sodass Sie die Interaktion gemäß den Best Practices des Gesprächsdesigns gestalten und standardisierte Abläufe (z. B. Authentifizierung, Support) durchsetzen können.
<!-- end-documentation-reuse -->
### Schutz vor LLM-Schwachstellen
Die NeMo Guardrails-Bibliothek bietet mehrere Mechanismen, um eine LLM-gestützte Chat-Anwendung vor häufigen LLM-Schwachstellen wie Jailbreaks und Prompt-Injections zu schützen. Nachfolgend finden Sie eine beispielhafte Übersicht über den Schutz, den verschiedene Guardrails-Konfigurationen für den in diesem Repository enthaltenen Beispiel-[ABC Bot](https://github.com/nvidia-nemo/guardrails/blob/develop/examples/bots/abc) bieten. Weitere Details finden Sie auf der Seite [LLM Vulnerability Scanning](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>
### Anwendungsfälle
Sie können programmierbare Guardrails in verschiedenen Arten von Anwendungsfällen einsetzen:
1. **Fragebeantwortung** anhand einer Reihe von Dokumenten (auch bekannt als Retrieval Augmented Generation): Durchsetzung von Faktenprüfung und Ausgabemoderation.
2. **Domänenspezifische Assistenten** (auch Chatbots genannt): Stellen Sie sicher, dass der Assistent beim Thema bleibt und den entworfenen Gesprächsabläufen folgt.
3. **LLM-Endpunkte**: Hinzufügen von Guardrails zu Ihrem eigenen LLM für eine sicherere Kundeninteraktion.
4. **LangChain-Chains** (optional): Wenn Sie LangChain für einen Anwendungsfall verwenden, können Sie eine Guardrails-Schicht um Ihre Chains legen. Um diese Integration zu aktivieren, setzen Sie die Umgebungsvariable `NEMOGUARDRAILS_LLM_FRAMEWORK=langchain` oder rufen Sie `set_default_framework("langchain")` auf.
### Verwendung
Um Ihrer Anwendung programmierbare Guardrails hinzuzufügen, können Sie die Python-API oder einen Guardrails-Server verwenden (weitere Details finden Sie im [Server-Leitfaden](https://docs.nvidia.com/nemo/guardrails/get-started/integrate-into-application)). Die Verwendung der Python-API ähnelt der direkten Verwendung des LLM. Das Aufrufen der Guardrails-Schicht anstelle des LLM erfordert nur minimale Änderungen am Code und umfasst zwei einfache Schritte:
1. Laden einer Guardrails-Konfiguration und Erstellen einer `LLMRails`-Instanz.
2. Durchführen der Aufrufe an das LLM mithilfe der Methoden `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!"}]
)
I'm unable to translate this chunk because the input content is empty — no source text was provided after "INPUT:". Please provide the actual chunk content so I can translate it into German.```json {"role": "assistant", "content": "Hi! How can I help you?"}
Das Eingabe- und Ausgabeformat für die Methode `generate` ähnelt der [Chat Completions API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) von OpenAI.
#### Asynchrone API
Die NeMo-Guardrails-Bibliothek ist ein asynchrones Toolkit, da die Kernmechanik mit dem Python-Async-Modell implementiert ist. Die öffentlichen Methoden haben sowohl eine synchrone als auch eine asynchrone Version. Zum Beispiel: `LLMRails.generate` und `LLMRails.generate_async`.
### Unterstützte LLMs
Sie können NeMo Guardrails mit mehreren LLMs wie OpenAI GPT-3.5, GPT-4, LLaMa-2, Falcon, Vicuna oder Mosaic verwenden. Weitere Details finden Sie im Abschnitt [Unterstützte LLM-Modelle](https://docs.nvidia.com/nemo/guardrails/about-nemo-guardrails-library/supported-llms) im Konfigurationsleitfaden.
### Arten von Guardrails
Die NeMo-Guardrails-Bibliothek unterstützt fünf Hauptarten von Guardrails:
<div align="center">
<img src="https://raw.githubusercontent.com/NVIDIA-NeMo/Guardrails/develop/docs/_static/images/programmable_guardrails_flow.png" width="75%" alt="Programmable Guardrails Flow">
</div>
1. **Eingabe-Rails**: werden auf die Eingabe des Benutzers angewendet; eine Eingabe-Rail kann die Eingabe ablehnen und dadurch jede weitere Verarbeitung stoppen, oder die Eingabe verändern (z. B. um potenziell sensible Daten zu maskieren oder umzuformulieren).
2. **Dialog-Rails**: beeinflussen, wie das LLM gepromptet wird; Dialog-Rails arbeiten mit Nachrichten in kanonischer Form, für Details siehe [Colang Guide](https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang)) und bestimmen, ob eine Aktion ausgeführt werden soll, ob das LLM aufgerufen werden soll, um den nächsten Schritt oder eine Antwort zu erzeugen, ob stattdessen eine vordefinierte Antwort verwendet werden soll, usw.
3. **Retrieval-Rails**: werden auf die abgerufenen Chunks in einem RAG-Szenario (Retrieval Augmented Generation) angewendet; eine Retrieval-Rail kann einen Chunk ablehnen und so verhindern, dass er zum Prompten des LLM verwendet wird, oder die relevanten Chunks verändern (z. B. um potenziell sensible Daten zu maskieren).
4. **Ausführungs-Rails**: werden auf die Ein-/Ausgabe der benutzerdefinierten Aktionen (auch bekannt als Tools) angewendet, die vom LLM aufgerufen werden müssen.
5. **Ausgabe-Rails**: werden auf die vom LLM erzeugte Ausgabe angewendet; eine Ausgabe-Rail kann die Ausgabe ablehnen und so verhindern, dass sie an den Benutzer zurückgegeben wird, oder sie verändern (z. B. um sensible Daten zu entfernen).
### Guardrails-Konfiguration
Eine Guardrails-Konfiguration definiert die zu verwendenden **LLM(s)** und **einen oder mehrere Guardrails**. Eine Guardrails-Konfiguration kann beliebig viele Eingabe-/Dialog-/Ausgabe-/Retrieval-/Ausführungs-Rails enthalten. Eine Konfiguration ohne konfigurierte Rails leitet die Anfragen im Wesentlichen direkt an das LLM weiter.
Die Standardstruktur für einen Ordner mit einer Guardrails-Konfiguration sieht wie folgt aus:```
.
├── config
│ ├── actions.py
│ ├── config.py
│ ├── config.yml
│ ├── rails.co
│ ├── ...
Die Datei config.yml enthält alle allgemeinen Konfigurationsoptionen, wie z. B. LLM-Modelle, aktive Rails und benutzerdefinierte Konfigurationsdaten". Die Datei config.py enthält benutzerdefinierten Initialisierungscode und actions.py enthält benutzerdefinierte Python-Aktionen. Einen vollständigen Überblick finden Sie im Konfigurationsleitfaden.
Unten ist ein Beispiel für 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
Die `.co`-Dateien, die in einer Guardrails-Konfiguration enthalten sind, enthalten die Colang-Definitionen (siehe den nächsten Abschnitt für einen kurzen Überblick darüber, was Colang ist), die verschiedene Arten von Rails definieren. Im Folgenden finden Sie eine Beispieldatei `greeting.co`, die die Dialog-Rails für die Begrüßung des Benutzers definiert.```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?"
Im Folgenden finden Sie ein weiteres Beispiel für Colang-Definitionen für ein Dialog-Rail gegen Beleidigungen:```colang define user express insult "You are stupid"
define flow user express insult bot express calmly willingness to help
### Colang
Um verschiedene Arten von Guardrails zu konfigurieren und zu implementieren, führt dieses Toolkit **Colang** ein, eine Modellierungssprache, die speziell für die Gestaltung flexibler, aber dennoch kontrollierbarer Dialogabläufe entwickelt wurde. Colang hat eine python-ähnliche Syntax und ist darauf ausgelegt, einfach und intuitiv zu sein, insbesondere für Entwickler.```{note}
Two versions of Colang, 1.0 and 2.0, are supported and Colang 1.0 is the default.
Für eine kurze Einführung in die Syntax von Colang 1.0, siehe Colang 1.0 Language Syntax Guide.
Um mit Colang 2.0 zu beginnen, siehe Colang 2.0 Documentation.
NeMo Guardrails umfasst eine Reihe von integrierten Guardrails.```{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.
Die Bibliothek umfasst Guardrails für die Selbstprüfung von LLMs (Moderation von Eingaben/Ausgaben, Faktenprüfung, Halluzinationserkennung), NVIDIA-Sicherheitsmodelle (Inhaltssicherheit, Themensicherheit), Jailbreak- und Injektionserkennung sowie Integrationen mit Community-Modellen und Drittanbieter-APIs. Die vollständige Liste finden Sie in der [Guardrails-Bibliothek-Dokumentation](https://docs.nvidia.com/nemo/guardrails/user-guides/guardrails-library.html).
## CLI
Die NeMo-Guardrails-Bibliothek wird außerdem mit einer integrierten CLI geliefert.```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.
Sie können die CLI der NeMo-Guardrails-Bibliothek verwenden, um einen Guardrails-Server zu starten. Der Server kann eine oder mehrere Konfigurationen aus dem angegebenen Ordner laden und eine HTTP-API für deren Verwendung bereitstellen.``` nemoguardrails server [--config PATH/TO/CONFIGS] [--port PORT]
Um beispielsweise eine Chat-Completion für eine `sample`-Konfiguration zu erhalten, können Sie den `/v1/chat/completions`-Endpunkt verwenden:```
POST /v1/chat/completions
I notice the input content appears to be empty — there is no actual Markdown chunk text provided after "INPUT:" to translate.
Since the instruction is to translate only the exact source text provided, and no source text is present, I cannot produce a translation. Please provide the chunk content (chunk 25 of 32) so I can translate it into German.```json { "config_id": "sample", "messages": [{ "role":"user", "content":"Hello! What can you do for me?" }] }
I'm unable to produce a translation because the input chunk content appears to be empty. No source text was provided to translate.```json
{"role": "assistant", "content": "Hi! How can I help you?"}
Zum Starten eines Guardrails-Servers können Sie auch einen Docker-Container verwenden. Die NeMo-Guardrails-Bibliothek stellt ein Dockerfile bereit, mit dem Sie ein nemoguardrails-Image erstellen können. Weitere Informationen finden Sie im Abschnitt Verwendung von Docker.
Die LangChain-Integration ist optional. Um sie zu aktivieren, setzen Sie die Umgebungsvariable NEMOGUARDRAILS_LLM_FRAMEWORK=langchain oder rufen Sie set_default_framework("langchain") auf. Installieren Sie anschließend die LangChain-Pakete, die Ihre Konfiguration benötigt. Nachdem Sie die Integration aktiviert haben, können Sie eine Guardrails-Konfiguration um eine LangChain-Kette (oder ein beliebiges Runnable) legen und innerhalb einer Guardrails-Konfiguration eine LangChain-Kette aufrufen. Weitere Informationen finden Sie in der Dokumentation zur LangChain-Integration.
Die Bewertung der Sicherheit einer LLM-basierten Konversationsanwendung ist eine komplexe Aufgabe und weiterhin eine offene Forschungsfrage. Um eine ordnungsgemäße Bewertung zu unterstützen, bietet die NeMo-Guardrails-Bibliothek Folgendes:
nemoguardrails evaluate, mit Unterstützung für thematische Rails, Faktenprüfung, Moderation (Jailbreak- und Ausgabemoderation) und Halluzination.Es gibt viele Möglichkeiten, Guardrails zu einer LLM-basierten Konversationsanwendung hinzuzufügen. Zum Beispiel: explizite Moderations-Endpunkte (z. B. OpenAI, ActiveFence, PolicyAI), Kritik-Ketten (z. B. Constitutional Chain), Parsing der Ausgabe (z. B. Guardrails.ai), einzelne Guardrails (z. B. LLM-Guard), Halluzinationserkennung für RAG-Anwendungen (z. B. Got It AI, Patronus Lynx).
Die NeMo-Guardrails-Bibliothek zielt darauf ab, ein flexibles Toolkit bereitzustellen, das all diese komplementären Ansätze in eine kohärente LLM-Guardrails-Schicht integrieren kann. Beispielsweise bietet das Toolkit eine integrierte Integration mit ActiveFence, PolicyAI, AlignScore und LangChain-Ketten.
Nach bestem Wissen ist die NeMo-Guardrails-Bibliothek das einzige Guardrails-Toolkit, das auch eine Lösung zur Modellierung des Dialogs zwischen dem Benutzer und dem LLM bietet. Dies ermöglicht einerseits die präzise Steuerung des Dialogs. Andererseits ermöglicht es eine feinkörnige Kontrolle darüber, wann bestimmte Guardrails verwendet werden sollen, z. B. die Verwendung der Faktenprüfung nur für bestimmte Arten von Fragen.
Die NVIDIA-NeMo-Guardrails-Bibliothek erfasst anonyme Telemetriedaten, um NVIDIA dabei zu helfen zu verstehen, welche Bereitstellungsmuster und Sicherheitsfunktionen am häufigsten verwendet werden. Die Bibliothek sendet ein Nutzungsereignis, wenn Sie LLMRails, IORails oder Guardrails instanziieren, und sendet anschließend periodische Heartbeats von einem einzelnen Daemon-Thread pro Prozess. Diese Telemetrie ist getrennt von der anforderungsbezogenen Ablaufverfolgung. Sie konfigurieren die Ablaufverfolgung in Ihrer Guardrails-Konfiguration und senden sie an Ihr eigenes Observability-Backend. Telemetrie ist ein minimaler anonymer Ping an NVIDIA.
Aggregierte anonyme Nutzung über die exakten Release-Builds 0.22.0 und 0.23.0, 22. Mai – 18. August 2026:
Zuletzt aktualisiert am 18. August 2026
Die Telemetrie umfasst:
openai, nim oder nvidia_ai_endpoints, niemals Modellnamen oder Anmeldedatenjailbreak_detection, content_safety oder topic_safetylibrary, api oder cli-Server)LLMRails oder IORails)Im Ereignis-Payload werden keine Benutzerinhalte erfasst. Der Payload enthält keine Modellnamen, API-Schlüssel, Endpunkte, Prompts, Vervollständigungen, Token-Anzahlen, anforderungsbezogene Metriken, Dateipfade, Benutzernamen oder IP-Adressen. NVIDIA verwendet die Daten in aggregierter Form, um technische Arbeiten zu priorisieren, und wird Adoptionstrends mit der Community teilen.
Die Bibliothek versucht außerdem, jeden Ereignis-Payload in eine lokale Audit-Datei unter ~/.config/nemoguardrails/usage_stats.json zu schreiben. Die Audit-Datei speichert das Ereignis-JSONL, nicht die vollständige NVIDIA-Telemetrie-Hülle. Audit-Schreibvorgänge werden nach bestem Bemühen durchgeführt, und die Telemetrieübertragung wird auch dann fortgesetzt, wenn das lokale Audit-Schreiben fehlschlägt.
Setzen Sie eine der folgenden Optionen, um die Telemetrie zu deaktivieren:```bash export NEMO_GUARDRAILS_NO_USAGE_STATS=1
export DO_NOT_TRACK=1
mkdir -p ~/.config/nemoguardrails && touch ~/.config/nemoguardrails/do_not_track
Setzen Sie den Opt-out, bevor die NVIDIA-NeMo-Guardrails-Bibliothek startet. Das Ändern von Umgebungsvariablen oder das Erstellen von `do_not_track`, nachdem die Telemetrie gestartet wurde, stoppt einen bereits laufenden Heartbeat-Thread nicht.
Informationen zum vollständigen Schema und zu den feldweisen Beschreibungen finden Sie unter [docs/telemetry.md](https://docs.nvidia.com/nemo/guardrails/latest/telemetry.html).
Sie können die Telemetrieerfassung jederzeit ablehnen (Opt-out). Der Opt-out gilt nur für die Datenerfassung durch die NVIDIA-NeMo-Guardrails-Bibliothek selbst.
Drittanbieter-Endpunkte haben separate Nutzungsbedingungen und Datenschutzpraktiken. Die NVIDIA-NeMo-Guardrails-Bibliothek kann Inferenz-Endpunkte wie NVIDIA Build (`build.nvidia.com`) verwenden. Wenn Sie NVIDIA Build oder einen anderen Drittanbieter-Endpunkt verwenden, gelten die Nutzungsbedingungen und Datenschutzpraktiken dieses Endpunkts unabhängig von der Bibliothek. Ein Telemetrie-Opt-out in der NVIDIA-NeMo-Guardrails-Bibliothek erstreckt sich nicht auf den von Ihnen gewählten Endpunkt. NVIDIA Build ist nur für Evaluierungs- und Testzwecke vorgesehen und darf nicht in Produktionsumgebungen eingesetzt werden. Übermitteln Sie bei der Verwendung von NVIDIA Build keine vertraulichen Informationen oder personenbezogenen Daten.
## Einladung an die Community zur Mitarbeit
Die Beispiel-Rails im Repository sind hervorragende Ausgangspunkte. Wir laden die Community mit Begeisterung ein, dazu beizutragen, die Leistung vertrauenswürdiger, sicherer und geschützter LLMs für alle zugänglich zu machen. Eine Anleitung zum Einrichten einer Entwicklungsumgebung und zur Mitarbeit an der NeMo-Guardrails-Bibliothek finden Sie in den [Beitragsrichtlinien](https://github.com/nvidia-nemo/guardrails/blob/develop/CONTRIBUTING.md).
## Lizenz
Die NeMo-Guardrails-Bibliothek ist unter der [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0) lizenziert.
## So zitieren Sie
Wenn Sie die NeMo-Guardrails-Bibliothek verwenden, zitieren Sie das [EMNLP-2023-Paper](https://aclanthology.org/2023.emnlp-demo.40), das sie vorstellt.```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",
}