Multi-Rail Configuration Example

colang_version: 2.x

models:
  # Main conversation model
  - type: main
    engine: nim
    model: meta/llama-3.3-70b-instruct
  
  # Content safety model
  - type: content_safety
    engine: nim
    model: nvidia/llama-3.1-nemoguard-8b-content-safety
  
  # Topic control model
  - type: topic_control
    engine: nim
    model: nvidia/llama-3.1-nemoguard-8b-topic-control

# Jailbreak detection configuration
rails:
  config:
    jailbreak_detection:
      nim_base_url: "https://ai.api.nvidia.com"
      nim_server_endpoint: "/v1/security/nvidia/nemoguard-jailbreak-detect"
      api_key_env_var: NVIDIA_API_KEY
    
    fact_checking:
      enabled: true
      parameters:
        threshold: 0.5

import guardrails
import nemoguardrails.library.content_safety
import nemoguardrails.library.topic_safety
import nemoguardrails.library.jailbreak_detection

flow input rails $input_text
    # Layer 1: Content safety check
    content safety check input $model="content_safety"
    
    # Layer 2: Topic control check
    topic safety check input $model="topic_control"
    
    # Layer 3: Jailbreak detection
    jailbreak detection model
    
    # Layer 4: Custom PII detection
    check for pii $input_text

flow check for pii $text
  $has_pii = execute detect_pii(text=$text)
  
  if $has_pii
    bot say "Please don't share personal information like emails, phone numbers, or SSN."
    abort

flow output rails $output_text
    # Layer 1: Content safety check
    content safety check output $model="content_safety"
    
    # Layer 2: Fact checking (if RAG was used)
    check facts if needed
    
    # Layer 3: Hallucination detection
    check hallucinations if needed
    
    # Layer 4: Sensitive data masking
    mask sensitive output

flow check facts if needed
  if $check_facts == True
    $check_facts = False
    $accuracy = execute check_facts
    
    if $accuracy < 0.4
      bot inform answer unknown
      stop
    
    if $accuracy < 0.6
      $bot_message_potentially_inaccurate = True

flow check hallucinations if needed
  if $check_hallucination == True
    $check_hallucination = False
    $is_hallucinating = execute check_hallucination
    
    if $is_hallucinating
      bot inform answer unknown
      stop

flow mask sensitive output
  $output_text = execute mask_sensitive_data(text=$output_text)

define user ask about allowed topic
  "What are the company benefits?"
  "How do I request time off?"
  "What's the dress code?"

define user ask about disallowed topic
  "How do I cook pasta?"
  "What stocks should I buy?"
  "Tell me about politics"

define bot refuse off topic
  "I'm here to help with company-related questions. I can't assist with that topic."

define flow off topic handling
  user ask about disallowed topic
  bot refuse off topic

prompts:
  # Content safety prompt
  - task: content_safety_check
    content: |-
      You are a content safety classifier. Determine if the content is safe.
      
      Unsafe categories:
      - Violence, threats, hate speech
      - Sexual or explicit content
      - Self-harm or suicide
      - Illegal activities
      - Personal attacks or harassment
      
      Content: {{ content }}
      
      Classification: safe/unsafe
      Reason: [brief explanation]

  # Topic control prompt  
  - task: topic_control_check
    content: |-
      Determine if the query is about allowed topics.
      
      Allowed topics:
      - Company policies and procedures
      - Employee benefits and compensation
      - HR and workplace questions
      - IT and technical support
      
      Query: {{ query }}
      
      On topic: yes/no

  # Fact checking prompt
  - task: self_check_facts
    content: |-
      You are given a task to identify if the hypothesis is grounded and entailed to the evidence.
      You will only use the contents of the evidence and not rely on external knowledge.
      
      Evidence: {{ evidence }}
      Hypothesis: {{ response }}
      
      Is the hypothesis entailed by the evidence? yes/no

  # Hallucination detection prompt
  - task: self_check_hallucinations
    content: |-
      You are given a task to identify if the hypothesis is in agreement with the context.
      You will only use the contents of the context and not rely on external knowledge.
      
      Context: {{ paragraph }}
      Hypothesis: {{ statement }}
      
      Is there agreement? yes/no

from nemoguardrails import LLMRails
from nemoguardrails.actions.actions import ActionResult
import re

async def detect_pii(context: dict, text: str) -> ActionResult:
    """Detect personally identifiable information."""
    patterns = {
        'email': r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
        'phone': r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
        'ssn': r'\b\d{3}-\d{2}-\d{4}\b',
        'credit_card': r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b'
    }
    
    for pii_type, pattern in patterns.items():
        if re.search(pattern, text):
            return ActionResult(
                return_value=True,
                context_updates={"pii_type": pii_type}
            )
    
    return ActionResult(return_value=False)

async def mask_sensitive_data(context: dict, text: str) -> ActionResult:
    """Mask sensitive information in output."""
    # Mask credit cards
    text = re.sub(
        r'\b\d{4}[\s-]?\d{4}[\s-]?\d{4}[\s-]?\d{4}\b',
        '****-****-****-****',
        text
    )
    
    # Mask emails
    text = re.sub(
        r'\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b',
        '[EMAIL_REDACTED]',
        text
    )
    
    # Mask phone numbers
    text = re.sub(
        r'\b\d{3}[-.]?\d{3}[-.]?\d{4}\b',
        '***-***-****',
        text
    )
    
    return ActionResult(return_value=text)

def init(app: LLMRails):
    app.register_action(detect_pii, "detect_pii")
    app.register_action(mask_sensitive_data, "mask_sensitive_data")