Overview

Content safety guardrails help ensure that both user inputs and LLM outputs are safe and appropriate. The NeMo Guardrails library provides multiple approaches to content safety:

• LLM self-checking: Use the LLM itself to check inputs and outputs for harmful content.
• NVIDIA safety models: Integrate with Llama 3.1 NemoGuard 8B Content Safety for robust content moderation.
• Community models: Use LlamaGuard, Fiddler Guardrails, and other community content safety solutions.
• Third-party APIs: Integrate with ActiveFence, Cisco AI Defense, and other moderation services.

For practical examples, try the following tutorials:

• Content Safety - Text
• Content Safety - Multimodal

Jailbreak protection helps prevent adversarial attempts from bypassing safety measures and manipulating the LLM into generating harmful or unwanted content. The NeMo Guardrails library provides multiple layers of jailbreak protection:

• Self-check jailbreak detection: Use the LLM to identify jailbreak attempts.
• Heuristic detection: Use pattern-based detection for common jailbreak techniques.
• NVIDIA NemoGuard: Integrate with NemoGuard Jailbreak Detection NIM for advanced threat detection.
• Third-party integrations: Use Prompt Security, Pangea AI Guard, and other services.

For practical examples, try the following tutorial:

• Detect Jailbreak Attempts

Topic control guardrails ensure that conversations stay within predefined subject boundaries and prevent the LLM from engaging in off-topic discussions. This is implemented through:

• Dialog rails: Pre-define conversational flows using the Colang language.
• Topical rails: Control what topics the bot can and cannot discuss.
• NVIDIA NemoGuard: Integrate with NemoGuard Topic Control NIM for semantic topic detection.

For practical examples, try the following tutorial:

• Restrict Topics

Personally Identifiable Information (PII) detection helps protect user privacy by detecting and masking sensitive data in user inputs, LLM outputs, and retrieved content. The NeMo Guardrails library supports PII detection through multiple integrations:

• Gliner: Use NVIDIA GLiNER-PII for detecting entities such as names, email addresses, phone numbers, social security numbers, and more.
• Presidio-based detection: Use Microsoft Presidio for detecting entities such as names, email addresses, phone numbers, social security numbers, and more.
• Private AI: Integrate with Private AI for advanced PII detection and masking.
• Polygraf: Integrate with Polygraf for advanced PII detection and masking.
• AutoAlign: Use AutoAlign PII detection with customizable entity types.
• GuardrailsAI: Access GuardrailsAI PII validators from the Guardrails Hub.

PII detection can be configured to either detect and block content containing PII or to mask PII entities before processing.

For more information, refer to the Presidio Integration and PII Detection in the Guardrail Catalog.

Agentic security provides specialized guardrails for LLM-based agents that use tools and interact with external systems. This includes:

• Tool call validation: Execute rails that validate tool inputs and outputs before and after invocation.
• Agent workflow protection: Integrate with LangGraph for multi-agent safety. Requires the LangChain opt-in (NEMOGUARDRAILS_LLM_FRAMEWORK=langchain) and the matching langchain-* packages.
• Secure tool integration: Review guidelines for safely connecting LLMs to external resources (refer to Security Guidelines).
• Action monitoring: Monitor detailed logging and tracing of agent actions.

Key security considerations for agent systems:

1. Isolate all authentication information from the LLM.
2. Validate and sanitize all tool inputs.
3. Apply execution rails to tool calls.
4. Monitor agent behavior for unexpected actions.

For more information, refer to the Tools Integration Guide, Security Guidelines, and LangGraph Integration.

The NeMo Guardrails library provides extensive flexibility for creating custom guardrails tailored to your specific requirements. You can either build your own guardrails or use third-party guardrails. If you have a script or tool that runs a custom guardrail, you can use it in NeMo Guardrails by following one of these approaches:

1. Python actions: Create custom actions in Python for complex logic and external integrations. For more information, refer to the Custom Actions.

2. LangChain tool integration: Register LangChain tools as custom actions. Requires the LangChain framework. For more information, refer to the Tools Integration.

3. Third-party API integration: Integrate external moderation and validation services. For a complete list of supported third-party guardrail services, refer to Third-Party APIs in the Guardrail Catalog.

You can integrate the NeMo Guardrails library into your application using the tools provided by the library.

1. Python SDK: Use the Python SDK to add guardrails directly into your Python application.

   1
   from nemoguardrails import LLMRails, RailsConfig
   2
   3
   config = RailsConfig.from_path("./config")
   4
   rails = LLMRails(config)
   5
   6
   response = rails.generate(
   7
       messages=[{"role": "user", "content": "Hello!"}]
   8
   )

   The generate method accepts the same message format as the OpenAI Chat Completions API.

2. API Server: You can solely set up a guardrails server after programming guardrails using the Python SDK. You can then start a local NeMo Guardrails server with the following command.

   $
   nemoguardrails server --config ./config --port 8000

   The server exposes API endpoints such as /v1/chat/completions for guardrailed chat completions.

   $
   curl -X POST http://localhost:8000/v1/chat/completions \
   >
     -H "Content-Type: application/json" \
   >
     -d '{
   >
       "config_id": "my-config",
   >
       "messages": [{"role": "user", "content": "Hello!"}]
   >
     }'