NVIDIA NeMo Guardrails

https://docs.nvidia.com/nemo/guardrails
Admin
NVIDIA NeMo Guardrails enables developers to add programmable guardrails between LLM applications...
Tokens:1,006,724
Snippets:9,475
Trust Score:10
Update:1 week ago
Show doc for...
Tokens:
Raw
### Start statement example

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/working-with-actions

Example of starting a single action with a reference.

```colang
start UtteranceBotAction(script="Hello") as $bot_action_ref
```

--------------------------------

### Install IPython and start REPL

Source: https://docs.nvidia.com/nemo/guardrails/get-started/tutorials/nemoguard-jailbreakdetect-deployment

Install the IPython REPL and run it to interpret the Python code. The command `pip install ipython` installs IPython, and `ipython` starts the REPL.

```bash
$ pip install ipython
$ ipython
In [1]:
```

--------------------------------

### Start server with default settings

Source: https://docs.nvidia.com/nemo/guardrails/latest/run-guardrailed-inference/using-fastapi-server/run-guardrails-server

Starts the server on port 8000 and looks for a ./config folder in the current directory. If not found, uses built-in example configurations.

```bash
nemoguardrails server
```

--------------------------------

### Run the tracing example script

Source: https://docs.nvidia.com/nemo/guardrails/latest/observability/tracing/quick-start

Execute the trace_example.py script to run the tracing setup.

```bash
python trace_example.py
```

--------------------------------

### Install vLLM and start Patronus Lynx server

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/guardrail-catalog/third-party/patronus-lynx

Install vLLM and start a server hosting the Patronus Lynx 70B model on port 5000. The server will be available at http://localhost:5000/.

```bash
pip install vllm
python -m vllm.entrypoints.openai.api_server --port 5000 --model PatronusAI/Patronus-Lynx-70B-Instruct
```

--------------------------------

### Run the library server with Docker

Source: https://docs.nvidia.com/nemo/guardrails/more-deployment-options/using-docker

Starts the library server with example configurations. The Chat UI is accessible at http://localhost:8000. Requires an OPENAI_API_KEY because the example configurations use OpenAI models such as gpt-3.5-turbo-instruct and gpt-4.

```bash
docker run -p 8000:8000 -e OPENAI_API_KEY=$OPENAI_API_KEY nemoguardrails

```

--------------------------------

### get_examples_data_path() -> pathlib.Path

Source: https://docs.nvidia.com/nemo/guardrails/guardrails-python-sdk/nemoguardrails/utils

Helper to get the path to the examples data directory.

```APIDOC
## get_examples_data_path() -> pathlib.Path

### Description
Helper to get the path to the examples data directory.

### Returns
- **pathlib.Path** - The path to the examples data directory.

```

--------------------------------

### user started saying something example

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/the-standard-library/core

Waits for the start of a user utterance. The example starts a listening posture when the user begins talking and stops it when the user finishes.

```colang
import core
import avatars
flow main
    # Start a bot posture as soon as the user starts talking
    user started saying something
    start bot posture "listening" as $ref
    # Stop the posture when the user is done talking
    user said something
    send $ref.Stop()

```

```text
> /UtteranceUserAction.Started()
Posture: listening
> /UtteranceUserAction.TranscriptUpdated(interim_transcript="I am starting to talk")
> /UtteranceUserAction.Finished(final_transcript="anything")
bot posture (stop)

```

--------------------------------

### StartInternalSystemAction event example

Source: https://docs.nvidia.com/nemo/guardrails/latest/run-guardrailed-inference/using-python-apis/event-based-api

Represents that an action needs to be started. The example shows the event type, action name, parameters, result key, and system action flag.

```json
{
  "type": "StartInternalSystemAction",
  "action_name": "generate_user_intent",
  "action_params": {},
  "action_result_key": null,
  "is_system_action": true
}
```

--------------------------------

### Run a Colang example with the NeMo Guardrails CLI

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/introduction

Start the interactive chat CLI with a configuration directory containing Colang and YAML files. Replace <path_to_example_file_directory> with the directory of the example you want to run.

```bash
> nemoguardrails chat --config=<path_to_example_file_directory>
```

--------------------------------

### get_examples_data_path() -> str

Source: https://docs.nvidia.com/nemo/guardrails/latest/guardrails-python-sdk/nemoguardrails/utils

Helper to get the path to the examples data directory. Useful for locating example data files.

