> 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.
> For AI client integration (Claude Code, Cursor, etc.), connect to the MCP server at https://docs.nvidia.com/nemo/guardrails/_mcp/server.

# Use the NVIDIA NeMo Guardrails Library with Your AI Agent

> Connect an AI coding agent to the NVIDIA NeMo Guardrails library documentation and starter prompt.

Use an AI coding agent to help you install, configure, evaluate, debug, or deploy the NVIDIA NeMo Guardrails library.

The easiest path is to connect your agent to the documentation MCP server.
If your agent does not support MCP, copy the starter prompt and paste it into your agent chat.

## Copy the Starter Prompt

Copy this prompt and paste it into your AI coding agent, such as Cursor, Claude Code, Codex, or another agent.
The prompt tells the agent how to find the Markdown documentation, align docs to your installed package version, and avoid asking for secrets in chat.

#### Copy Starter Prompt

# NVIDIA NeMo Guardrails Library Agent Instructions

You are helping me get started with the NVIDIA NeMo Guardrails library from this AI coding agent.
Assume I may not have installed the Python package yet and may not have cloned the GitHub repository, so local `.agents/skills/` and `AGENTS.md` files might not exist.

## How to Help Me

* Help me install, add, configure, evaluate, debug, or deploy guardrails for an LLM application.
* Use the official NVIDIA NeMo Guardrails library documentation as the source of truth.
* Prefer the docs MCP server if this agent supports MCP.
* Otherwise, use the documentation index at `https://docs.nvidia.com/nemo/guardrails/llms.txt`, then fetch the clean Markdown form of the relevant page by using the page URL with `.md`.
* Use Markdown documentation under `https://docs.nvidia.com/nemo/guardrails/` when loading information for agent context. When presenting references or citations to me, use the canonical human-readable docs links without `.md`.
* If a full Markdown documentation bundle is available, use it only when you need broad cross-page context.
* Do not hardcode staging documentation URLs unless I explicitly ask you to use staging.
* Before using installation or tutorial instructions, select the package and documentation version as described in the Developer Path.
* If I am working from a cloned repository, you may also use local `docs/**/*.mdx`, `README.md`, `CONTRIBUTING.md`, and `AGENTS.md` files as context.

## Identify My Role First

Before giving install or usage instructions, ask who I am:

1. Developer using the NVIDIA NeMo Guardrails library in an application.
2. Contributor changing the Guardrails repository.

If I choose developer, follow the Developer Path.
If I choose contributor, follow the Contributor Path.

## Developer Path

Before loading installation or tutorial documentation, select the package and documentation version:

1. Check whether `nemoguardrails` is already installed. If it is installed, determine its version.
2. Discover the currently available stable package releases and published documentation versions from official sources. Do not rely on a version list hardcoded in this prompt.
3. If the installed version has matching documentation, recommend that documentation version and ask whether to keep the installed package, upgrade it, or install a different version.
4. If the package is not installed, ask which version I want to install. Present the available versions as a numbered list with actual version numbers, newest first. Mark the most recent stable release as "Recommended for first-time installation," include each older release that has published documentation, and add a final option to specify a different version.
5. If I am installing the library for the first time and have no compatibility requirement, recommend the most recent stable release, but wait for my selection before installing it.
6. If I need a specific version for an existing application, environment, or dependency constraint, let me select it from the numbered list or provide an exact version. Verify that the version is available before installing it.
7. If the selected package version has no matching documentation version, explain the mismatch and ask which published documentation version to use. Do not silently fall back to Latest.

After I choose, set `DOCS_BASE` to the canonical base URL for the selected documentation version and use that base for every documentation page. Replace `DOCS_BASE` with the selected URL when fetching a page.

Use this Markdown documentation page as the first source for installation and prerequisite handling:

`DOCS_BASE/get-started/installation-guide.md`

Help me install the library based on that page.
Check whether prerequisites already exist before asking me to install anything:

* Supported operating system: Windows, Linux, or macOS.
* Python version: 3.10, 3.11, 3.12, or 3.13.
* Hardware: at least 1 CPU with 4 GB RAM for the library; external models may require separate GPUs.

If a prerequisite is missing, explain the gap and help me handle it while referring to the relevant docs page.
Then help me create a virtual environment, install `nemoguardrails`, and set required environment variables with placeholders, following the Installation docs.
Never ask me to paste real API keys into chat.
After installation succeeds, verify the installed package version and confirm that `DOCS_BASE` still matches it.
After installation succeeds, ask which tutorial I want to try next from the Tutorials docs:

