Skip to content
KitploitKITPLOIT
StrumentiBlog
Invia
StrumentiBlog
Invia

Strumenti di Hacking, PenTest e Cybersecurity per il tuo Arsenale di Sicurezza!

Kitploit è una directory di strumenti di hacking, cybersecurity e pentesting. Scopri gli ultimi aggiornamenti dei progetti per trovare vulnerabilità, analizzare sistemi, automatizzare i test e rafforzare la tua sicurezza.

··Feed·Contatto·Privacy·© 2026 Kitploit

Directory degli strumenti

Categorie

Vedi tutte le categorie
Loading categories
Guardrails — 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. | Kitploit
Strumenti/GitHubGitHub/nvidia-nemo/guardrails
Strumenti DifensiviAnalisi delle VulnerabilitàPrivacyMachine LearningSicurezza dell'IARilevamento di AnomalieTop in Sicurezza dell'IA n.10
GitHubnvidia-nemo/guardrails

Guardrails

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.

7.1k832472 giorni faRevisionato da Kitploit

Più Popolari

Vedi tutti →

Scopri gli strumenti più utilizzati dalla nostra community.

Esplora tutti gli strumenti

Sfoglia la nostra collezione di strumenti

Vedi tutti gli strumenti →
Vedi RepositorySito web
Condividi

Libreria NVIDIA NeMo Guardrails

License PyPI PyPI - Python Version Tests/Linux Tests/Windows Tests/macOS Lint

Code style: black
Documentation
arXiv
Downloads
Downloads

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.

Requisiti

Python 3.10, 3.11, 3.12 o 3.13.

Installazione

Per installare usando pip:```bash

pip install nemoguardrails

root@kitploit:~
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?"}

root@kitploit:~
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

config.yml

models:

  • type: main engine: openai model: gpt-3.5-turbo-instruct

rails:

Input rails are invoked when new input from the user is received.

input: flows: - check jailbreak - mask sensitive data on input

Output rails are triggered after a bot message has been generated.

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

root@kitploit:~
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

root@kitploit:~
### 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.

Libreria di Guardrails

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.

root@kitploit:~
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.

Server Guardrails

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]

root@kitploit:~
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?" }] }

root@kitploit:~
Output di esempio:```json
{"role": "assistant", "content": "Hi! How can I help you?"}

Docker

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.

Integrazione con LangChain (Opzionale)

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.

Valutazione

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:

  1. Un strumento di valutazione, ad esempio nemoguardrails evaluate, con supporto per rail tematici, fact-checking, moderazione (jailbreak e moderazione dell'output) e allucinazioni.
  2. Report di esempio sulla scansione delle vulnerabilità degli LLM, ad esempio ABC Bot - Risultati della scansione delle vulnerabilità LLM

In cosa differisce?

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.

Per saperne di più

  • Documentazione
  • Guida per iniziare
  • Esempi
  • FAQ
  • Linee guida sulla sicurezza

Telemetria e privacy

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.

Snapshot dell'utilizzo della community

Utilizzo anonimo aggregato nelle versioni di rilascio esatte 0.22.0 e 0.23.0, dal 22 maggio al 18 agosto 2026:

Sessioni per tipo di rail

Sessioni per funzionalità integrata

Rail configurati all'avvio

Ultimo aggiornamento: 18 agosto 2026

La telemetria include:

  • Versione della libreria installata, versione di Python, sistema operativo e stringa della piattaforma
  • Versione del linguaggio di configurazione Colang (1.0 o 2.x)
  • Nomi dei provider del motore LLM configurati, come openai, nim o nvidia_ai_endpoints, mai nomi di modelli o credenziali
  • Conteggi dei flussi rail configurati per rail di input, output, retrieval, input degli strumenti e output degli strumenti, più quali categorie di rail sono attive
  • Nomi delle funzionalità integrate della libreria che sono attive, come jailbreak_detection, content_safety o topic_safety
  • Numero di flussi Colang definiti dall'utente (solo il conteggio, mai nomi o contenuti dei flussi)
  • Se il tracing, lo streaming o una knowledge base è configurato
  • Come hai distribuito i guardrails (server library, api o cli)
  • Quale motore di runtime rail è in uso (LLMRails o IORails)
  • Un UUID casuale per processo per correlare gli eventi della stessa istanza. La libreria lo genera in memoria e non lo memorizza per il riutilizzo tra riavvii, ma lo include nei record di audit e negli eventi di telemetria trasmessi

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

or

export DO_NOT_TRACK=1

or

mkdir -p ~/.config/nemoguardrails && touch ~/.config/nemoguardrails/do_not_track

root@kitploit:~
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",
}
Scarica lo strumento