```APIDOC
## get_examples_data_path() -> str

### Description
Helper to get the path to the examples data directory.

### Method
Function

### Signature
`get_examples_data_path() -> str`

### Returns
- **str** - The path to the examples data directory.

### Example
```python
from nemoguardrails.utils import get_examples_data_path
path = get_examples_data_path()
# path: "/path/to/examples"
```
```

--------------------------------

### Await an Action - Basic Example (actions/await_keyword/main.co)

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/working-with-actions

Shows a flow that uses the await statement to start an action and wait for it to finish. The await statement is a shortcut for starting an action and matching its .Finished() event.

```colang
flow main
    match UtteranceUserAction.Finished(final_transcript="Hi")
    await UtteranceBotAction(script="Hi there! How are you?")
    match UtteranceUserAction.Finished(final_transcript="Good and you?")
    # ...
```

--------------------------------

### Basic Tool Setup with RunnableRails

Source: https://docs.nvidia.com/nemo/guardrails/integration-with-third-party-libraries/langchain/runnable-rails

Set up a guarded model with tool calling. Requires passthrough=True and bind_tools() to attach tools. The example defines a calculator tool, binds it to a ChatOpenAI model, and creates a RunnableRails instance.

```python
from langchain_core.tools import tool
from langchain_openai import ChatOpenAI
from nemoguardrails import RailsConfig
from nemoguardrails.integrations.langchain.runnable_rails import RunnableRails
@tool
def calculator(expression: str) -> str:
    """Evaluates mathematical expressions like '2 + 2' or 'sqrt(16)'."""
    try:
        safe_dict = {'sqrt': __import__('math').sqrt, 'pow': pow, '__builtins__': {}}
        return str(eval(expression, safe_dict))
    except Exception as e:
        return f"Error: {e}"
tools = [calculator]
model = ChatOpenAI(model="gpt-5").bind_tools(tools)
config = RailsConfig.from_path("path/to/config")
guardrails = RunnableRails(config=config, passthrough=True)
guarded_model = guardrails | model
```

--------------------------------

### KnowledgeBase usage example

Source: https://docs.nvidia.com/nemo/guardrails/guardrails-python-sdk/nemoguardrails/kb/kb

Shows how to create a KnowledgeBase instance, initialize it, build the index, and search for relevant chunks. The build and search methods are async.

```python
# Creating a KnowledgeBase instance
kb = KnowledgeBase(documents=["Document 1", "Document 2"], config=my_config, get_embedding_search_provider_instance=my_provider)
# Initializing and building the knowledge base
kb.init()
await kb.build()
# Searching for relevant chunks
results = await kb.search_relevant_chunks("query text", max_results=5)
```

--------------------------------

### bot started saying something example

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/the-standard-library/core

Waits for the bot to start saying any utterance. The example shows a flow that sets the bot posture to 'talking' when the bot starts speaking.

```colang
import core
import avatars
flow handling talking posture
    bot started saying something
    bot posture "talking"
    bot said something
flow main
    activate handling talking posture
    user said something
    bot say "hi"
```

```text
> something
hi
Posture: talking
bot posture (stop)
```

--------------------------------

### bot started saying $text example

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/the-standard-library/core

Waits for the bot to start saying a specific utterance. The example shows a flow that reacts to the bot starting to say 'hi' and sends a custom event.

```colang
import core
flow reacting to bot utterances
    bot started saying "hi"
    send CustomEvent()
flow main
    activate reacting to bot utterances
    user said something
    bot say "hi"
```

```text
> hello
hi
Event: CustomEvent
```

--------------------------------

### Run content_capture_example.py

Source: https://docs.nvidia.com/nemo/guardrails/observability/tracing/content-capture

Run the script to execute the example and print the captured spans to the console.

```bash
python content_capture_example.py
```

--------------------------------

### Bad design example with action-like flows

Source: https://docs.nvidia.com/nemo/guardrails/latest/configure-guardrails/colang/colang-2/language-reference/flow-control

Example of a bad design where `when` is used with action-like flows that start with an action. This will not work correctly because only one of the two actions will be started due to action conflict between `UtteranceBotAction` and `GestureBotAction`.

```colang
flow bot greet then comment
    when bot say "Hi there!"
        bot say "I am done talking first"
    or when bot gesture "Wave with one hand"
        bot say "I am done gesturing first"
flow bot say $text
    await UtteranceBotAction(script=$text)
flow bot gesture $gesture
    await GestureBotAction(gesture=$gesture)
```

