
Guardrail programmabili per app di chat LLM: applica vincoli di input/output, blocca jailbreak e prompt injection, rileva le allucinazioni e maschera i dati sensibili.
ULTIMA VERSIONE / VERSIONE DI SVILUPPO: Il ramo develop traccia l'ultimo sviluppo del ramo principale. L'ultima versione rilasciata è 0.23.0.
✨✨✨
📌 La documentazione ufficiale della libreria NeMo Guardrails è disponibile su docs.nvidia.com/nemo/guardrails.
✨✨✨
La libreria NVIDIA NeMo Guardrails è un toolkit open-source per aggiungere facilmente guardrail programmabili alle applicazioni conversazionali basate su LLM. I guardrail (o "rails" in breve) sono modi specifici per controllare l'output di un modello linguistico di grandi dimensioni, come non parlare di politica, rispondere in un modo particolare a richieste specifiche degli utenti, seguire un percorso di dialogo predefinito, usare uno stile linguistico particolare, estrarre dati strutturati e altro ancora.
Questo articolo introduce la libreria NeMo Guardrails e contiene una panoramica tecnica del sistema e della valutazione attuale.
Python 3.10, 3.11, 3.12 o 3.13.
Per installare usando pip:```bash
pip install nemoguardrails
Per istruzioni più dettagliate, consulta la [Guida all'installazione](https://docs.nvidia.com/nemo/guardrails/get-started/installation-guide).
## Panoramica
<!-- start-documentation-reuse -->
La libreria NeMo Guardrails consente agli sviluppatori che creano applicazioni basate su LLM di aggiungere **guardrail programmabili** tra il codice applicativo e l'LLM.
<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>
I principali vantaggi dell'aggiunta di *guardrail programmabili* includono:
- **Creare applicazioni basate su LLM affidabili, sicure e protette:** puoi definire guardrail per guidare e salvaguardare le conversazioni; puoi scegliere di definire il comportamento della tua applicazione basata su LLM su argomenti specifici e impedirle di intraprendere discussioni su argomenti indesiderati.
- **Connettere modelli, chain e altri servizi in modo sicuro:** puoi connettere un LLM ad altri servizi (detti anche strumenti) in modo fluido e sicuro.
- **Dialogo controllabile:** puoi guidare l'LLM a seguire percorsi conversazionali predefiniti, permettendoti di progettare l'interazione seguendo le migliori pratiche di progettazione conversazionale e di applicare procedure operative standard (ad esempio autenticazione, supporto).
<!-- end-documentation-reuse -->
### Protezione dalle vulnerabilità degli LLM
La libreria NeMo Guardrails offre diversi meccanismi per proteggere un'applicazione di chat basata su LLM dalle vulnerabilità comuni degli LLM, come i jailbreak e le injection di prompt. Di seguito è riportata una panoramica di esempio della protezione offerta dalle diverse configurazioni di guardrail per il [Bot ABC](https://github.com/nvidia-nemo/guardrails/blob/develop/examples/bots/abc) incluso in questo repository. Per maggiori dettagli, consulta la pagina [Scansione delle vulnerabilità degli 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>
### Casi d'uso
Puoi utilizzare i guardrail programmabili in diversi tipi di casi d'uso:
1. **Risposta a domande** su un insieme di documenti (nota anche come Retrieval Augmented Generation): applica il fact-checking e la moderazione dell'output.
2. **Assistenti specifici per dominio** (detti anche chatbot): garantisci che l'assistente rimanga sull'argomento e segua i flussi conversazionali progettati.
3. **Endpoint LLM**: aggiungi guardrail al tuo LLM personalizzato per un'interazione più sicura con i clienti.
4. **LangChain Chains** (opzionale): se utilizzi LangChain per qualsiasi caso d'uso, puoi aggiungere un livello di guardrail attorno alle tue chain. Per abilitare questa integrazione, imposta la variabile d'ambiente `NEMOGUARDRAILS_LLM_FRAMEWORK=langchain` oppure chiama `set_default_framework("langchain")`.
### Utilizzo
Per aggiungere guardrail programmabili alla tua applicazione puoi utilizzare l'API Python o un server di guardrail (vedi la [Guida al server](https://docs.nvidia.com/nemo/guardrails/get-started/integrate-into-application) per maggiori dettagli). Usare l'API Python è simile all'utilizzo diretto dell'LLM. Chiamare il livello di guardrail invece dell'LLM richiede solo modifiche minime al codice e prevede due semplici passaggi:
1. Caricare una configurazione di guardrail e creare un'istanza `LLMRails`.
2. Effettuare le chiamate all'LLM utilizzando i metodi `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!"}]
)
Esempio di output:```json {"role": "assistant", "content": "Hi! How can I help you?"}
Il formato di input e output per il metodo `generate` è simile alla [Chat Completions API](https://platform.openai.com/docs/guides/gpt/chat-completions-api) di OpenAI.
#### API asincrona
La libreria NeMo Guardrails è un toolkit basato sull'async: i meccanismi principali sono implementati usando il modello asincrono di Python. I metodi pubblici hanno sia una versione sincrona sia una asincrona. Ad esempio: `LLMRails.generate` e `LLMRails.generate_async`.
### LLM supportati
Puoi usare NeMo Guardrails con diversi LLM come OpenAI GPT-3.5, GPT-4, LLaMa-2, Falcon, Vicuna o Mosaic. Per maggiori dettagli, consulta la sezione [Modelli LLM supportati](https://docs.nvidia.com/nemo/guardrails/about-nemo-guardrails-library/supported-llms) nella Guida di configurazione.
### Tipi di guardrail
La libreria NeMo Guardrails supporta cinque tipi principali di guardrail:
<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**: applicati all'input dell'utente; un input rail può rifiutare l'input, interrompendo qualsiasi ulteriore elaborazione, oppure alterare l'input (ad es., per mascherare dati potenzialmente sensibili, per riformularlo).
2. **Dialog rails**: influenzano il modo in cui l'LLM viene interrogato; i dialog rails operano su messaggi in forma canonica (per i dettagli vedere [Guida Colang](https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang)) e determinano se un'azione deve essere eseguita, se l'LLM deve essere invocato per generare il passo successivo o una risposta, se invece deve essere utilizzata una risposta predefinita, ecc.
3. **Retrieval rails**: applicati ai chunk recuperati nel caso di uno scenario RAG (Retrieval Augmented Generation); un retrieval rail può rifiutare un chunk, impedendo che venga usato per il prompt dell'LLM, oppure alterare i chunk pertinenti (ad es., per mascherare dati potenzialmente sensibili).
4. **Execution rails**: applicati all'input/output delle azioni personalizzate (a.k.a. tools) che devono essere chiamate dall'LLM.
5. **Output rails**: applicati all'output generato dall'LLM; un output rail può rifiutare l'output, impedendo che venga restituito all'utente, oppure alterarlo (ad es., rimuovendo dati sensibili).
### Configurazione dei guardrails
Una configurazione dei guardrails definisce l'**LLM (o gli LLM)** da utilizzare e **uno o più guardrails**. Una configurazione dei guardrails può includere un qualsiasi numero di input/dialog/output/retrieval/execution rails. Una configurazione senza alcun rail configurato inoltrerà sostanzialmente le richieste all'LLM.
La struttura standard per una cartella di configurazione dei guardrails è la seguente:```
.
├── config
│ ├── actions.py
│ ├── config.py
│ ├── config.yml
│ ├── rails.co
│ ├── ...
Il config.yml contiene tutte le opzioni di configurazione generali, come i modelli LLM, i rails attivi e i dati di configurazione personalizzati". Il file config.py contiene qualsiasi codice di inizializzazione personalizzato e actions.py contiene qualsiasi azione Python personalizzata. Per una panoramica completa, consulta la Guida alla configurazione.
Di seguito è riportato un esempio di 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
I file `.co` inclusi in una configurazione di guardrails contengono le definizioni Colang (vedi la prossima sezione per una rapida panoramica su cos'è Colang) che definiscono vari tipi di rails. Di seguito è riportato un esempio di file `greeting.co` che definisce le rails di dialogo per salutare l'utente.```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?"
Di seguito è riportato un ulteriore esempio di definizioni Colang per un rail di dialogo contro gli insulti:```colang define user express insult "You are stupid"
define flow user express insult bot express calmly willingness to help
### Colang
Per configurare e implementare vari tipi di guardrail, questo toolkit introduce **Colang**, un linguaggio di modellazione creato specificamente per progettare flussi di dialogo flessibili, ma controllabili. Colang ha una sintassi simile a Python ed è progettato per essere semplice e intuitivo, soprattutto per gli sviluppatori.```{note}
Two versions of Colang, 1.0 and 2.0, are supported and Colang 1.0 is the default.
Per una breve introduzione alla sintassi di Colang 1.0, consulta la Guida alla sintassi del linguaggio Colang 1.0.
Per iniziare con Colang 2.0, consulta la Documentazione di Colang 2.0.
NeMo Guardrails include un set di guardrails integrati.```{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 libreria include guardrail per l'autoverifica degli LLM (moderazione di input/output, verifica dei fatti, rilevamento delle allucinazioni), modelli di sicurezza NVIDIA (sicurezza dei contenuti, sicurezza degli argomenti), rilevamento di jailbreak e injection, e integrazioni con modelli della community e API di terze parti. Per l'elenco completo, consulta la [documentazione della Guardrails Library](https://docs.nvidia.com/nemo/guardrails/user-guides/guardrails-library.html).
## CLI
La libreria NeMo Guardrails include anche una CLI integrata.```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.
Puoi utilizzare la CLI della libreria NeMo Guardrails per avviare un server guardrails. Il server può caricare una o più configurazioni dalla cartella specificata ed esporre un'API HTTP per utilizzarle.``` nemoguardrails server [--config PATH/TO/CONFIGS] [--port PORT]
Ad esempio, per ottenere una chat completion per una config `sample`, puoi utilizzare l'endpoint `/v1/chat/completions`:```
POST /v1/chat/completions
Il contenuto da tradurre non è stato fornito: il campo INPUT è vuoto.```json { "config_id": "sample", "messages": [{ "role":"user", "content":"Hello! What can you do for me?" }] }
Output di esempio:```json
{"role": "assistant", "content": "Hi! How can I help you?"}
Per avviare un server guardrails, puoi utilizzare anche un contenitore Docker. La libreria NeMo Guardrails fornisce un Dockerfile che puoi usare per creare un'immagine nemoguardrails. Per ulteriori informazioni, consulta la sezione uso di Docker.
L'integrazione con LangChain è opzionale. Per abilitarla, imposta la variabile d'ambiente NEMOGUARDRAILS_LLM_FRAMEWORK=langchain oppure chiama set_default_framework("langchain"). Quindi installa i pacchetti LangChain richiesti dalla tua configurazione. Dopo aver abilitato l'integrazione, puoi avvolgere una configurazione guardrails attorno a una chain LangChain (o qualsiasi Runnable) e puoi chiamare una chain LangChain dall'interno di una configurazione guardrails. Per maggiori informazioni, fai riferimento alla Documentazione sull'integrazione con LangChain.
Valutare la sicurezza di un'applicazione conversazionale basata su LLM è un compito complesso e ancora una questione di ricerca aperta. Per supportare una valutazione adeguata, la libreria NeMo Guardrails fornisce quanto segue:
nemoguardrails evaluate, con supporto per rail tematici, fact-checking, moderazione (jailbreak e moderazione dell'output) e allucinazioni.Ci sono molti modi per aggiungere guardrails a un'applicazione conversazionale basata su LLM. Ad esempio: endpoint di moderazione espliciti (ad es. OpenAI, ActiveFence, PolicyAI), chain di critica (ad es. constitutional chain), parsing dell'output (ad es. guardrails.ai), guardrails individuali (ad es. LLM-Guard), rilevamento delle allucinazioni per applicazioni RAG (ad es. Got It AI, Patronus Lynx).
La libreria NeMo Guardrails mira a fornire un toolkit flessibile che possa integrare tutti questi approcci complementari in un livello guardrails LLM coeso. Ad esempio, il toolkit fornisce un'integrazione pronta all'uso con ActiveFence, PolicyAI, AlignScore e chain LangChain.
Per quanto ne sappiamo, la libreria NeMo Guardrails è l'unico toolkit guardrails che offre anche una soluzione per modellare il dialogo tra l'utente e l'LLM. Questo consente da un lato di guidare il dialogo in modo preciso. Dall'altro lato consente un controllo granulare su quando devono essere utilizzati determinati guardrails, ad esempio, usare il fact-checking solo per alcuni tipi di domande.
La libreria NVIDIA NeMo Guardrails raccoglie telemetria anonima per aiutare NVIDIA a capire quali modelli di distribuzione e funzionalità di sicurezza sono più utilizzati. La libreria emette un evento di utilizzo quando istanzi LLMRails, IORails o Guardrails, quindi emette heartbeat periodici da un singolo thread daemon per processo. Questa telemetria è separata dal tracing per richiesta. Configuri il tracing nella tua configurazione guardrails e lo invii al tuo backend di osservabilità. La telemetria è un ping anonimo minimale a NVIDIA.
Utilizzo anonimo aggregato nelle versioni di rilascio esatte 0.22.0 e 0.23.0, dal 22 maggio al 18 agosto 2026:



Ultimo aggiornamento: 18 agosto 2026
La telemetria include:
openai, nim o nvidia_ai_endpoints, mai nomi di modelli o credenzialijailbreak_detection, content_safety o topic_safetylibrary, api o cli)LLMRails o IORails)Nessun contenuto utente viene raccolto nel payload dell'evento. Il payload non include nomi di modelli, chiavi API, endpoint, prompt, completamenti, conteggi di token, metriche per richiesta, percorsi di file, nomi utente o indirizzi IP. NVIDIA utilizza i dati in forma aggregata per dare priorità al lavoro di ingegneria e condividerà le tendenze di adozione con la community.
La libreria tenta inoltre di scrivere ogni payload di evento in un file di audit locale in ~/.config/nemoguardrails/usage_stats.json. Il file di audit memorizza il JSONL degli eventi, non l'intero involucro di telemetria NVIDIA. Le scritture di audit sono a migliore sforzo e la trasmissione della telemetria prosegue anche se la scrittura dell'audit locale fallisce.
Imposta una qualsiasi delle seguenti opzioni per disabilitare la telemetria:```bash export NEMO_GUARDRAILS_NO_USAGE_STATS=1
export DO_NOT_TRACK=1
mkdir -p ~/.config/nemoguardrails && touch ~/.config/nemoguardrails/do_not_track
Imposta l'opt-out prima che la libreria NVIDIA NeMo Guardrails venga avviata. Modificare le variabili d'ambiente o creare `do_not_track` dopo che la telemetria è stata avviata non ferma un thread di heartbeat già in esecuzione.
Fai riferimento a [docs/telemetry.md](https://docs.nvidia.com/nemo/guardrails/latest/telemetry.html) per lo schema completo e le descrizioni campo per campo.
Puoi rinunciare alla raccolta di telemetria in qualsiasi momento. La rinuncia si applica solo alla raccolta di dati da parte della libreria NVIDIA NeMo Guardrails stessa.
Gli endpoint di terze parti hanno termini e pratiche sulla privacy separati. La libreria NVIDIA NeMo Guardrails può utilizzare endpoint di inferenza come NVIDIA Build (`build.nvidia.com`). Se utilizzi NVIDIA Build o un altro endpoint di terze parti, i termini di servizio e le pratiche sulla privacy di tale endpoint si applicano indipendentemente dalla libreria. Qualsiasi opt-out della telemetria nella libreria NVIDIA NeMo Guardrails non si estende all'endpoint che scegli. NVIDIA Build è destinato esclusivamente alla valutazione e ai test e non deve essere utilizzato in ambienti di produzione. Non inviare informazioni riservate o dati personali quando utilizzi NVIDIA Build.
## Invitare la community a contribuire
Le rails di esempio presenti nel repository sono ottimi punti di partenza. Invitiamo con entusiasmo la community a contribuire per rendere accessibile a tutti la potenza di LLM affidabili, sicuri e protetti. Per indicazioni su come configurare un ambiente di sviluppo e su come contribuire alla libreria NeMo Guardrails, consulta le [linee guida per i contributi](https://github.com/nvidia-nemo/guardrails/blob/develop/CONTRIBUTING.md).
## Licenza
La libreria NeMo Guardrails è concessa in licenza secondo i termini della [Apache License, Version 2.0](http://www.apache.org/licenses/LICENSE-2.0).
## Come citare
Se utilizzi la libreria NeMo Guardrails, cita il [paper EMNLP 2023](https://aclanthology.org/2023.emnlp-demo.40) che la introduce.```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",
}