nvidia-nemo/guardrailsProgrammierbare Guardrails für LLM-Chat-Apps: Eingabe-/Ausgabe-Regeln durchsetzen, Jailbreaks und Prompt-Injections blockieren, Halluzinationen erkennen und sensible Daten maskieren.
NEUESTE VERSION / ENTWICKLUNGSVERSION: Der Branch develop verfolgt die neueste Entwicklung auf dem aktuellen Stand. Die zuletzt veröffentlichte Version ist 0.24.1.
✨✨✨
📌 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 auf einfache Weise programmierbare Guardrails zu LLM-basierten Konversationsanwendungen hinzufügen lassen. Guardrails (oder kurz „Rails") sind spezifische Möglichkeiten, die Ausgabe eines großen Sprachmodells zu steuern, beispielsweise nicht über Politik zu sprechen, auf bestimmte Benutzeranfragen in einer bestimmten Weise zu reagieren, einem vordefinierten Dialogpfad zu folgen, einen bestimmten Sprachstil zu verwenden, strukturierte Daten zu extrahieren und vieles mehr.
Dieses Paper stellt die NeMo Guardrails Bibliothek vor und enthält einen technischen Überblick über das System sowie die aktuelle Evaluierung.
Python 3.10, 3.11, 3.12 oder 3.13.
Zur Installation mit pip:```bash
pip install nemoguardrails
Detailliertere Anweisungen findest du im [Installationsleitfaden](https://docs.nvidia.com/nemo/guardrails/get-started/installation-guide).
## Überblick
<!-- 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="Programmable Guardrails">
</div>
Zu den wichtigsten Vorteilen der Hinzufügung von *programmierbaren Guardrails* gehören:
- **Aufbau vertrauenswürdiger, sicherer und geschützter LLM-basierter Anwendungen:** Du kannst Rails definieren, um Gespräche zu lenken und abzusichern; du kannst das Verhalten deiner LLM-basierten Anwendung zu bestimmten Themen festlegen und verhindern, dass sie sich an Diskussionen über unerwünschte Themen beteiligt.
- **Modelle, Chains und andere Dienste sicher verbinden:** Du kannst ein LLM nahtlos und sicher mit anderen Diensten (auch bekannt als Tools) verbinden.
- **Kontrollierbarer Dialog**: Du kannst das LLM dazu anleiten, vordefinierten Gesprächspfaden zu folgen, sodass du die Interaktion nach Best Practices des Conversation Designs gestalten und Standardarbeitsanweisungen (z. B. Authentifizierung, Support) durchsetzen kannst.
<!-- end-documentation-reuse -->
### Schutz vor LLM-Schwachstellen
Die NeMo Guardrails-Bibliothek bietet mehrere Mechanismen zum Schutz einer LLM-gestützten Chat-Anwendung vor gängigen LLM-Schwachstellen wie Jailbreaks und Prompt-Injections. Nachfolgend findest du 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 findest du 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
Du kannst programmierbare Guardrails in verschiedenen Arten von Anwendungsfällen einsetzen:
1. **Fragebeantwortung** über eine Reihe von Dokumenten (auch bekannt als Retrieval Augmented Generation): Durchsetzung von Faktenprüfung und Output-Moderation.
2. **Domänenspezifische Assistenten** (auch bekannt als Chatbots): Stelle sicher, dass der Assistent beim Thema bleibt und den gestalteten Gesprächsabläufen folgt.
3. **LLM-Endpunkte**: Füge Guardrails zu deinem benutzerdefinierten LLM hinzu, um eine sicherere Kundeninteraktion zu ermöglichen.
4. **LangChain Chains** (optional): Wenn du LangChain für einen Anwendungsfall verwendest, kannst du eine Guardrails-Schicht um deine Chains hinzufügen. Um diese Integration zu aktivieren, setze die Umgebungsvariable `NEMOGUARDRAILS_LLM_FRAMEWORK=langchain` oder rufe `set_default_framework("langchain")` auf.
### Verwendung
Um programmierbare Guardrails zu deiner Anwendung hinzuzufügen, kannst du die Python-API oder einen Guardrails-Server verwenden (siehe den [Server Guide](https://docs.nvidia.com/nemo/guardrails/get-started/integrate-into-application) für weitere Details). Die Verwendung der Python-API ähnelt der direkten Verwendung des LLM. Der Aufruf der Guardrails-Schicht anstelle des LLM erfordert nur minimale Änderungen an der Codebasis und umfasst zwei einfache Schritte:
1. Laden einer Guardrails-Konfiguration und Erstellen einer `LLMRails`-Instanz.
2. Aufrufen des 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!"}]
)
Beispielausgabe:```json {"role": "assistant", "content": "Hi! How can I help you?"}
Das Eingabe- und Ausgabeformat für die `generate`-Methode ähnelt der [Chat Completions API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) von OpenAI.
#### Async API
Die NeMo Guardrails-Bibliothek ist ein Async-First-Toolkit, da die Kernmechanismen unter Verwendung des Python-Async-Modells implementiert sind. Die öffentlichen Methoden verfügen sowohl über eine synchrone als auch über 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 [Supported LLM Models](https://docs.nvidia.com/nemo/guardrails/about-nemo-guardrails-library/supported-llms) im Konfigurationshandbuch.
### 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. **Input Rails**: werden auf die Eingabe des Benutzers angewendet; ein Input Rail kann die Eingabe ablehnen und damit 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 kanonischen Formnachrichten (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 generieren, ob stattdessen eine vordefinierte Antwort verwendet werden soll usw.
3. **Retrieval Rails**: werden auf die abgerufenen Chunks im Fall eines RAG-Szenarios (Retrieval Augmented Generation) angewendet; ein Retrieval Rail kann einen Chunk ablehnen und damit verhindern, dass er zum Prompten des LLM verwendet wird, oder die relevanten Chunks verändern (z. B. um potenziell sensible Daten zu maskieren).
4. **Execution Rails**: werden auf Eingabe/Ausgabe der benutzerdefinierten Aktionen (auch bekannt als Tools) angewendet, die vom LLM aufgerufen werden müssen.
5. **Output Rails**: werden auf die vom LLM generierte Ausgabe angewendet; ein Output Rail kann die Ausgabe ablehnen und damit verhindern, dass sie an den Benutzer zurückgegeben wird, oder sie verändern (z. B. durch Entfernen sensibler Daten).
### Guardrails-Konfiguration
Eine Guardrails-Konfiguration definiert die zu verwendenden **LLM(s)** und **einen oder mehrere Guardrails**. Eine Guardrails-Konfiguration kann eine beliebige Anzahl von Input-/Dialog-/Output-/Retrieval-/Execution Rails enthalten. Eine Konfiguration ohne konfigurierte Rails leitet die Anfragen im Wesentlichen an das LLM weiter.
Die Standardstruktur für einen Guardrails-Konfigurationsordner sieht folgendermaßen aus:```
.
├── config
│ ├── actions.py
│ ├── config.py
│ ├── config.yml
│ ├── rails.co
│ ├── ...
Die config.yml enthält alle allgemeinen Konfigurationsoptionen wie 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 Configuration Guide.
Nachfolgend finden Sie ein Beispiel für eine 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. Nachfolgend finden Sie ein Beispiel für eine `greeting.co`-Datei, 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?"
Nachfolgend ein weiteres Beispiel für Colang-Definitionen für eine Dialog-Schiene 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 und 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.
Eine kurze Einführung in die Colang 1.0-Syntax finden Sie im Colang 1.0 Language Syntax Guide.
Um mit Colang 2.0 zu beginnen, siehe die Colang 2.0 Documentation.
NeMo Guardrails wird mit einer Reihe von integrierten Guardrails geliefert.```{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 enthält Guardrails für die LLM-Selbstüberprüfung (Eingabe-/Ausgabemoderation, Faktenprüfung, Halluzinationserkennung), NVIDIA-Sicherheitsmodelle (Inhaltssicherheit, Themensicherheit), Jailbreak- und Injection-Erkennung sowie Integrationen mit Community-Modellen und Drittanbieter-APIs. Die vollständige Liste finden Sie in der [Guardrails Library-Dokumentation](https://docs.nvidia.com/nemo/guardrails/user-guides/guardrails-library.html).
## CLI
Die NeMo Guardrails-Bibliothek verfügt außerdem über eine integrierte CLI.```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 NeMo Guardrails-Bibliothek CLI 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 Nutzung bereitstellen.``` nemoguardrails server [--config PATH/TO/CONFIGS] [--port PORT]
Um beispielsweise eine Chat-Vervollständigung für eine `sample`-Konfiguration zu erhalten, können Sie den Endpunkt `/v1/chat/completions` verwenden:```
POST /v1/chat/completions
| -s | --server | Server-Modus aktivieren (erfordert --port) |
| -p | --port | Port für den Server-Modus (Standard: 8080) |
| -c | --config | Pfad zur Konfigurationsdatei |
| -v | --verbose | Ausführliche Ausgabe aktivieren |
| -h | --help | Hilfemeldung anzeigen |
| -V | --version | Versionsinformationen anzeigen |
# Grundlegende Verwendung
mytool scan --target example.com
# Ausführliche Ausgabe
mytool scan --target example.com --verbose
# Server-Modus
mytool --server --port 9090
Das Tool kann über eine Konfigurationsdatei konfiguriert werden:
# config.yaml
server:
host: "0.0.0.0"
port: 8080
timeout: 30
scan:
threads: 10
timeout: 5
retries: 3
Dieses Projekt ist unter der MIT-Lizenz lizenziert – siehe die Datei LICENSE für Details.
Beiträge sind willkommen! Bitte lesen Sie CONTRIBUTING.md für Richtlinien.
Dieses Tool ist nur für Bildungs- und autorisierte Sicherheitstests gedacht. Die Nutzer sind für die Einhaltung aller geltenden Gesetze und Vorschriften verantwortlich.```json { "config_id": "sample", "messages": [{ "role":"user", "content":"Hello! What can you do for me?" }] }
Beispielausgabe:```json
{"role": "assistant", "content": "Hi! How can I help you?"}
Um einen Guardrails-Server zu starten, 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 dann die LangChain-Pakete, die Ihre Konfiguration erfordert. Nachdem Sie die Integration aktiviert haben, können Sie eine Guardrails-Konfiguration um eine LangChain-Chain (oder ein beliebiges Runnable) legen und eine LangChain-Chain aus einer Guardrails-Konfiguration heraus aufrufen. Weitere Informationen finden Sie in der LangChain-Integrationsdokumentation.
Die Bewertung der Sicherheit einer LLM-basierten Konversationsanwendung ist eine komplexe Aufgabe und nach wie vor eine offene Forschungsfrage. Um eine ordnungsgemäße Evaluierung zu unterstützen, bietet die NeMo Guardrails-Bibliothek Folgendes:
nemoguardrails evaluate, mit Unterstützung für thematische Rails, Faktenprüfung, Moderation (Jailbreak- und Ausgabe-Moderation) und Halluzination.Es gibt viele Möglichkeiten, Guardrails zu einer LLM-basierten Konversationsanwendung hinzuzufügen. Zum Beispiel: explizite Moderationsendpunkte (z. B. OpenAI, ActiveFence, PolicyAI), Kritik-Ketten (z. B. Constitutional Chain), Parsen 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 sofort einsatzbereite Integration mit ActiveFence, PolicyAI, AlignScore und LangChain-Chains.
Nach unserem besten Wissen ist die NeMo Guardrails-Bibliothek das einzige Guardrails-Toolkit, das auch eine Lösung für die Modellierung des Dialogs zwischen dem Benutzer und dem LLM bietet. Dies ermöglicht einerseits die Fähigkeit, den Dialog auf präzise Weise zu lenken. Andererseits ermöglicht es eine feingranulare Steuerung, wann bestimmte Guardrails verwendet werden sollten, z. B. Faktenprüfung nur für bestimmte Arten von Fragen.
Die NVIDIA NeMo Guardrails-Bibliothek erfasst anonyme Telemetrie, 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 dann regelmäßige Heartbeats von einem einzelnen Daemon-Thread pro Prozess. Diese Telemetrie ist getrennt vom Tracing pro Anfrage. Sie konfigurieren Tracing in Ihrer Guardrails-Konfiguration und senden es an Ihr eigenes Observability-Backend. Telemetrie ist ein minimaler anonymer Ping an NVIDIA.
Aggregierte anonyme Nutzung über exakte 0.22.0- und 0.23.0-Release-Builds, 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, Completions, Token-Zahlen, Metriken pro Anfrage, Dateipfade, Benutzernamen oder IP-Adressen. NVIDIA verwendet die Daten in aggregierter Form, um die Engineering-Arbeit 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 den vollständigen NVIDIA-Telemetrie-Umschlag. Audit-Schreibvorgänge erfolgen nach bestem Bemühen, 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
Legen Sie das Opt-out fest, bevor die NVIDIA NeMo Guardrails-Bibliothek startet. Das Ändern von Umgebungsvariablen oder das Erstellen von `do_not_track`, nachdem die Telemetrie gestartet wurde, stoppt keinen bereits laufenden Heartbeat-Thread.
Weitere Informationen zum vollständigen Schema und zu den einzelnen Feldern finden Sie in [docs/telemetry.md](https://docs.nvidia.com/nemo/guardrails/latest/telemetry.html).
Sie können die Telemetrieerfassung jederzeit deaktivieren. Das Opt-out gilt nur für die Datenerfassung durch die NVIDIA NeMo Guardrails-Bibliothek selbst.
Endpunkte von Drittanbietern haben separate Bedingungen und Datenschutzpraktiken. Die NVIDIA NeMo Guardrails-Bibliothek kann Inferenz-Endpunkte wie NVIDIA Build (`build.nvidia.com`) verwenden. Wenn Sie NVIDIA Build oder einen anderen Endpunkt eines Drittanbieters verwenden, gelten die Nutzungsbedingungen und Datenschutzpraktiken dieses Endpunkts unabhängig von der Bibliothek. Ein etwaiges 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 verwendet werden. Übermitteln Sie keine vertraulichen Informationen oder personenbezogenen Daten bei der Verwendung von NVIDIA Build.
## Die Community zur Mitarbeit einladen
Die im Repository enthaltenen Beispiel-Rails sind hervorragende Ausgangspunkte. Wir laden die Community begeistert dazu ein, dazu beizutragen, die Kraft vertrauenswürdiger, sicherer und geschützter LLMs für alle zugänglich zu machen. Anleitungen zur Einrichtung einer Entwicklungsumgebung und dazu, wie Sie zur NeMo Guardrails-Bibliothek beitragen können, finden Sie in den [contributing guidelines](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.
## Zitierweise
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",
}