--------------------------------

### Start and stop bot posture with user started saying something

Source: https://docs.nvidia.com/nemo/guardrails/latest/configure-guardrails/colang/colang-2/language-reference/the-standard-library/core

Waits for the start of a user utterance, then starts a bot posture and stops it when the user finishes. The example uses the avatars library.

```colang
import core
import avatars
flow main
    # Start a bot posture as soon as the user starts talking
    user started saying something
    start bot posture "listening" as $ref
    # Stop the posture when the user is done talking
    user said something
    send $ref.Stop()
```

```text
> /UtteranceUserAction.Started()
Posture: listening
> /UtteranceUserAction.TranscriptUpdated(interim_transcript="I am starting to talk")
> /UtteranceUserAction.Finished(final_transcript="anything")
bot posture (stop)
```

--------------------------------

### Example output from Python script

Source: https://docs.nvidia.com/nemo/guardrails/latest/run-guardrailed-inference/using-fastapi-server/list-guardrail-configs

Shows the expected output when running the Python example to list configurations.

```text
Available configurations:
  - content_safety
  - jailbreak_detection
  - topic_safety
```

--------------------------------

### Python example to list configs

Source: https://docs.nvidia.com/nemo/guardrails/latest/run-guardrailed-inference/using-fastapi-server/list-guardrail-configs

Uses the requests library to fetch and print the available configurations from the server.

```python
import requests
base_url = "http://localhost:8000"
response = requests.get(f"{base_url}/v1/rails/configs")
configs = response.json()
print("Available configurations:")
for config in configs:
    print(f"  - {config['id']}")
```

--------------------------------

### Start server with default configuration

Source: https://docs.nvidia.com/nemo/guardrails/latest/run-guardrailed-inference/using-fastapi-server/run-guardrails-server

Starts the server with a default configuration within a multi-config folder. Chat completions requests without a config_id use the specified default configuration.

```bash
nemoguardrails server --config examples/configs --default-config-id content_safety
```

--------------------------------

### Install NeMo Guardrails with pip

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/introduction

Install the NeMo Guardrails package using pip. This is the first step before running any Colang examples.

```bash
> pip install nemoguardrails
```

--------------------------------

### Database Connection Example in init

Source: https://docs.nvidia.com/nemo/guardrails/latest/configure-guardrails/custom-initialization/init-function

Creates a PostgreSQL connection pool using environment variables and registers it as an action parameter with app.register_action_param.

```python
import os
import psycopg2
from nemoguardrails import LLMRails
def init(app: LLMRails):
    # Create connection pool
    conn = psycopg2.connect(
        host=os.environ.get("DB_HOST", "localhost"),
        database=os.environ.get("DB_NAME", "mydb"),
        user=os.environ.get("DB_USER", "user"),
        password=os.environ.get("DB_PASSWORD"),
    )
    app.register_action_param("db_conn", conn)
```

--------------------------------

### Example response for GET /v1/health

Source: https://docs.nvidia.com/nemo/guardrails/latest/reference/guardrails-api-server/health/get-health

Example 200 response body for the health check endpoint. The status field is a string and is optional.

```json
{
  "status": "pass"
}
```

--------------------------------

### Example output from demo.py

Source: https://docs.nvidia.com/nemo/guardrails/latest/configure-guardrails/guardrail-catalog/agentic-security

Example output from the rails.generate call, showing the assistant's response with a Python script for getting weather in Santa Clara.

