> 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.

# nemoguardrails.integrations.langchain.runnable_rails

## Module Contents

### Classes

| Name                                                                                   | Description                                  |
| -------------------------------------------------------------------------------------- | -------------------------------------------- |
| [`RunnableRails`](#nemoguardrails-integrations-langchain-runnable_rails-RunnableRails) | A runnable that wraps a rails configuration. |

### Data

[`logger`](#nemoguardrails-integrations-langchain-runnable_rails-logger)

### API

```python
class nemoguardrails.integrations.langchain.runnable_rails.RunnableRails(
    config: nemoguardrails.RailsConfig,
    llm: typing.Optional[langchain_core.language_models.BaseLanguageModel] = None,
    tools: typing.Optional[typing.List[langchain_core.tools.Tool]] = None,
    passthrough: bool = True,
    runnable: typing.Optional[langchain_core.runnables.Runnable] = None,
    input_key: str = 'input',
    output_key: str = 'output',
    verbose: bool = False,
    input_blocked_message: str = 'I cannot process this requ...,
    output_blocked_message: str = 'I cannot provide this resp...
)
```

**Bases:** `Runnable[Input, Output]`

A runnable that wraps a rails configuration.

This class implements the LangChain Runnable protocol to provide a way
to add guardrails to LangChain components. It can wrap LLM models or
entire chains and add input/output rails and dialog rails.

**Parameters:**

**`config`** `RailsConfig`

The rails configuration to use.

---

**`llm`** `Optional[BaseLanguageModel]` — default: None

Optional LLM to use with the rails.

---

**`tools`** `Optional[List[Tool]]` — default: None

Optional list of tools to register with the rails.

---

**`passthrough`** `bool` — default: True

Whether to pass through the original prompt or let
rails modify it. Defaults to True.

---

**`runnable`** `Optional[Runnable]` — default: None

Optional runnable to wrap with the rails.

---

**`input_key`** `str` — default: 'input'

The key to use for the input when dealing with dict input.

---

**`output_key`** `str` — default: 'output'

The key to use for the output when dealing with dict output.

---

**`verbose`** `bool` — default: False

Whether to print verbose logs.

---

**`input_blocked_message`** `str` — default: 'I cannot process this request.'

Message to return when input is blocked by rails.

---

**`output_blocked_message`** `str` — default: 'I cannot provide this response.'

Message to return when output is blocked by rails.

---

**`OutputType`** `Any`

The type of the output of this runnable as a type annotation.

---

**`config`** `Optional[RunnableConfig] = None`

---

**`kwargs`** `Dict[str, Any] = {}`

---

**`rails`** `= LLMRails(config=config, llm=llm, verbose=verbose)`

---

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.__or__(
    other: typing.Union[langchain_core.language_models.BaseLanguageModel, langchain_core.runnables.Runnable[typing.Any, typing.Any]]
) -> typing.Union['RunnableRails', langchain_core.runnables.Runnable[typing.Any, typing.Any]]
```

Chain this runnable with another, returning a new runnable.

This method handles two different cases:

1. If other is a BaseLanguageModel, set it as the LLM for this RunnableRails
2. If other is a Runnable, either:
   a. Set it as the passthrough\_runnable if this RunnableRails has no passthrough\_runnable yet
   b. Otherwise, delegate to the standard Runnable.**or** to create a proper chain

This ensures associativity in complex chains.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._convert_messages_to_rails_format(
    messages
) -> typing.List[dict]
```

Convert LangChain messages to rails message format.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._create_passthrough_messages(
    _input
) -> typing.List[typing.Dict[str, typing.Any]]
```

Create messages for passthrough mode.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._extract_content_from_result(
    result: typing.Any
) -> str
```

Extract text content from result, handling both dict and direct formats.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._extract_output_content(
    output: langchain_core.runnables.utils.Output
) -> str
```

Extract content from output for rails checking.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._extract_text_from_input(
    _input
) -> str
```

Extract text content from various input types for passthrough mode.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._extract_user_input_from_dict(
    _input: dict
)
```

Extract user input from dictionary, checking configured key first.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_chat_prompt_output(
    result: typing.Any,
    tool_calls: typing.Optional[list] = None,
    metadata: typing.Optional[dict] = None
) -> AIMessage
```

Format output for ChatPromptValue input.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_dict_output(
    input_dict: dict,
    result: typing.Any,
    tool_calls: typing.Optional[list] = None,
    metadata: typing.Optional[dict] = None
) -> typing.Dict[str, typing.Any]
```

Format output for dictionary input.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_dict_output_for_base_message(
    result: typing.Any,
    output_key: str,
    tool_calls: typing.Optional[list] = None,
    metadata: typing.Optional[dict] = None
) -> typing.Dict[str, typing.Any]
```

Format dict output when user input was a BaseMessage.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_dict_output_for_base_message_list(
    result: typing.Any,
    output_key: str,
    tool_calls: typing.Optional[list] = None,
    metadata: typing.Optional[dict] = None
) -> typing.Dict[str, typing.Any]
```

Format dict output when user input was a list of BaseMessage objects.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_dict_output_for_dict_message_list(
    result: typing.Any,
    output_key: str
) -> typing.Dict[str, typing.Any]
```

Format dict output when user input was a list of dict messages.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_dict_output_for_string_input(
    result: typing.Any,
    output_key: str
) -> typing.Dict[str, typing.Any]
```

Format dict output when the user input was a string.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_message_output(
    result: typing.Any,
    tool_calls: typing.Optional[list] = None,
    metadata: typing.Optional[dict] = None
) -> AIMessage
```

Format output for BaseMessage input types.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_output(
    input: typing.Any,
    result: typing.Any,
    context: typing.Dict[str, typing.Any],
    tool_calls: typing.Optional[list] = None,
    metadata: typing.Optional[dict] = None
) -> typing.Any
```

Format the output based on the input type and rails result.

**Parameters:**

**`input`** `Any`

The original input.

---

**`result`** `Any`

The result from the rails.

---

**`context`** `Dict[str, Any]`

The context returned by the rails.

---

**Returns:** `Any`

The formatted output.

**Raises:**

* `ValueError`: If the input type cannot be handled.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_passthrough_output(
    result: typing.Any,
    context: typing.Dict[str, typing.Any]
) -> typing.Any
```

Format output for passthrough mode.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_streaming_chunk(
    input: typing.Any,
    chunk
) -> typing.Any
```

Format a streaming chunk based on the input type.

**Parameters:**

**`input`** `Any`

The original input

---

**`chunk`**

The current chunk (string or dict with text and metadata)

---

**Returns:** `Any`

The formatted streaming chunk (using AIMessageChunk for LangChain compatibility)

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._format_string_prompt_output(
    result: typing.Any
) -> str
```

Format output for StringPromptValue input.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._full_rails_ainvoke(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> langchain_core.runnables.utils.Output
```

async

Full rails mode async: existing LLMRails processing.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._full_rails_invoke(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> langchain_core.runnables.utils.Output
```

Full rails mode: existing LLMRails processing.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._get_bot_message(
    result: typing.Any,
    context: typing.Dict[str, typing.Any]
) -> str
```

Extract the bot message from context or result.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._init_passthrough_fn()
```

Initialize the passthrough function for the LLM rails instance.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._input_to_rails_messages(
    input: langchain_core.runnables.utils.Input
) -> typing.List[dict]
```

Convert various input formats to rails message format.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._transform_chat_prompt_value(
    _input: langchain_core.prompt_values.ChatPromptValue
) -> typing.List[typing.Dict[str, typing.Any]]
```

Transform ChatPromptValue to messages list.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._transform_dict_input(
    _input: dict
) -> typing.List[typing.Dict[str, typing.Any]]
```

Transform dictionary input to messages list.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._transform_dict_message_list(
    user_input: list
) -> typing.List[typing.Dict[str, typing.Any]]
```

Transform list from dictionary input to messages.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._transform_dict_user_input(
    user_input
) -> typing.List[typing.Dict[str, typing.Any]]
```

Transform user input value from dictionary.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails._transform_input_to_rails_format(
    _input
) -> typing.List[typing.Dict[str, typing.Any]]
```

Transform input to the format expected by the rails.

**Parameters:**

**`_input`**

The input to transform.

---

**Returns:** `List[Dict[str, Any]]`

A list of messages in the format expected by the rails.

**Raises:**

* `ValueError`: If the input format cannot be handled.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.abatch(
    inputs: typing.List[langchain_core.runnables.utils.Input],
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> typing.List[langchain_core.runnables.utils.Output]
```

async

Batch inputs and process them asynchronously.

Concurrency is controlled via config\['max\_concurrency'] following LangChain best practices.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.ainvoke(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> langchain_core.runnables.utils.Output
```

async

Invoke this runnable asynchronously.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.astream(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> typing.AsyncIterator[langchain_core.runnables.utils.Output]
```

async

Stream the output of this runnable asynchronously.

Provides token-by-token streaming of the LLM response with guardrails applied.
Uses LLMRails.stream\_async() directly for efficient streaming.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.atransform(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> langchain_core.runnables.utils.Output
```

async

Transform the input asynchronously.

This is just an alias for ainvoke.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.batch(
    inputs: typing.List[langchain_core.runnables.utils.Input],
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> typing.List[langchain_core.runnables.utils.Output]
```

Batch inputs and process them synchronously.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.get_name(
    suffix: str = ''
) -> str
```

Get the name of this runnable.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.invoke(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> langchain_core.runnables.utils.Output
```

Invoke this runnable synchronously.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.stream(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> typing.Iterator[langchain_core.runnables.utils.Output]
```

Stream the output of this runnable synchronously.

Provides token-by-token streaming of the LLM response with guardrails applied.
Handles async context properly by running astream in a separate event loop.

```python
nemoguardrails.integrations.langchain.runnable_rails.RunnableRails.transform(
    input: langchain_core.runnables.utils.Input,
    config: typing.Optional[langchain_core.runnables.RunnableConfig] = None,
    kwargs: typing.Optional[typing.Any] = {}
) -> langchain_core.runnables.utils.Output
```

Transform the input.

This is just an alias for invoke.

```python
nemoguardrails.integrations.langchain.runnable_rails.logger = logging.getLogger(__name__)
```