> This page is for version v0.25.0.
> For other versions, use one of these documentation indexes:
> - Latest (default): https://docs.nvidia.com/nemo/guardrails/latest/llms.txt
> - v0.25.0: https://docs.nvidia.com/nemo/guardrails/v0.25.0/llms.txt
> - v0.24.1: https://docs.nvidia.com/nemo/guardrails/v0.24.1/llms.txt
> - v0.24.0: https://docs.nvidia.com/nemo/guardrails/v0.24.0/llms.txt
> - v0.23.0: https://docs.nvidia.com/nemo/guardrails/v0.23.0/llms.txt
> - v0.22.0: https://docs.nvidia.com/nemo/guardrails/v0.22.0/llms.txt

> For clean Markdown of any page, append .md to the page URL.
> For a complete documentation index, see https://docs.nvidia.com/nemo/guardrails/llms.txt.

# Custom Policy with Nemotron 3.5 Content Safety NIM

> Restrict conversations to allowed topics using a custom policy with Nemotron 3.5 Content Safety NIM.

Learn how to restrict conversations to allowed topics using a custom policy with [Nemotron 3.5 Content Safety](https://build.nvidia.com/nvidia/nemotron-3.5-content-safety).

A custom policy lets you define your own safety rules for a specific use case, for example limiting a customer service bot to company-related topics. The Nemotron 3.5 Content Safety NIM supports two mutually exclusive custom-field modes: `custom_policy` (Mode A) accepts free-text behavioral instructions and replaces the built-in safety behavior entirely; `custom_taxonomy` (Mode B) accepts a structured list of harm categories that replaces the built-in 24-category taxonomy. This tutorial uses `custom_policy`. To apply both the built-in taxonomy and a custom policy simultaneously, use two separate model entries in `config.yml`: one with `request_categories: "/categories"` for the built-in taxonomy and one with `custom_policy` for your rules.

By following this tutorial, you learn how to configure a custom policy and interact with both on-topic and off-topic requests.

## Prerequisites

* The NVIDIA NeMo Guardrails library [installed](/nemo/guardrails/v0.25.0/get-started/installation-guide).
* A personal NVIDIA API key generated on [build.nvidia.com](https://build.nvidia.com/).

## Configure Guardrails

1. Create a configuration directory.

   ```console
   mkdir config
   ```

2. Save the following as `config/config.yml`.

   ```yaml
   models:
     - type: main
       engine: nim
       model: nvidia/nemotron-3.5-lightning-30b-a3b

     - type: content_safety
       engine: nim
       model: nvidia/nemotron-3.5-content-safety
       parameters:
         chat_template_kwargs:
           enable_thinking: false
           request_categories: "/categories"
           custom_policy: |
             You are to act as a customer service agent, providing users with factual information in accordance with the knowledge base. Your role is to ensure that you respond only to relevant queries and adhere to the following guidelines:
             - Do not answer questions related to personal opinions or advice on a user's order or future recommendations.
             - Do not provide any information on non-company products or services.
             - Do not answer enquiries unrelated to the company policies.
             - Do not answer questions asking for personal details about the agent or its creators.
             - Do not answer questions about sensitive topics related to politics, religion, or other sensitive subjects.
             - If a user asks about topics irrelevant to the company's customer service, politely redirect the conversation or end the interaction.
             - Allow user comments that are related to small talk and chit-chat.

   rails:
     input:
       flows:
         - content safety check input $model=content_safety
   ```

   The `custom_policy` field is passed to the model's chat template as free-text behavioral instructions (Mode A). The model applies your policy and returns `User Safety: safe` or `User Safety: unsafe`. Topic control only operates on user input, so there is no output rail flow.

   For more information about guardrail configurations, refer to [Configure Rails](/nemo/guardrails/v0.25.0/configure-guardrails/overview).

3. Save the following as `config/prompts.yml`.

   ```yaml
   prompts:
     - task: content_safety_check_input $model=content_safety
       messages:
         - type: user
           content: "{{ user_input }}"
       output_parser: nemotron_content_safety_parse_prompt_safety
       max_tokens: 100
       max_length: 128000
   ```

   Nemotron 3.5 Content Safety builds the full safety prompt server-side, including your `custom_policy`. The `prompts.yml` passes only the user turn to classify. The `nemotron_content_safety_parse_prompt_safety` output parser reads the `User Safety: safe/unsafe` verdict line.

## Run the Guardrails Chat Application

1. Set the NVIDIA_API_KEY environment variable.

   ```console
   $ export NVIDIA_API_KEY="..."
   ```

2. Run the interactive chat application.

   ```console
   $ nemoguardrails chat --config config
   Starting the chat (Press Ctrl + C twice to quit) ...

   > _
   ```

3. Enter an off-topic request.

   The custom policy prohibits questions about politics. The content safety input rail detects a policy violation and returns the refusal text. The main model is never called.

   ```console
   > Which party should I vote for in the next election?
   I'm sorry, I can't respond to that.
   ```

4. Enter an on-topic request.

   This request is within the allowed topics, so the content safety rail passes it through to the main model.

   ```console
   > I'd like to cancel my subscription. Can I do this by phone or on the website?
   I'd be happy to help you with canceling your subscription. You have a couple of options to do so...

   [The NeMo Guardrails library responds with instructions and information on subscription cancellations]
   ```

## Import the NeMo Guardrails Library in Python

1. Install the IPython REPL and run it.

   ```console
   $ pip install ipython
   $ ipython

   In [1]:
   ```

2. Load the guardrails configuration you created earlier.

   ```python
   import asyncio
   from nemoguardrails import LLMRails, RailsConfig

   config = RailsConfig.from_path("./config")
   rails = LLMRails(config)
   ```

3. Verify the guardrails with an off-topic political question.

   ```python
   messages = [{"role": "user", "content": "Which party should I vote for in the next election?"}]
   response = await rails.generate_async(messages=messages)
   print(response['content'])
   ```

   The content safety rail blocks the request.

   ```output
   I'm sorry, I can't respond to that.
   ```

4. Verify the guardrails with an on-topic question.

   ```python
   messages = [{"role": "user", "content": "I'd like to cancel my subscription. Can I do this by phone or on the website?"}]
   response = await rails.generate_async(messages=messages)
   print(response['content'])
   ```

   The model responds with advice on how to cancel a subscription by phone or website.

## Deploy Nemotron 3.5 Content Safety NIM Locally

This section shows how to run the Nemotron 3.5 Content Safety model locally while still using the build.nvidia.com hosted main model. The prerequisites are:

* The NeMo Guardrails library [installed](/nemo/guardrails/v0.25.0/get-started/installation-guide).
* A personal NVIDIA NGC API key with NVIDIA NGC Catalog and NVIDIA Public API Endpoints services access.
  For more information, refer to [NGC API Keys](https://docs.nvidia.com/ngc/latest/ngc-user-guide.html#ngc-api-keys) in the NVIDIA GPU cloud documentation.
* Docker [installed](https://docs.docker.com/engine/install/).
* NVIDIA Container Toolkit [installed](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/install-guide.html).
* GPUs meeting the memory requirements for the [Nemotron 3.5 Content Safety NIM](https://catalog.ngc.nvidia.com/orgs/nim/nvidia/containers/nemotron-3.5-content-safety).

To run the Nemotron 3.5 Content Safety NIM in a Docker container, follow these steps:

1. Update the `config.yml` file to point to a local NIM deployment. Add a `base_url` field under `parameters`:

   ```yaml
   models:
     - type: main
       engine: nim
       model: nvidia/nemotron-3.5-lightning-30b-a3b

     - type: content_safety
       engine: nim
       model: nvidia/nemotron-3.5-content-safety
       parameters:
         base_url: "http://localhost:8123/v1"
         chat_template_kwargs:
           enable_thinking: false
           request_categories: "/categories"
           custom_policy: |
             You are to act as a customer service agent, providing users with factual information in accordance with the knowledge base. Your role is to ensure that you respond only to relevant queries and adhere to the following guidelines:
             - Do not answer questions related to personal opinions or advice on a user's order or future recommendations.
             - Do not provide any information on non-company products or services.
             - Do not answer enquiries unrelated to the company policies.
             - Do not answer questions asking for personal details about the agent or its creators.
             - Do not answer questions about sensitive topics related to politics, religion, or other sensitive subjects.
             - If a user asks about topics irrelevant to the company's customer service, politely redirect the conversation or end the interaction.
             - Allow user comments that are related to small talk and chit-chat.

   rails:
     input:
       flows:
         - content safety check input $model=content_safety
   ```

2. Start the Nemotron 3.5 Content Safety NIM Docker container.

   1. Export your personal NGC API key to an environment variable.

      ```console
      $ export NGC_API_KEY="..."
      ```

      Log in to the NGC registry.

      ```console
      $ docker login nvcr.io --username '$oauthtoken' --password-stdin <<< $NGC_API_KEY
      ```

   2. Download the container.

      ```console
      $ docker pull nvcr.io/nim/nvidia/nemotron-3.5-content-safety:latest
      ```

   3. Create a model cache directory on the host machine.

      ```console
      $ export LOCAL_NIM_CACHE=~/.cache/nim
      $ mkdir -p "${LOCAL_NIM_CACHE}"
      $ chmod 700 "${LOCAL_NIM_CACHE}"
      ```

   4. Run the container with the cache directory mounted.

      The `-p` argument maps the Docker container port 8000 to 8123 to avoid conflicts with other servers running locally.

      ```console
      $ docker run -d \
        --name nemotron-content-safety \
        --gpus=all --runtime=nvidia \
        --shm-size=64GB \
        -e NGC_API_KEY \
        -u $(id -u) \
        -v "${LOCAL_NIM_CACHE}:/opt/nim/.cache/" \
        -p 8123:8000 \
        nvcr.io/nim/nvidia/nemotron-3.5-content-safety:latest
      ```

      The container requires several minutes to start and download the model from NGC. Monitor progress with `docker logs nemotron-content-safety`.

   5. Confirm the service is ready.

      ```console
      $ curl -X GET http://localhost:8123/v1/models | jq '.data[].id'
      ```

      This returns the following response.

      ```console
      "nvidia/nemotron-3.5-content-safety"
      ```

3. Follow the steps in [Run the Guardrails Chat Application](#run-the-guardrails-chat-application) and [Import the NeMo Guardrails Library in Python](#import-the-nemo-guardrails-library-in-python) to run Guardrails with the local model.

## Next Steps

* [Nemotron 3.5 Content Safety NIM on NGC](https://catalog.ngc.nvidia.com/orgs/nim/nvidia/containers/nemotron-3.5-content-safety)
* [Content Safety guardrail catalog page](/nemo/guardrails/v0.25.0/configure-guardrails/guardrail-catalog/content-safety)
* [Check Harmful Content with Nemotron Content Safety NIM](/nemo/guardrails/v0.25.0/get-started/tutorials/nemotron-safety-guard-deployment)
* [NeMo Guardrails Library Configuration Guide](/nemo/guardrails/v0.25.0/configure-guardrails/overview)