```text
{'role': 'assistant', 'content': '**Getting the Weather in Santa Clara using Python**\n=====================================================\n\nTo get the weather in Santa Clara, we can use the OpenWeatherMap API, which provides current and forecasted weather conditions. We will use the `requests` library to make an HTTP request to the API and the `json` library to parse the response.\n\n**Prerequisites**\n---------------\n\n* Python 3.x\n* `requests` library (`pip install requests`)\n* OpenWeatherMap API key (sign up for free at [OpenWeatherMap](https://home.openweathermap.org/users/sign_up))\n\n**Code**\n-----\n\n```python\nimport requests\nimport json\n\ndef get_weather(api_key, city, units=\'metric\'):\n    """\n    Get the current weather in a city.\n\n    Args:\n        api_key (str): OpenWeatherMap API key\n        city (str): City name\n        units (str, optional): Units of measurement (default: \'metric\')\n\n    Returns:\n        dict: Weather data\n    """\n    base_url = \'http://api.openweathermap.org/data/2.5/weather\'\n    params = {\n        \'q\': city,\n        \'units\': units,\n        \'appid\': api_key\n    }\n    response = requests.get(base_url, params=params)\n    response.raise_for_status()\n    return response.json()\n\ndef main():\n    api_key = \'YOUR_API_KEY\'  # replace with your OpenWeatherMap API key\n    city = \'Santa Clara\'\n    weather_data = get_weather(api_key, city)\n    print(\'Weather in {}:\'.format(city))\n    print(\'Temperature: {}°C\'.format(weather_data[\'main\'][\'temp\']))\n    print(\'Humidity: {}%\'.format(weather_data[\'main\'][\'humidity\']))\n    print(\'Conditions: {}\'.format(weather_data[\'weather\'][0][\'description\']))\n\nif __name__ == \'__main__\':\n    main()\n```\n\n**Explanation**\n--------------\n\n1. We import the required libraries: `requests` for making HTTP requests and `json` for parsing the response.\n2. We define a function `get_weather` that takes the API key, city name, and units of measurement as arguments.\n3. We construct the API URL and parameters using the `base_url` and `params` dictionary.\n4. We make a GET request to the API using `requests.get` and raise an exception if the response status code is not 200 (OK).\n5. We parse the response data using `response.json()` and return the result as a dictionary.\n6. In the `main` function, we set the API key and city name, call `get_weather`, and print the weather data.\n\n**Notes**\n-------\n\n* Replace `YOUR_API_KEY` with your actual OpenWeatherMap API key.\n* You can adjust the units of measurement by passing a different value for the `units` parameter (e.g., \'imperial\' for Fahrenheit).\n* This script only retrieves the current weather conditions. For forecasted weather, you can use the [OpenWeatherMap forecast API](https://openweathermap.org/forecast5).\n\nI hope this helps! Let me know if you have any questions or need further assistance.'}
```

--------------------------------

### Set up tracing with OpenTelemetry in trace_example.py

Source: https://docs.nvidia.com/nemo/guardrails/latest/observability/tracing/quick-start

Configure OpenTelemetry with a console exporter, set up guardrails with tracing enabled, and generate a response. Save as trace_example.py.

```python
# trace_example.py
from opentelemetry import trace
from opentelemetry.sdk.trace import TracerProvider
from opentelemetry.sdk.trace.export import BatchSpanProcessor, ConsoleSpanExporter
from opentelemetry.sdk.resources import Resource
from nemoguardrails import LLMRails, RailsConfig
# Configure OpenTelemetry
resource = Resource.create({"service.name": "guardrails-quickstart"})
tracer_provider = TracerProvider(resource=resource)
trace.set_tracer_provider(tracer_provider)
tracer_provider.add_span_processor(BatchSpanProcessor(ConsoleSpanExporter()))
# Configure guardrails with tracing
config_yaml = """
models:
  - type: main
    engine: openai
    model: gpt-4o-mini
rails:
  config:
    streaming: true
tracing:
  enabled: true
  adapters:
    - name: OpenTelemetry
"""
config = RailsConfig.from_content(yaml_content=config_yaml)
rails = LLMRails(config)
response = rails.generate(messages=[{"role": "user", "content": "Hello!"}])
print(f"Response: {response}")
```

--------------------------------

### Run metrics_example.py

Source: https://docs.nvidia.com/nemo/guardrails/latest/observability/metrics/enable-metrics

Run the Python script to execute the request and export metrics.

```bash
python metrics_example.py
```

--------------------------------

### Activate notification of undefined flow start flow

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/the-standard-library/core

Activates the 'notification of undefined flow start' flow to detect when a flow is started but not defined. The example intentionally misspells 'bot say' as 'bot sayy' to trigger the undefined flow start. The expected test output is 'Failed to start an undefined flow!'

```colang
import core
flow main
    activate notification of undefined flow start
    # We are misspelling the `bot say` flow to trigger a undefined flow start.
    user said something
    bot sayy "hello"

```

```text
> test
Failed to start an undefined flow!