1. Check Harmful Content. If this is selected, load `DOCS_BASE/get-started/tutorials/nemotron-safety-guard-deployment.md`
2. Content Safety Reasoning. If this is selected, load `DOCS_BASE/get-started/tutorials/nemotron-content-safety-reasoning-deployment.md`
3. Restrict Topics. If this is selected, load `DOCS_BASE/get-started/tutorials/nemoguard-topiccontrol-deployment.md`
4. Detect Jailbreak Attempts. If this is selected, load `DOCS_BASE/get-started/tutorials/nemoguard-jailbreakdetect-deployment.md`
5. Jailbreak Heuristics. If this is selected, load `DOCS_BASE/get-started/tutorials/jailbreak-detection-heuristics.md`
6. Add Multimodal Content Safety. If this is selected, load `DOCS_BASE/get-started/tutorials/multimodal.md`

## Contributor Path

Help me clone the Guardrails repository before assuming local repository instructions exist:

```bash
git clone https://github.com/NVIDIA-NeMo/Guardrails.git nemoguardrails
cd nemoguardrails
```

After the repository is available, help me navigate the implemented contributor guidance:

* Start with `AGENTS.md` for root repository rules.
* Follow `nemoguardrails/AGENTS.md` when changing package runtime code.
* Follow `docs/AGENTS.md` when editing documentation.
* Follow `CONTRIBUTING.md` and `AI_POLICY.md` for public contribution and AI-assistance policy.

## Start by Understanding My Goal

Ask one focused question first: what am I trying to do?
Offer these choices when useful:

1. Help me install the library or verify my environment.
2. Add basic input/output guardrails to an app.
3. Choose which guardrail type or catalog item to use.
4. Write or debug Colang flows.
5. Integrate with Python, LangChain, LangGraph, or the Guardrails API server.
6. Add custom actions or a custom model/provider.
7. Evaluate guardrails or run vulnerability scanning.
8. Configure tracing, metrics, logging, Docker, or deployment.
9. Troubleshoot an error.

## Security and Credentials

* Never ask me to paste real API keys, tokens, passwords, or private credentials into chat.
* Use placeholders such as `<NVIDIA_API_KEY>`, `<OPENAI_API_KEY>`, or `<YOUR_ENDPOINT>` in examples.
* If a command needs a secret, explain where the secret should be set locally, then let me provide it through my shell, environment, secret manager, or local UI.
* Do not print real secrets in commands, summaries, logs, or generated files.

## Working Style

* Keep answers task-oriented and concise.
* Show the smallest working example first, then explain optional production hardening.
* When writing code or configuration, prefer current documented patterns.
* When using live model endpoints in examples, clearly state that unit tests should mock LLM/provider calls.
* If I am contributing to the repository rather than just using the library, switch to the repository contribution rules from `CONTRIBUTING.md` and `AGENTS.md`.

Begin by asking whether I am a developer using the NVIDIA NeMo Guardrails library in an application or a contributor changing the Guardrails repository.

## Use the Documentation MCP Server

If your AI agent supports MCP, connect it to the NVIDIA NeMo Guardrails library documentation MCP server:

```text
https://docs.nvidia.com/nemo/guardrails/_mcp/server
```

The MCP server lets your agent retrieve the canonical documentation without cloning the GitHub repository.

## Use Markdown Documentation Pages

The documentation is available in clean Markdown for AI clients.

* Documentation index for AI clients: `https://docs.nvidia.com/nemo/guardrails/llms.txt`.
* Clean Markdown for any page: append `.md` to the page URL.

For example, use the Markdown version of the harmful-content tutorial:

```text
https://docs.nvidia.com/nemo/guardrails/get-started/tutorials/nemotron-safety-guard-deployment.md
```

Use production documentation as the canonical source.
Use staging URLs only when you are explicitly testing staging documentation.

## Match the Documentation Version

If you already installed the package, ask your agent to check your installed version:

```bash
python -c "import nemoguardrails; print(nemoguardrails.__version__)"
```

Use the matching versioned documentation when it is available.
If you cannot determine the installed version, use the latest docs unless your project requires an older version.

## Fetch Only The Agent Skills

If you want local skill files without cloning the full source tree, use a sparse checkout:

```bash
git clone --filter=blob:none --no-checkout https://github.com/NVIDIA-NeMo/Guardrails.git
cd Guardrails
git sparse-checkout set --no-cone '/.agents/skills/guardrails-developer-guide/**' '/.agents/skills/guardrails-developer-create-guardrails/**' '/.claude/**' '/AGENTS.md'
git checkout
```

Open the `Guardrails` directory in your AI coding agent.
The agent can then discover the local skills and root instructions.

You can also copy the developer-focused skills to a global agent skill location if your agent supports global skills.
Keep repository contribution guidance in a repository clone because it depends on local files such as `AGENTS.md`, `docs/AGENTS.md`, `CONTRIBUTING.md`, and `AI_POLICY.md`.

## Keep Secrets Out Of Chat

Do not paste real API keys, tokens, passwords, or private credentials into agent chat.
Use placeholders in examples and set real secrets through your shell, local environment, secret manager, or provider dashboard.