```

--------------------------------

### Multi-Config Mode: Start Server and List Configurations

Source: https://docs.nvidia.com/nemo/guardrails/run-guardrailed-inference/using-fastapi-server/run-guardrails-server

Start the server in multi-config mode and list available configurations using the `/v1/rails/configs` endpoint.

```bash
nemoguardrails server --config examples/configs
```

```bash
curl http://localhost:8000/v1/rails/configs
```

```json
[
  {"id": "content_safety"},
  {"id": "jailbreak_detection"},
  {"id": "topic_safety"}
]
```

--------------------------------

### start(port, host)

Source: https://docs.nvidia.com/nemo/guardrails/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/server

Starts the jailbreak detection server with the specified port and host.

```APIDOC
## start(port, host)

### Description
Starts the jailbreak detection server with the specified port and host.

### Parameters
- **port** (int) - Required - Port number for the server. Default: 1337
- **host** (str) - Required - Host address for the server. Default: '0.0.0.0'

### Signature
```python
start(port: int = typer.Option(default=1337, ...), host: str = typer.Option(default='0.0.0...'))
```

```

--------------------------------

### user saying something -> $transcript example

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/the-standard-library/core

Waits for any ongoing user utterance (partial transcripts). The example triggers a bot gesture when the user starts speaking.

```colang
import core
import avatars
flow main
    user saying something
    bot gesture "nod"

```

```text
> /UtteranceUserAction.TranscriptUpdated(interim_transcript="anything")
Gesture: nod

```

--------------------------------

### config.yml: Example with model parameters

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/custom-initialization/custom-llm-framework

Shows a config.yml entry that names a provider (engine) and model, with parameters, but does not name the framework.

```yaml
models:
  - type: main
    engine: my_engine
    model: my-flagship-model
    parameters:
      temperature: 0.2
```

--------------------------------

### Health response example

Source: https://docs.nvidia.com/nemo/guardrails/latest/reference/guardrails-api-server/health/get-root

Example JSON response from the GET / endpoint when the chat UI is disabled. Contains a status field with the value "ok".

```json
{
  "status": "ok"
}

```

--------------------------------

### Python example to use a configuration

Source: https://docs.nvidia.com/nemo/guardrails/latest/run-guardrailed-inference/using-fastapi-server/list-guardrail-configs

Retrieves the available configs, picks the first one, and sends a chat request with the guardrails config_id.

```python
# Get available configs
response = requests.get(f"{base_url}/v1/rails/configs")
configs = response.json()
# Use the first available config
if configs:
    config_id = configs[0]["id"]
    response = requests.post(f"{base_url}/v1/chat/completions", json={
        "model": "meta/llama-3.1-8b-instruct",
        "messages": [{"role": "user", "content": "Hello!"}],
        "guardrails": {
            "config_id": config_id
        }
    })
    print(response.json())
```

--------------------------------

### Corrected implementation for action-like flows

Source: https://docs.nvidia.com/nemo/guardrails/latest/configure-guardrails/colang/colang-2/language-reference/flow-control

Corrected implementation of the bad design example. It uses `start` with `and` to start both actions concurrently, then uses `when` on the `Finished()` events of the action references.

```colang
flow bot greet then comment
    start bot say "Hi there!" as $action_1_ref
        and bot gesture "Wave with one hand" as $action_2_ref
    when $action_1_ref.Finished()
        bot say "I am done talking first"
    or when $action_2_ref.Finished()
        bot say "I am done gesturing first"
```

--------------------------------

### nemoguardrails.utils.get_examples_data_path(file_path: str) -> str

Source: https://docs.nvidia.com/nemo/guardrails/guardrails-python-sdk/nemoguardrails/utils

Helper to get the path to the examples data directory.

```APIDOC
## nemoguardrails.utils.get_examples_data_path(file_path: str) -> str

### Description
Helper to get the path to the examples data directory.

### Parameters
- **file_path** (str) - Required - The file path.

### Returns
- **str** - The path to the examples data directory.
```

--------------------------------

### start(port, models, initialize_only)

Source: https://docs.nvidia.com/nemo/guardrails/guardrails-python-sdk/nemoguardrails/library/factchecking/align_score/server

CLI command to start the AlignScore server with configurable port and models.

```APIDOC
## start(port, models, initialize_only)

### Description
CLI command to start the AlignScore server with configurable port and models.

### Parameters
- **port** (int) - Optional - Default: 5000 - The port to run the server on.
- **models** (List[str]) - Optional - Default: ['base', ...] - List of models to load.
- **initialize_only** (bool) - Optional - Default: False - If True, only initialize models and exit.

### Returns
- None

```

--------------------------------

### Install NeMo Guardrails with sdd extra and download spaCy model

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/guardrail-catalog/third-party/presidio

Alternative setup using the sdd extra to install NeMo Guardrails with Presidio dependencies, then download the en_core_web_lg model.

```bash
pip install nemoguardrails[sdd]
python -m spacy download en_core_web_lg
```

--------------------------------

### Complete configuration with all components

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/overview

Full structure with config.yml, prompts.yml, config.py, rails/, actions/ package, and kb/ for knowledge base documents.

```text
config/
├── config.yml          # Core configuration
├── prompts.yml         # Custom prompts (optional, can also be in config.yml)
├── config.py           # Custom initialization (LLM providers, etc.)
├── rails/              # Colang flow files (can also be at config root)
│   ├── input.co
│   ├── output.co
│   └── ...
├── actions/            # Custom actions (as a package)
│   ├── __init__.py
│   ├── validation.py
│   ├── external_api.py
│   └── ...
└── kb/                 # Knowledge base documents
    ├── policies.md
    ├── faq.md
    └── ...

```

--------------------------------

### Hello World raw event interaction

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/introduction

Shows the CLI interaction for the raw event example. Enter /InputEvent to trigger the HelloWorld event.

```text
> /InputEvent
Event: HelloWorld
```

--------------------------------

### Start the Actions Server

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/actions/registering-actions

Starts the actions server using the CLI command with the configuration directory. This command launches the server that will handle action execution.

```bash
nemoguardrails actions-server --config config/
```

--------------------------------

### polling llm request response example

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-2/language-reference/the-standard-library/lmm

Starts response polling for all LLM related calls to receive LLM responses and act on them. The example shows activating the flow and using an LLM expression to compute a value.

```colang
import core
import llm
flow main
    # Normally you don't need to activate this flow, as it is activated by LLM based flows where needed.
    activate polling llm request response
    user said something
    # While the response is generated the polling mechanism ensures that
    # the Colang runtime is getting polled.
    $value = ..."ten minus one"
    bot say $value
```

```text
> compute the value
nine
```

--------------------------------

### GET /v1/rails/configs (Python)

Source: https://docs.nvidia.com/nemo/guardrails/run-guardrailed-inference/using-fastapi-server/list-guardrail-configs

Python example using the requests library to retrieve the list of available guardrail configurations.

```APIDOC
## GET /v1/rails/configs (Python)

### Description
Python example using the requests library to retrieve the list of available guardrail configurations.

### Method
GET

### Endpoint
/v1/rails/configs

### Parameters
None

### Request Example
```python
import requests
base_url = "http://localhost:8000"
response = requests.get(f"{base_url}/v1/rails/configs")
configs = response.json()
print("Available configurations:")
for config in configs:
    print(f"  - {config['id']}")
```

### Response
#### Success Response (200)
- **array** (array of objects) - List of configuration objects, each with an `id` field.
- **id** (string) - The identifier of the guardrail configuration.

#### Response Example
```
Available configurations:
  - content_safety
  - jailbreak_detection
  - topic_safety
```

```

--------------------------------

### Single-Config Mode: Start Server and List Configurations

Source: https://docs.nvidia.com/nemo/guardrails/run-guardrailed-inference/using-fastapi-server/run-guardrails-server

Start the server in single-config mode and list available configurations using the `/v1/rails/configs` endpoint.

```bash
nemoguardrails server --config examples/configs/content_safety
```

```bash
curl http://localhost:8000/v1/rails/configs
```

--------------------------------

### Create Configuration Directory

Source: https://docs.nvidia.com/nemo/guardrails/configure-guardrails/colang/colang-1/tutorials/1-hello-world

Command to create the configuration folder from the project root.

```bash

mkdir config

```

--------------------------------

### Install OpenTelemetry SDK and Prometheus exporter for scraping

Source: https://docs.nvidia.com/nemo/guardrails/observability/metrics/opentelemetry-integration

Installs the NeMo Guardrails tracing package, the OpenTelemetry SDK, the Prometheus exporter, and the prometheus-client library. The prometheus-client is required because the example uses start_http_server to expose the scrape endpoint.

```bash
pip install "nemoguardrails[tracing]" opentelemetry-sdk opentelemetry-exporter-prometheus prometheus-client
```
Tokens:
Raw