> For clean Markdown of any page, append .md to the page URL. > For a complete documentation index, see https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llms.txt. # nemoguardrails The NeMo Guardrails library. ## Subpackages * **[`nemoguardrails.actions`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions)** * **[`nemoguardrails.actions_server`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions_server)** * **[`nemoguardrails.cli`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/cli)** * **[`nemoguardrails.colang`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang)** * **[`nemoguardrails.embeddings`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/index)** * **[`nemoguardrails.eval`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval)** * **[`nemoguardrails.evaluate`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate)** * **[`nemoguardrails.guardrails`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails)** * **[`nemoguardrails.http`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http)** * **[`nemoguardrails.integrations`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations)** * **[`nemoguardrails.kb`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/kb)** * **[`nemoguardrails.library`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library)** * **[`nemoguardrails.llm`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm)** * **[`nemoguardrails.logging`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging)** * **[`nemoguardrails.manifests`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/manifests)** * **[`nemoguardrails.rails`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails)** * **[`nemoguardrails.server`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server)** * **[`nemoguardrails.testing`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/testing)** * **[`nemoguardrails.tracing`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing)** ## Submodules * **[`nemoguardrails.base_guardrails`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/base_guardrails)** * **[`nemoguardrails.context`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/context)** * **[`nemoguardrails.deprecation`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/deprecation)** * **[`nemoguardrails.exceptions`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/exceptions)** * **[`nemoguardrails.imports`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/imports)** * **[`nemoguardrails.patch_asyncio`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/patch_asyncio)** * **[`nemoguardrails.registry`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/registry)** * **[`nemoguardrails.singleton`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/singleton)** * **[`nemoguardrails.streaming`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/streaming)** * **[`nemoguardrails.telemetry`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/telemetry)** * **[`nemoguardrails.types`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/types)** * **[`nemoguardrails.utils`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/utils)** ## Package Contents ### Classes | Name | Description | | ------------------------------------------------------------------------------ | ---------------------------------------------------------------------------------- | | [`ChatMessage`](#nemoguardrails-types-ChatMessage) | - | | [`Guardrails`](#nemoguardrails-guardrails-guardrails-Guardrails) | Top-level interface for NeMo Guardrails functionality. | | [`LLMFramework`](#nemoguardrails-types-LLMFramework) | Protocol for pluggable LLM framework backends. | | [`LLMModel`](#nemoguardrails-types-LLMModel) | Protocol that all LLM backends must implement. | | [`LLMRails`](#nemoguardrails-rails-llm-llmrails-LLMRails) | Rails based on a given configuration. | | [`LLMRailsRemovalWarning`](#nemoguardrails-deprecation-LLMRailsRemovalWarning) | A feature that is removed together with the LLMRails engine. | | [`LLMResponse`](#nemoguardrails-types-LLMResponse) | - | | [`LLMResponseChunk`](#nemoguardrails-types-LLMResponseChunk) | - | | [`RailsConfig`](#nemoguardrails-rails-llm-config-RailsConfig) | Configuration object for the models and the rails. | | [`Role`](#nemoguardrails-types-Role) | - | | [`ToolCall`](#nemoguardrails-types-ToolCall) | - | | [`ToolCallChunk`](#nemoguardrails-types-ToolCallChunk) | A structured stream event containing completed tool calls, not argument fragments. | | [`ToolCallDelta`](#nemoguardrails-types-ToolCallDelta) | - | | [`ToolCallDeltaChunk`](#nemoguardrails-types-ToolCallDeltaChunk) | - | | [`ToolCallFunction`](#nemoguardrails-types-ToolCallFunction) | - | | [`ToolCallFunctionDelta`](#nemoguardrails-types-ToolCallFunctionDelta) | - | | [`UsageInfo`](#nemoguardrails-types-UsageInfo) | - | ### Functions | Name | Description | | ---------------------------------------------------------------------------------------- | ------------------------------------------------- | | [`get_default_framework`](#nemoguardrails-llm-frameworks-registry-get_default_framework) | - | | [`register_framework`](#nemoguardrails-llm-frameworks-registry-register_framework) | Register an `LLMFramework` instance under `name`. | | [`register_provider`](#nemoguardrails-llm-providers-register_provider) | - | | [`set_default_framework`](#nemoguardrails-llm-frameworks-registry-set_default_framework) | - | ### Data [`FinishReason`](#nemoguardrails-types-FinishReason) [`__version__`](#nemoguardrails-__version__) [`_use_guardrails_wrapper`](#nemoguardrails-_use_guardrails_wrapper) ### API ```python class nemoguardrails.ChatMessage( role: nemoguardrails.types.Role, content: typing.Optional[typing.Union[str, typing.List[typing.Dict[str, typing.Any]]]] = None, tool_calls: typing.Optional[typing.List[nemoguardrails.types.ToolCall]] = None, tool_call_id: typing.Optional[str] = None, name: typing.Optional[str] = None, provider_metadata: typing.Dict[str, typing.Any] = dict() ) ``` Dataclass **`content`** `Optional[Union[str, List[Dict[str, Any]]]] = None` --- **`name`** `Optional[str] = None` --- **`provider_metadata`** `Dict[str, Any] = field(default_factory=dict)` --- **`role`** `Role` --- **`tool_call_id`** `Optional[str] = None` --- **`tool_calls`** `Optional[List[ToolCall]] = None` --- ```python nemoguardrails.ChatMessage.from_assistant( content: str, kwargs = {} ) -> nemoguardrails.types.ChatMessage ``` classmethod ```python nemoguardrails.ChatMessage.from_dict( d: typing.Dict[str, typing.Any] ) -> nemoguardrails.types.ChatMessage ``` classmethod Create a ChatMessage from a dict. Accepts both the canonical nested tool call format (`{"function": {"name": ..., "arguments": ...}}`) and the legacy flat format (`{"name": ..., "args": ...}`). JSON string arguments are parsed automatically. Role aliases like "bot", "human", and "developer" are mapped to canonical Role values. Unknown keys are captured into `provider_metadata`. ```python nemoguardrails.ChatMessage.from_system( content: str, kwargs = {} ) -> nemoguardrails.types.ChatMessage ``` classmethod ```python nemoguardrails.ChatMessage.from_tool( content: str, tool_call_id: str, kwargs = {} ) -> nemoguardrails.types.ChatMessage ``` classmethod ```python nemoguardrails.ChatMessage.from_user( content: str, kwargs = {} ) -> nemoguardrails.types.ChatMessage ``` classmethod ```python nemoguardrails.ChatMessage.to_dict() -> typing.Dict[str, typing.Any] ``` ```python class nemoguardrails.Guardrails( config: nemoguardrails.rails.llm.config.RailsConfig, llm: typing.Optional[nemoguardrails.types.LLMModel] = None, verbose: bool = False, use_iorails: bool = True, require_iorails: bool = False ) ``` **Bases:** [BaseGuardrails](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/base_guardrails#nemoguardrails-base_guardrails-BaseGuardrails) Top-level interface for NeMo Guardrails functionality. **`_rails_engine`** `= IORails(config)` --- **`_started`** `bool` Read IORails readiness from its owner; retain legacy startup state. --- **`events_history_cache`** `dict` Per-session events history cache. Used by the server to persist conversation state across requests. For LLMRails this is stored by reference; assigning replaces the dict object, not its contents. IORails is stateless, return empty cache and drop cache-store writes --- **`explain_info`** `Optional[ExplainInfo]` Deprecated. Use `explain()` instead. Direct access can return `None` for an uninitialized accumulator; `explain()` guarantees a non-None ExplainInfo. Only supported for LLMRails. --- **`llm`** `Optional[LLMModel]` The main LLM in use. Only supported for LLMRails. Read-only; use `update_llm()` to replace it. --- **`passthrough_fn`** `Optional[Callable]` The optional passthrough function that bypasses LLM generation. Only supported for LLMRails. When set, the rails pipeline calls this function instead of the main LLM for generating responses. --- **`rails_engine`** `IORails | LLMRails` Get immutable LLMRails object --- **`runtime`** `Runtime` The Colang runtime backing the rails engine. Only supported for LLMRails. --- **`use_iorails_engine`** `bool` --- ```python nemoguardrails.Guardrails.__aenter__() ``` async Async context manager entry. ```python nemoguardrails.Guardrails.__aexit__( exc_type, exc_val, exc_tb ) ``` async Async context manager exit. ```python nemoguardrails.Guardrails.__getstate__() ``` Pickle support: preserve config, verbose, and use_iorails so the rebuilt instance lands on the same engine. The llm is dropped (matches LLMRails). ```python nemoguardrails.Guardrails.__setstate__( state ) ``` Pickle support: rebuild from config + verbose + use_iorails. Older pickles missing these keys default to False/True respectively for backwards compatibility. ```python nemoguardrails.Guardrails._ensure_started() -> None ``` async Lazy initialization: call startup() on first use if not already started. ```python nemoguardrails.Guardrails.check( messages: typing.List[dict], rail_types: typing.Optional[typing.List[nemoguardrails.rails.llm.options.RailType]] = None, tools: typing.Optional[typing.List[dict]] = None ) -> nemoguardrails.rails.llm.options.RailsResult ``` Synchronous version of check_async. Supported by both LLMRails and IORails; tool rail types and `tools` by IORails only. ```python nemoguardrails.Guardrails.check_async( messages: typing.List[dict], rail_types: typing.Optional[typing.List[nemoguardrails.rails.llm.options.RailType]] = None, tools: typing.Optional[typing.List[dict]] = None ) -> nemoguardrails.rails.llm.options.RailsResult ``` async Run rails on messages based on their content (asynchronous). Supported by both LLMRails and IORails; tool rail types and `tools` by IORails only. ```python nemoguardrails.Guardrails.explain() -> nemoguardrails.logging.explain.ExplainInfo ``` Get the latest ExplainInfo object for debugging. Only supported for LLMRails ```python nemoguardrails.Guardrails.generate( prompt: str | None = None, messages: nemoguardrails.guardrails.guardrails_types.LLMMessages | None = None, options: typing.Optional[typing.Union[dict, nemoguardrails.rails.llm.options.GenerationOptions]] = None, kwargs = {} ) -> typing.Union[str, dict, nemoguardrails.rails.llm.options.GenerationResponse, typing.Tuple[dict, dict]] ``` Generate an LLM response synchronously with guardrails applied. Supported in both IORails and LLMRails ```python nemoguardrails.Guardrails.generate_async( prompt: str | None = None, messages: nemoguardrails.guardrails.guardrails_types.LLMMessages | None = None, options: typing.Optional[typing.Union[dict, nemoguardrails.rails.llm.options.GenerationOptions]] = None, kwargs = {} ) -> str | dict | nemoguardrails.rails.llm.options.GenerationResponse | tuple[dict, dict] ``` async Generate an LLM response asynchronously with guardrails applied. Supported by both LLMRails and IORails ```python nemoguardrails.Guardrails.generate_events( events: typing.List[dict] ) -> typing.List[dict] ``` Synchronous version of generate_events_async. Only supported for LLMRails. ```python nemoguardrails.Guardrails.generate_events_async( events: typing.List[dict] ) -> typing.List[dict] ``` async Generate the next events based on the provided history. Only supported for LLMRails. ```python nemoguardrails.Guardrails.process_events( events: typing.List[dict], state: typing.Union[typing.Optional[dict], nemoguardrails.colang.v2_x.runtime.flows.State] = None, blocking: bool = False ) -> typing.Tuple[typing.List[dict], typing.Union[dict, nemoguardrails.colang.v2_x.runtime.flows.State]] ``` Synchronous version of process_events_async. Only supported for LLMRails. ```python nemoguardrails.Guardrails.process_events_async( events: typing.List[dict], state: typing.Union[typing.Optional[dict], nemoguardrails.colang.v2_x.runtime.flows.State] = None, blocking: bool = False ) -> typing.Tuple[typing.List[dict], typing.Union[dict, nemoguardrails.colang.v2_x.runtime.flows.State]] ``` async Process a sequence of events in a given state. Only supported for LLMRails. ```python nemoguardrails.Guardrails.register_action( action: typing.Callable, name: typing.Optional[str] = None ) -> typing_extensions.Self ``` Register a custom action for the rails configuration. Only supported for LLMRails. Returns self so calls can be chained. ```python nemoguardrails.Guardrails.register_action_param( name: str, value: typing.Any ) -> typing_extensions.Self ``` Register a custom action parameter. Only supported for LLMRails. Returns self so calls can be chained. ```python nemoguardrails.Guardrails.register_embedding_provider( name: typing.Optional[str] = None ) -> typing_extensions.Self ``` Register a custom embedding provider. Only supported for LLMRails. Returns self so calls can be chained. ```python nemoguardrails.Guardrails.register_embedding_search_provider( name: str ) -> typing_extensions.Self ``` Register a new embedding search provider. Only supported for LLMRails. Returns self so calls can be chained. ```python nemoguardrails.Guardrails.register_filter( filter_fn: typing.Callable, name: typing.Optional[str] = None ) -> typing_extensions.Self ``` Register a custom filter for the rails configuration. Only supported for LLMRails. Returns self so calls can be chained. ```python nemoguardrails.Guardrails.register_output_parser( output_parser: typing.Callable, name: str ) -> typing_extensions.Self ``` Register a custom output parser for the rails configuration. Only supported for LLMRails. Returns self so calls can be chained. ```python nemoguardrails.Guardrails.register_prompt_context( name: str, value_or_fn: typing.Any ) -> typing_extensions.Self ``` Register a value to be included in the prompt context. Only supported for LLMRails. Returns self so calls can be chained. ```python nemoguardrails.Guardrails.shutdown() -> None ``` async Lifecycle method to stop the rails engine. Idempotent after successful cleanup. Failed or cancelled IORails startup and shutdown may retain resources; call again to retry their cleanup. ```python nemoguardrails.Guardrails.startup() -> None ``` async Lifecycle method to start the rails engine. Idempotent: safe to call multiple times. Also called automatically on first `generate_async()` if not called explicitly, so callers are not required to manage the lifecycle. The non-streaming admission queue is owned by `IORails` and is started/stopped as part of `IORails.start()` / `stop()`. ```python nemoguardrails.Guardrails.stream_async( prompt: str | None = None, messages: nemoguardrails.guardrails.guardrails_types.LLMMessages | None = None, kwargs = {} ) -> typing.AsyncIterator[str | dict | nemoguardrails.types.ToolCallChunk | nemoguardrails.types.ToolCallDeltaChunk] ``` Generate an LLM response asynchronously with streaming support. ```python nemoguardrails.Guardrails.update_llm( llm: nemoguardrails.types.LLMModel ) -> None ``` Replace the main LLM with a new one. Only supported for LLMRails, since IORails doesn't take LLM as argument ```python class nemoguardrails.LLMFramework() ``` Protocol Protocol for pluggable LLM framework backends. Each framework (LangChain, LiteLLM, etc.) implements this protocol to provide a factory for creating `LLMModel` instances and managing its own set of providers. `model_kwargs` carries all provider-specific configuration. Framework implementations extract what they need (e.g. LangChain pops `mode` to choose between chat and text completion models). ```python nemoguardrails.LLMFramework.create_model( model_name: str, provider_name: str, model_kwargs: typing.Optional[typing.Dict[str, typing.Any]] = None ) -> nemoguardrails.types.LLMModel ``` ```python nemoguardrails.LLMFramework.get_provider_names() -> typing.List[str] ``` ```python nemoguardrails.LLMFramework.register_provider( name: str, provider_cls: typing.Any ) -> None ``` ```python nemoguardrails.LLMFramework.reset() -> None ``` async Release all framework-owned resources and clear all registered state. Implementations should close any pooled connections, clear registered providers, and return the framework to its initial state. Callers can continue using the instance after reset; new resources will be created on demand. ```python class nemoguardrails.LLMModel() ``` Protocol Protocol that all LLM backends must implement. Adapters wrap provider-specific SDKs (LangChain, LiteLLM, OpenAI, etc.) behind this interface so the core pipeline remains framework-agnostic. `prompt` accepts either a plain string or a list of `ChatMessage` objects. Adapters convert `ChatMessage` to whatever their SDK expects. `**kwargs` are forwarded to the underlying SDK (e.g. temperature, max_tokens). **`model_name`** `str` --- **`provider_name`** `Optional[str]` --- **`provider_url`** `Optional[str]` --- ```python nemoguardrails.LLMModel.generate_async( prompt: typing.Union[str, typing.List[nemoguardrails.types.ChatMessage]], stop: typing.Optional[typing.List[str]] = None, kwargs = {} ) -> nemoguardrails.types.LLMResponse ``` async ```python nemoguardrails.LLMModel.stream_async( prompt: typing.Union[str, typing.List[nemoguardrails.types.ChatMessage]], stop: typing.Optional[typing.List[str]] = None, kwargs = {} ) -> typing.AsyncIterator[nemoguardrails.types.LLMResponseChunk] ``` Implementations must be async generator functions (use `yield`). ```python class nemoguardrails.LLMRails( config: nemoguardrails.rails.llm.config.RailsConfig, llm: typing.Optional[nemoguardrails.types.LLMModel] = None, verbose: bool = False ) ``` **Bases:** [BaseGuardrails](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/base_guardrails#nemoguardrails-base_guardrails-BaseGuardrails) Rails based on a given configuration. **`_default_embedding_engine`** `= 'FastEmbed'` --- **`_default_embedding_model`** `= 'all-MiniLM-L6-v2'` --- **`_default_embedding_params`** `= {}` --- **`_embedding_search_providers`** `= {}` --- **`_llm_generation_actions`** --- **`_log_adapters`** `= create_log_adapters(config.tracing)` --- **`events_history_cache`** `= {}` --- **`llm`** `Optional[LLMModel]` --- **`passthrough_fn`** The optional passthrough function that bypasses LLM generation. When set, the rails pipeline calls this function instead of the main LLM for generating responses. LLMGenerationActions is private, expose only `passthrough_fn` as a public API --- **`runtime`** `Runtime` --- ```python nemoguardrails.LLMRails.__getstate__() ``` ```python nemoguardrails.LLMRails.__setstate__( state ) ``` ```python nemoguardrails.LLMRails._create_model_cache( model ) -> nemoguardrails.llm.cache.LFUCache ``` Create cache instance for a model based on its configuration. **Parameters:** **`model`** The model configuration object --- **Returns:** [`LFUCache`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/cache/lfu#nemoguardrails-llm-cache-lfu-LFUCache) The cache instance ```python nemoguardrails.LLMRails._ensure_explain_info() -> nemoguardrails.logging.explain.ExplainInfo ``` staticmethod Ensure that the ExplainInfo variable is present in the current context **Returns:** [`ExplainInfo`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging/explain#nemoguardrails-logging-explain-ExplainInfo) A ExplainInfo class containing the llm calls' statistics ```python nemoguardrails.LLMRails._get_embeddings_search_provider_instance( esp_config: typing.Optional[nemoguardrails.rails.llm.config.EmbeddingSearchProvider] = None ) -> nemoguardrails.embeddings.index.EmbeddingsIndex ``` ```python nemoguardrails.LLMRails._get_events_for_messages( messages: typing.List[dict], state: typing.Any ) ``` Return the list of events corresponding to the provided messages. Tries to find a prefix of messages for which we have already a list of events in the cache. For the rest, they are converted as is. The reason this cache exists is that we want to benefit from events generated in previous turns, which can't be computed again because it would be expensive (e.g., involving multiple LLM calls). When an explicit state object will be added, this mechanism can be removed. **Parameters:** **`messages`** `List[dict]` The list of messages. --- **Returns:** A list of events. ```python nemoguardrails.LLMRails._init_kb() ``` async Initializes the knowledge base. ```python nemoguardrails.LLMRails._init_llms() ``` Initializes the right LLM engines based on the configuration. There can be multiple LLM engines and types that can be specified in the config. The main LLM engine is the one that will be used for all the core guardrails generations. Other LLM engines can be specified for use in specific actions. The reason we provide an option for decoupling the main LLM engine from the action LLM is to allow for flexibility in using specialized LLM engines for specific actions. **Raises:** * `ModelInitializationError`: If any model initialization fails ```python nemoguardrails.LLMRails._initialize_model_caches() -> None ``` Initialize caches for configured models. ```python nemoguardrails.LLMRails._prepare_model_kwargs( model_config ) ``` Prepare kwargs for model initialization, including API key from environment variable. **Parameters:** **`model_config`** The model configuration object --- **Returns:** The prepared kwargs for model initialization ```python nemoguardrails.LLMRails._resolve_streaming_output_rail_actions() -> typing.List[typing.Tuple[str, typing.Tuple[str, typing.Any]]] ``` Pair each configured output rail flow, in order, with the action streaming calls on every chunk. ```python nemoguardrails.LLMRails._run_output_rails_in_streaming( streaming_handler: typing.AsyncIterator[typing.Union[str, dict, nemoguardrails.types.ToolCallChunk, nemoguardrails.types.ToolCallDeltaChunk]], output_rails_streaming_config: nemoguardrails.rails.llm.config.OutputRailsStreamingConfig, output_rail_actions: typing.List[typing.Tuple[str, typing.Tuple[str, typing.Any]]], prompt: typing.Optional[str] = None, messages: typing.Optional[typing.List[dict]] = None, stream_first: typing.Optional[bool] = None ) -> typing.AsyncIterator[str] ``` async 1. Buffers tokens from 'streaming_handler' via BufferStrategy. 2. Runs sequential (parallel for colang 2.0 in future) flows for each chunk. 3. Yields the chunk if not blocked, or STOP if blocked. ```python nemoguardrails.LLMRails._validate_config() ``` Runs additional validation checks on the config. ```python nemoguardrails.LLMRails._validate_public_state( state: typing.Optional[typing.Union[dict, nemoguardrails.colang.v2_x.runtime.flows.State]] ) -> None ``` Validate public dict state passed through generate/generate_async. ```python nemoguardrails.LLMRails._validate_streaming_with_output_rails() -> None ``` ```python nemoguardrails.LLMRails.check( messages: typing.List[dict], rail_types: typing.Optional[typing.List[nemoguardrails.rails.llm.options.RailType]] = None, tools: typing.Optional[typing.List[dict]] = None ) -> nemoguardrails.rails.llm.options.RailsResult ``` Run rails on messages based on their content (synchronous). This is a synchronous wrapper around check_async(). **Parameters:** **`messages`** `List[dict]` List of message dicts with 'role' and 'content' fields. --- **`rail_types`** `Optional[List[RailType]]` — default: None `Optional[List[` [`RailType`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/options#nemoguardrails-rails-llm-options-RailType) `]]` — Optional list of rail types to run. See check_async() for details. --- **`tools`** `Optional[List[dict]]` — default: None Not supported. See check_async() for details. --- **Returns:** [`RailsResult`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/options#nemoguardrails-rails-llm-options-RailsResult) RailsResult containing status, content, and optional blocking rail name. **Raises:** * `RailTypeNotSupportedError`: If `tools` is given, or a requested rail type is `tool_call` or `tool_result`, which only the IORails engine runs. * `RailTypeNotConfiguredError`: If a requested rail type has no configured flows. ```python nemoguardrails.LLMRails.check_async( messages: typing.List[dict], rail_types: typing.Optional[typing.List[nemoguardrails.rails.llm.options.RailType]] = None, tools: typing.Optional[typing.List[dict]] = None ) -> nemoguardrails.rails.llm.options.RailsResult ``` async Run rails on messages based on their content (asynchronous). When `rail_types` is not provided, automatically determines which rails to run based on message roles: * Only user messages: runs input rails * Only assistant messages: runs output rails * Both user and assistant messages: runs both input and output rails * No user/assistant messages: logs warning and returns passing result When `rail_types` is provided, runs exactly the specified rail types, skipping the auto-detection logic. **Parameters:** **`messages`** `List[dict]` List of message dicts with 'role' and 'content' fields. Messages can contain any roles, but only user/assistant roles determine which rails execute when `rail_types` is not provided. --- **`rail_types`** `Optional[List[RailType]]` — default: None `Optional[List[` [`RailType`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/options#nemoguardrails-rails-llm-options-RailType) `]]` — Optional list of rail types to run, e.g. `[RailType.INPUT]` or `[RailType.OUTPUT]`. When provided, overrides automatic detection. --- **`tools`** `Optional[List[dict]]` — default: None Not supported. Only a tool-call check reads tools, and only the IORails engine runs one. --- **Returns:** [`RailsResult`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/options#nemoguardrails-rails-llm-options-RailsResult) RailsResult containing: **Raises:** * `RailTypeNotSupportedError`: If `tools` is given, or a requested rail type is `tool_call` or `tool_result`, which only the IORails engine runs. * `RailTypeNotConfiguredError`: If a requested rail type has no configured flows. **Examples:** ```python Check user input (auto-detected):: result = await rails.check_async([{"role": "user", "content": "Hello!"}]) if result.status == RailStatus.BLOCKED: print(f"Blocked by: {result.rail}") Check bot output with context (auto-detected):: result = await rails.check_async([ {"role": "user", "content": "Hello!"}, {"role": "assistant", "content": "Hi there!"} ]) Run only input rails explicitly:: result = await rails.check_async(messages, rail_types=[RailType.INPUT]) ``` ```python nemoguardrails.LLMRails.explain() -> nemoguardrails.logging.explain.ExplainInfo ``` Helper function to return the latest ExplainInfo object. ```python nemoguardrails.LLMRails.generate( prompt: typing.Optional[str] = None, messages: typing.Optional[typing.List[dict]] = None, options: typing.Optional[typing.Union[dict, nemoguardrails.rails.llm.options.GenerationOptions]] = None, state: typing.Optional[dict] = None ) ``` Synchronous version of generate_async. ```python nemoguardrails.LLMRails.generate_async( prompt: typing.Optional[str] = None, messages: typing.Optional[typing.List[dict]] = None, options: typing.Optional[typing.Union[dict, nemoguardrails.rails.llm.options.GenerationOptions]] = None, state: typing.Optional[typing.Union[dict, nemoguardrails.colang.v2_x.runtime.flows.State]] = None, streaming_handler: typing.Optional[nemoguardrails.streaming.StreamingHandler] = None ) -> typing.Union[str, dict, nemoguardrails.rails.llm.options.GenerationResponse, typing.Tuple[dict, dict]] ``` async Generate a completion or a next message. The format for messages is the following: ```python [ {"role": "context", "content": {"user_name": "John"}}, {"role": "user", "content": "Hello! How are you?"}, {"role": "assistant", "content": "I am fine, thank you!"}, {"role": "event", "event": {"type": "UserSilent"}}, ... ] ``` System messages are not yet supported. **Parameters:** **`prompt`** `Optional[str]` — default: None The prompt to be used for completion. --- **`messages`** `Optional[List[dict]]` — default: None The history of messages to be used to generate the next message. --- **`options`** `Optional[Union[dict, GenerationOptions]]` — default: None `Optional[Union[dict,` [`GenerationOptions`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/options#nemoguardrails-rails-llm-options-GenerationOptions) `]]` — Options specific for the generation. --- **`state`** `Optional[Union[dict, State]]` — default: None The state object that should be used as the starting point. --- **`streaming_handler`** `Optional[StreamingHandler]` — default: None `Optional[` [`StreamingHandler`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/streaming#nemoguardrails-streaming-StreamingHandler) `]` — If specified, and the config supports streaming, the provided handler will be used for streaming. --- **Returns:** `Union[str, dict,` [`GenerationResponse`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/options#nemoguardrails-rails-llm-options-GenerationResponse) `, Tuple[dict, dict]]` The completion (when a prompt is provided) or the next message. ```python nemoguardrails.LLMRails.generate_events( events: typing.List[dict] ) -> typing.List[dict] ``` Synchronous version of `LLMRails.generate_events_async`. ```python nemoguardrails.LLMRails.generate_events_async( events: typing.List[dict] ) -> typing.List[dict] ``` async Generate the next events based on the provided history. The format for events is the following: ```python [ {"type": "...", ...}, ... ] ``` **Parameters:** **`events`** `List[dict]` The history of events to be used to generate the next events. --- **`options`** The options to be used for the generation. --- **Returns:** `List[dict]` The newly generate event(s). ```python nemoguardrails.LLMRails.process_events( events: typing.List[dict], state: typing.Union[typing.Optional[dict], nemoguardrails.colang.v2_x.runtime.flows.State] = None, blocking: bool = False ) -> typing.Tuple[typing.List[dict], typing.Union[dict, nemoguardrails.colang.v2_x.runtime.flows.State]] ``` Synchronous version of `LLMRails.process_events_async`. ```python nemoguardrails.LLMRails.process_events_async( events: typing.List[dict], state: typing.Union[typing.Optional[dict], nemoguardrails.colang.v2_x.runtime.flows.State] = None, blocking: bool = False ) -> typing.Tuple[typing.List[dict], typing.Union[dict, nemoguardrails.colang.v2_x.runtime.flows.State]] ``` async Process a sequence of events in a given state. The events will be processed one by one, in the input order. **Parameters:** **`events`** `List[dict]` A sequence of events that needs to be processed. --- **`state`** `Union[Optional[dict], State]` — default: None The state that should be used as the starting point. If not provided, a clean state will be used. --- **Returns:** `Tuple[List[dict], Union[dict, State]]` (output_events, output_state) Returns a sequence of output events and an output state. ```python nemoguardrails.LLMRails.register_action( action: typing.Callable, name: typing.Optional[str] = None ) -> typing_extensions.Self ``` Register a custom action for the rails configuration. ```python nemoguardrails.LLMRails.register_action_param( name: str, value: typing.Any ) -> typing_extensions.Self ``` Registers a custom action parameter. ```python nemoguardrails.LLMRails.register_embedding_provider( name: typing.Optional[str] = None ) -> typing_extensions.Self ``` Register a custom embedding provider. **Parameters:** **`model`** `Type[EmbeddingModel]` `Type[` [`EmbeddingModel`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/base#nemoguardrails-embeddings-providers-base-EmbeddingModel) `]` — The embedding model class. --- **`name`** `str` — default: None The name of the embedding engine. If available in the model, it will be used. --- **Raises:** * `ValueError`: If the engine name is not provided and the model does not have an engine name. * `ValueError`: If the model does not have 'encode' or 'encode_async' methods. ```python nemoguardrails.LLMRails.register_embedding_search_provider( name: str ) -> typing_extensions.Self ``` Register a new embedding search provider. **Parameters:** **`name`** `str` The name of the embedding search provider that will be used. --- **`cls`** `Type[EmbeddingsIndex]` `Type[` [`EmbeddingsIndex`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/index#nemoguardrails-embeddings-index-EmbeddingsIndex) `]` — The class that will be used to generate and search embedding --- ```python nemoguardrails.LLMRails.register_filter( filter_fn: typing.Callable, name: typing.Optional[str] = None ) -> typing_extensions.Self ``` Register a custom filter for the rails configuration. ```python nemoguardrails.LLMRails.register_output_parser( output_parser: typing.Callable, name: str ) -> typing_extensions.Self ``` Register a custom output parser for the rails configuration. ```python nemoguardrails.LLMRails.register_prompt_context( name: str, value_or_fn: typing.Any ) -> typing_extensions.Self ``` Register a value to be included in the prompt context. :name: The name of the variable or function that will be used. :value_or_fn: The value or function that will be used to generate the value. ```python nemoguardrails.LLMRails.stream_async( prompt: typing.Optional[str] = None, messages: typing.Optional[typing.List[dict]] = None, options: typing.Optional[typing.Union[dict, nemoguardrails.rails.llm.options.GenerationOptions]] = None, state: typing.Optional[typing.Union[dict, nemoguardrails.colang.v2_x.runtime.flows.State]] = None, include_metadata: typing.Optional[bool] = False, generator: typing.Optional[typing.AsyncIterator[typing.Union[str, nemoguardrails.types.ToolCallChunk, nemoguardrails.types.ToolCallDeltaChunk]]] = None, include_generation_metadata: typing.Optional[bool] = None ) -> typing.AsyncIterator[typing.Union[str, dict, nemoguardrails.types.ToolCallChunk, nemoguardrails.types.ToolCallDeltaChunk]] ``` Simplified interface for getting directly the streamed tokens from the LLM. ```python nemoguardrails.LLMRails.update_llm( llm: nemoguardrails.types.LLMModel ) ``` Replace the main LLM with the provided one. **Parameters:** **`llm`** `LLMModel` [`LLMModel`](/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/types#nemoguardrails-types-LLMModel) — The new LLM that should be used. --- ```python class nemoguardrails.LLMRailsRemovalWarning() ``` **Bases:** `DeprecationWarning` A feature that is removed together with the LLMRails engine. ```python class nemoguardrails.LLMResponse( content: str, reasoning: typing.Optional[str] = None, tool_calls: typing.Optional[typing.List[nemoguardrails.types.ToolCall]] = None, model: typing.Optional[str] = None, finish_reason: typing.Optional[nemoguardrails.types.FinishReason] = None, stop_sequence: typing.Optional[str] = None, request_id: typing.Optional[str] = None, usage: typing.Optional[nemoguardrails.types.UsageInfo] = None, provider_metadata: typing.Optional[typing.Dict[str, typing.Any]] = None ) ``` Dataclass **`content`** `str` --- **`finish_reason`** `Optional[FinishReason] = None` --- **`model`** `Optional[str] = None` --- **`provider_metadata`** `Optional[Dict[str, Any]] = None` --- **`reasoning`** `Optional[str] = None` --- **`request_id`** `Optional[str] = None` --- **`stop_sequence`** `Optional[str] = None` --- **`tool_calls`** `Optional[List[ToolCall]] = None` --- **`usage`** `Optional[UsageInfo] = None` --- ```python class nemoguardrails.LLMResponseChunk( delta_content: typing.Optional[str] = None, delta_reasoning: typing.Optional[str] = None, delta_tool_calls: typing.Optional[typing.List[nemoguardrails.types.ToolCall]] = None, model: typing.Optional[str] = None, finish_reason: typing.Optional[nemoguardrails.types.FinishReason] = None, request_id: typing.Optional[str] = None, usage: typing.Optional[nemoguardrails.types.UsageInfo] = None, provider_metadata: typing.Optional[typing.Dict[str, typing.Any]] = None, tool_call_deltas: typing.Optional[typing.List[nemoguardrails.types.ToolCallDelta]] = None ) ``` Dataclass **`delta_content`** `Optional[str] = None` --- **`delta_reasoning`** `Optional[str] = None` --- **`delta_tool_calls`** `Optional[List[ToolCall]] = None` --- **`finish_reason`** `Optional[FinishReason] = None` --- **`model`** `Optional[str] = None` --- **`provider_metadata`** `Optional[Dict[str, Any]] = None` --- **`request_id`** `Optional[str] = None` --- **`tool_call_deltas`** `Optional[List[ToolCallDelta]] = None` --- **`usage`** `Optional[UsageInfo] = None` --- ```python class nemoguardrails.RailsConfig() ``` **Bases:** `BaseModel` Configuration object for the models and the rails. TODO: add typed config for user_messages, bot_messages, and flows. **`actions_server_url`** `Optional[str]` --- **`bot_messages`** `Dict[str, List[str]]` --- **`colang_version`** `str` --- **`config_path`** `Optional[str]` --- **`core`** `CoreConfig` --- **`custom_data`** `Dict` --- **`docs`** `Optional[List[Document]]` --- **`enable_multi_step_generation`** `Optional[bool]` --- **`enable_rails_exceptions`** `bool` --- **`event_source_uid`** `str` --- **`flows`** `List[Union[Dict, Any]]` --- **`hooks_server`** `HooksServerConfig` --- **`import_paths`** `Optional[List[str]]` --- **`imported_paths`** `Optional[Dict[str, str]]` --- **`instructions`** `Optional[List[Instruction]]` --- **`knowledge_base`** `KnowledgeBaseConfig` --- **`lowest_temperature`** `Optional[float]` --- **`metrics`** `MetricsConfig` --- **`models`** `List[Model]` --- **`passthrough`** `Optional[bool]` --- **`prompting_mode`** `Optional[str]` --- **`prompts`** `Optional[List[TaskPrompt]]` --- **`rails`** `Rails` --- **`raw_llm_call_action`** `Optional[str]` --- **`sample_conversation`** `Optional[str]` --- **`streaming`** `bool` --- **`tracing`** `TracingConfig` --- **`user_messages`** `Dict[str, List[str]]` --- ```python nemoguardrails.RailsConfig.__add__( other ) ``` Adds two RailsConfig objects. ```python nemoguardrails.RailsConfig.check_jailbreak_detection_config( values ) ``` classmethod Validate jailbreak detection configuration against enabled flows. ```python nemoguardrails.RailsConfig.check_model_exists_for_input_rails( values ) ``` classmethod Make sure we have a model for each input rail where one is provided using \$model=\ ```python nemoguardrails.RailsConfig.check_model_exists_for_output_rails( values ) ``` classmethod Make sure we have a model for each output rail where one is provided using \$model=\ ```python nemoguardrails.RailsConfig.check_model_exists_for_tool_rails() -> nemoguardrails.rails.llm.config.RailsConfig ``` Make sure we have every model a tool rail's manifest binds, such as the judge named by `$model=` ```python nemoguardrails.RailsConfig.check_output_parser_exists( values ) ``` classmethod ```python nemoguardrails.RailsConfig.check_prompt_exist_for_self_check_rails( values ) ``` classmethod ```python nemoguardrails.RailsConfig.check_streaming_can_apply_output_rewrites( values ) ``` classmethod Reject configs whose output rails transform response with `stream_first` == True ```python nemoguardrails.RailsConfig.fill_in_default_values_for_v2_x( values ) ``` classmethod ```python nemoguardrails.RailsConfig.from_content( colang_content: typing.Optional[str] = None, yaml_content: typing.Optional[str] = None, config: typing.Optional[dict] = None ) ``` classmethod Loads a configuration from the provided colang/YAML content/config dict. ```python nemoguardrails.RailsConfig.from_path( config_path: str ) ``` classmethod Loads a configuration from a given path. Supports loading a from a single file, or from a directory. ```python nemoguardrails.RailsConfig.parse_object( obj ) ``` classmethod Parses a configuration object from a given dictionary. ```python nemoguardrails.RailsConfig.validate_models_api_key_env_var( models ) ``` classmethod Model API Key Env var must be set to make LLM calls ```python nemoguardrails.RailsConfig.warn_unknown_keys( values: typing.Any, handler: pydantic.ModelWrapValidatorHandler[nemoguardrails.rails.llm.config.RailsConfig] ) -> nemoguardrails.rails.llm.config.RailsConfig ``` classmethod ```python class nemoguardrails.Role ``` **Bases:** `enum.Enum` **`ASSISTANT`** `= 'assistant'` --- **`SYSTEM`** `= 'system'` --- **`TOOL`** `= 'tool'` --- **`USER`** `= 'user'` --- ```python class nemoguardrails.ToolCall( id: str, type: str = 'function', function: nemoguardrails.types.ToolCallFunction = (lambda: ToolCallFunction(n... ) ``` Dataclass **`function`** `ToolCallFunction` --- **`id`** `str` --- **`type`** `str = 'function'` --- ```python nemoguardrails.ToolCall.to_dict() -> typing.Dict[str, typing.Any] ``` ```python class nemoguardrails.ToolCallChunk( tool_calls: typing.List[nemoguardrails.types.ToolCall] ) ``` Dataclass A structured stream event containing completed tool calls, not argument fragments. **`tool_calls`** `List[ToolCall]` --- ```python class nemoguardrails.ToolCallDelta( index: int, id: typing.Optional[str] = None, type: typing.Optional[str] = None, function: typing.Optional[nemoguardrails.types.ToolCallFunctionDelta] = None ) ``` Dataclass **`function`** `Optional[ToolCallFunctionDelta] = None` --- **`id`** `Optional[str] = None` --- **`index`** `int` --- **`type`** `Optional[str] = None` --- ```python nemoguardrails.ToolCallDelta.to_dict() -> typing.Dict[str, typing.Any] ``` ```python class nemoguardrails.ToolCallDeltaChunk( tool_calls: typing.List[nemoguardrails.types.ToolCallDelta] = list(), finish_reason: typing.Optional[nemoguardrails.types.FinishReason] = None ) ``` Dataclass **`finish_reason`** `Optional[FinishReason] = None` --- **`tool_calls`** `List[ToolCallDelta] = field(default_factory=list)` --- ```python class nemoguardrails.ToolCallFunction( name: str, arguments: typing.Dict[str, typing.Any] ) ``` Dataclass **`arguments`** `Dict[str, Any]` --- **`name`** `str` --- ```python class nemoguardrails.ToolCallFunctionDelta( name: typing.Optional[str] = None, arguments: typing.Optional[str] = None ) ``` Dataclass **`arguments`** `Optional[str] = None` --- **`name`** `Optional[str] = None` --- ```python class nemoguardrails.UsageInfo( input_tokens: int = 0, output_tokens: int = 0, total_tokens: int = 0, reasoning_tokens: typing.Optional[int] = None, cached_tokens: typing.Optional[int] = None ) ``` Dataclass **`cached_tokens`** `Optional[int] = None` --- **`input_tokens`** `int = 0` --- **`output_tokens`** `int = 0` --- **`reasoning_tokens`** `Optional[int] = None` --- **`total_tokens`** `int = 0` --- ```python nemoguardrails.get_default_framework() -> str ``` ```python nemoguardrails.register_framework( name: str, framework: nemoguardrails.types.LLMFramework ) -> None ``` Register an `LLMFramework` instance under `name`. Validates two invariants before storing the instance: 1. The object structurally matches the `LLMFramework` Protocol (`create_model`, `register_provider`, `get_provider_names`, `reset`). 2. Its `reset` attribute is an `async` coroutine function. The registry awaits it directly during shutdown / test teardown. **Raises:** * `ValueError`: a framework is already registered under `name`. * `TypeError`: `framework` does not implement the `LLMFramework` Protocol, or its `reset` is not an async coroutine function. ```python nemoguardrails.register_provider( name: str, provider_cls: typing.Any ) -> None ``` ```python nemoguardrails.set_default_framework( name: str ) -> None ``` ```python nemoguardrails.types.FinishReason = Literal['stop', 'length', 'tool_calls', 'content_filter', 'error', 'other'] ``` ```python nemoguardrails.__version__ = version('nemoguardrails') ``` ```python nemoguardrails._use_guardrails_wrapper = os.environ.get('NEMO_GUARDRAILS_IORAILS_ENGINE', '').lower() in ('true', '1', 'y... ``` ## Docs - [nemoguardrails.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions.md) - [nemoguardrails.actions.action_dispatcher](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/action_dispatcher.md) - [nemoguardrails.actions.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/actions.md) - [nemoguardrails.actions.core](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/core.md) - [nemoguardrails.actions.llm](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/llm.md) - [nemoguardrails.actions.llm.generation](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/llm/generation.md) - [nemoguardrails.actions.llm.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/llm/utils.md) - [nemoguardrails.actions.llm_judge](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/llm_judge.md) - [nemoguardrails.actions.math](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/math.md) - [nemoguardrails.actions.rail_outcome](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/rail_outcome.md) - [nemoguardrails.actions.retrieve_relevant_chunks](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/retrieve_relevant_chunks.md) - [nemoguardrails.actions.v2_x](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/v2_x.md) - [nemoguardrails.actions.v2_x.generation](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/v2_x/generation.md) - [nemoguardrails.actions.validation](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/validation.md) - [nemoguardrails.actions.validation.base](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/validation/base.md) - [nemoguardrails.actions.validation.filter_secrets](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions/validation/filter_secrets.md) - [nemoguardrails.actions_server](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions_server.md) - [nemoguardrails.actions_server.actions_server](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/actions_server/actions_server.md) - [nemoguardrails.base_guardrails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/base_guardrails.md) - [nemoguardrails.cli](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/cli.md) - [nemoguardrails.cli.chat](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/cli/chat.md) - [nemoguardrails.cli.debugger](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/cli/debugger.md) - [nemoguardrails.cli.migration](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/cli/migration.md) - [nemoguardrails.cli.providers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/cli/providers.md) - [nemoguardrails.colang](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang.md) - [nemoguardrails.colang.runtime](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/runtime.md) - [nemoguardrails.colang.v1_0](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0.md) - [nemoguardrails.colang.v1_0.lang](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/lang.md) - [nemoguardrails.colang.v1_0.lang.colang_parser](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/lang/colang_parser.md) - [nemoguardrails.colang.v1_0.lang.comd_parser](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/lang/comd_parser.md) - [nemoguardrails.colang.v1_0.lang.coyml_parser](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/lang/coyml_parser.md) - [nemoguardrails.colang.v1_0.lang.parser](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/lang/parser.md) - [nemoguardrails.colang.v1_0.lang.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/lang/utils.md) - [nemoguardrails.colang.v1_0.runtime](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/runtime.md) - [nemoguardrails.colang.v1_0.runtime.eval](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/runtime/eval.md) - [nemoguardrails.colang.v1_0.runtime.flows](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/runtime/flows.md) - [nemoguardrails.colang.v1_0.runtime.runtime](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/runtime/runtime.md) - [nemoguardrails.colang.v1_0.runtime.sliding](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/runtime/sliding.md) - [nemoguardrails.colang.v1_0.runtime.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v1_0/runtime/utils.md) - [nemoguardrails.colang.v2_x](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x.md) - [nemoguardrails.colang.v2_x.lang](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang.md) - [nemoguardrails.colang.v2_x.lang.colang_ast](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang/colang_ast.md) - [nemoguardrails.colang.v2_x.lang.expansion](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang/expansion.md) - [nemoguardrails.colang.v2_x.lang.grammar](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang/grammar.md) - [nemoguardrails.colang.v2_x.lang.grammar.load](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang/grammar/load.md) - [nemoguardrails.colang.v2_x.lang.parser](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang/parser.md) - [nemoguardrails.colang.v2_x.lang.transformer](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang/transformer.md) - [nemoguardrails.colang.v2_x.lang.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/lang/utils.md) - [nemoguardrails.colang.v2_x.runtime](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime.md) - [nemoguardrails.colang.v2_x.runtime.errors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/errors.md) - [nemoguardrails.colang.v2_x.runtime.eval](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/eval.md) - [nemoguardrails.colang.v2_x.runtime.flows](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/flows.md) - [nemoguardrails.colang.v2_x.runtime.runtime](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/runtime.md) - [nemoguardrails.colang.v2_x.runtime.serialization](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/serialization.md) - [nemoguardrails.colang.v2_x.runtime.statemachine](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/statemachine.md) - [nemoguardrails.colang.v2_x.runtime.system_functions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/system_functions.md) - [nemoguardrails.colang.v2_x.runtime.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/colang/v2_x/runtime/utils.md) - [nemoguardrails.context](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/context.md) - [nemoguardrails.deprecation](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/deprecation.md) - [nemoguardrails.embeddings.index](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/index.md) - [nemoguardrails.embeddings.basic](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/basic.md) - [nemoguardrails.embeddings.cache](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/cache.md) - [nemoguardrails.embeddings.providers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers.md) - [nemoguardrails.embeddings.providers.azureopenai](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/azureopenai.md) - [nemoguardrails.embeddings.providers.base](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/base.md) - [nemoguardrails.embeddings.providers.cohere](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/cohere.md) - [nemoguardrails.embeddings.providers.fastembed](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/fastembed.md) - [nemoguardrails.embeddings.providers.google](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/google.md) - [nemoguardrails.embeddings.providers.nim](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/nim.md) - [nemoguardrails.embeddings.providers.openai](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/openai.md) - [nemoguardrails.embeddings.providers.registry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/registry.md) - [nemoguardrails.embeddings.providers.sentence_transformers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/embeddings/providers/sentence_transformers.md) - [nemoguardrails.eval](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval.md) - [nemoguardrails.eval.check](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/check.md) - [nemoguardrails.eval.cli](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/cli.md) - [nemoguardrails.eval.eval](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/eval.md) - [nemoguardrails.eval.models](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/models.md) - [nemoguardrails.eval.ui](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/ui.md) - [nemoguardrails.eval.ui.chart_utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/ui/chart_utils.md) - [nemoguardrails.eval.ui.common](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/ui/common.md) - [nemoguardrails.eval.ui.README](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/ui/README.md) - [nemoguardrails.eval.ui.streamlit_utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/ui/streamlit_utils.md) - [nemoguardrails.eval.ui.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/ui/utils.md) - [nemoguardrails.eval.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/eval/utils.md) - [nemoguardrails.evaluate](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate.md) - [nemoguardrails.evaluate.cli](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/cli.md) - [nemoguardrails.evaluate.cli.evaluate](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/cli/evaluate.md) - [nemoguardrails.evaluate.cli.simplify_formatter](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/cli/simplify_formatter.md) - [nemoguardrails.evaluate.evaluate_factcheck](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/evaluate_factcheck.md) - [nemoguardrails.evaluate.evaluate_hallucination](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/evaluate_hallucination.md) - [nemoguardrails.evaluate.evaluate_moderation](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/evaluate_moderation.md) - [nemoguardrails.evaluate.evaluate_topical](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/evaluate_topical.md) - [nemoguardrails.evaluate.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/evaluate/utils.md) - [nemoguardrails.exceptions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/exceptions.md) - [nemoguardrails.guardrails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails.md) - [nemoguardrails.guardrails.async_work_queue](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/async_work_queue.md) - [nemoguardrails.guardrails.base_engine](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/base_engine.md) - [nemoguardrails.guardrails.compiled_rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/compiled_rail.md) - [nemoguardrails.guardrails.engine_registry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/engine_registry.md) - [nemoguardrails.guardrails.guardrails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/guardrails.md) - [nemoguardrails.guardrails.guardrails_types](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/guardrails_types.md) - [nemoguardrails.guardrails.iorails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/iorails.md) - [nemoguardrails.guardrails.model_engine](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/model_engine.md) - [nemoguardrails.guardrails.rail_guard](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/rail_guard.md) - [nemoguardrails.guardrails.rails_manager](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/rails_manager.md) - [nemoguardrails.guardrails.telemetry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/telemetry.md) - [nemoguardrails.guardrails.tool_rail_action](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/tool_rail_action.md) - [nemoguardrails.guardrails.tool_schema](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/guardrails/tool_schema.md) - [nemoguardrails.http](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http.md) - [nemoguardrails.http.client](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/client.md) - [nemoguardrails.http.composition](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/composition.md) - [nemoguardrails.http.errors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/errors.md) - [nemoguardrails.http.instrumented](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/instrumented.md) - [nemoguardrails.http.request](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/request.md) - [nemoguardrails.http.retry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/retry.md) - [nemoguardrails.http.runtime](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/runtime.md) - [nemoguardrails.http.telemetry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/telemetry.md) - [nemoguardrails.http.transport](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/transport.md) - [nemoguardrails.http.types](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/http/types.md) - [nemoguardrails.imports](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/imports.md) - [nemoguardrails.integrations](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations.md) - [nemoguardrails.integrations.langchain](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain.md) - [nemoguardrails.integrations.langchain.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/actions.md) - [nemoguardrails.integrations.langchain.actions.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/actions/actions.md) - [nemoguardrails.integrations.langchain.actions.safetools](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/actions/safetools.md) - [nemoguardrails.integrations.langchain.exceptions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/exceptions.md) - [nemoguardrails.integrations.langchain.helpers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/helpers.md) - [nemoguardrails.integrations.langchain.langchain_initializer](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/langchain_initializer.md) - [nemoguardrails.integrations.langchain.llm_adapter](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/llm_adapter.md) - [nemoguardrails.integrations.langchain.message_utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/message_utils.md) - [nemoguardrails.integrations.langchain.middleware](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/middleware.md) - [nemoguardrails.integrations.langchain.providers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers.md) - [nemoguardrails.integrations.langchain.providers.huggingface](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers/huggingface.md) - [nemoguardrails.integrations.langchain.providers.huggingface.pipeline](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers/huggingface/pipeline.md) - [nemoguardrails.integrations.langchain.providers.huggingface.streamers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers/huggingface/streamers.md) - [nemoguardrails.integrations.langchain.providers.providers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers/providers.md) - [nemoguardrails.integrations.langchain.providers.trtllm](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers/trtllm.md) - [nemoguardrails.integrations.langchain.providers.trtllm.client](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers/trtllm/client.md) - [nemoguardrails.integrations.langchain.providers.trtllm.llm](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/providers/trtllm/llm.md) - [nemoguardrails.integrations.langchain.runnable_rails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/runnable_rails.md) - [nemoguardrails.integrations.langchain.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/integrations/langchain/utils.md) - [nemoguardrails.kb](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/kb.md) - [nemoguardrails.kb.kb](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/kb/kb.md) - [nemoguardrails.kb.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/kb/utils.md) - [nemoguardrails.library](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library.md) - [nemoguardrails.library.activefence](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/activefence.md) - [nemoguardrails.library.activefence.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/activefence/actions.md) - [nemoguardrails.library.activefence.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/activefence/rail.md) - [nemoguardrails.library.ai_defense](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/ai_defense.md) - [nemoguardrails.library.ai_defense.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/ai_defense/actions.md) - [nemoguardrails.library.ai_defense.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/ai_defense/rail.md) - [nemoguardrails.library.ai_defense.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/ai_defense/rail_config.md) - [nemoguardrails.library.autoalign](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/autoalign.md) - [nemoguardrails.library.autoalign.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/autoalign/actions.md) - [nemoguardrails.library.autoalign.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/autoalign/rail.md) - [nemoguardrails.library.autoalign.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/autoalign/rail_config.md) - [nemoguardrails.library.cel](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/cel.md) - [nemoguardrails.library.cel.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/cel/actions.md) - [nemoguardrails.library.cel.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/cel/rail.md) - [nemoguardrails.library.cel.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/cel/rail_config.md) - [nemoguardrails.library.clavata](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/clavata.md) - [nemoguardrails.library.clavata.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/clavata/actions.md) - [nemoguardrails.library.clavata.errs](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/clavata/errs.md) - [nemoguardrails.library.clavata.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/clavata/rail.md) - [nemoguardrails.library.clavata.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/clavata/rail_config.md) - [nemoguardrails.library.clavata.request](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/clavata/request.md) - [nemoguardrails.library.cleanlab](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/cleanlab.md) - [nemoguardrails.library.cleanlab.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/cleanlab/actions.md) - [nemoguardrails.library.cleanlab.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/cleanlab/rail.md) - [nemoguardrails.library.content_safety](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/content_safety.md) - [nemoguardrails.library.content_safety.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/content_safety/actions.md) - [nemoguardrails.library.content_safety.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/content_safety/rail.md) - [nemoguardrails.library.content_safety.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/content_safety/rail_config.md) - [nemoguardrails.library.context_bloat_detection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/context_bloat_detection.md) - [nemoguardrails.library.context_bloat_detection.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/context_bloat_detection/actions.md) - [nemoguardrails.library.context_bloat_detection.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/context_bloat_detection/rail.md) - [nemoguardrails.library.context_bloat_detection.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/context_bloat_detection/rail_config.md) - [nemoguardrails.library.crowdstrike_aidr](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/crowdstrike_aidr.md) - [nemoguardrails.library.crowdstrike_aidr.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/crowdstrike_aidr/actions.md) - [nemoguardrails.library.crowdstrike_aidr.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/crowdstrike_aidr/rail.md) - [nemoguardrails.library.crowdstrike_aidr.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/crowdstrike_aidr/rail_config.md) - [nemoguardrails.library.f5](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/f5.md) - [nemoguardrails.library.f5.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/f5/actions.md) - [nemoguardrails.library.f5.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/f5/rail.md) - [nemoguardrails.library.f5.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/f5/rail_config.md) - [nemoguardrails.library.factchecking](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking.md) - [nemoguardrails.library.factchecking.align_score](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking/align_score.md) - [nemoguardrails.library.factchecking.align_score.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking/align_score/actions.md) - [nemoguardrails.library.factchecking.align_score.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking/align_score/rail.md) - [nemoguardrails.library.factchecking.align_score.request](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking/align_score/request.md) - [nemoguardrails.library.factchecking.align_score.server](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking/align_score/server.md) - [nemoguardrails.library.factchecking.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking/rail.md) - [nemoguardrails.library.factchecking.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/factchecking/rail_config.md) - [nemoguardrails.library.fiddler](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/fiddler.md) - [nemoguardrails.library.fiddler.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/fiddler/actions.md) - [nemoguardrails.library.fiddler.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/fiddler/rail.md) - [nemoguardrails.library.fiddler.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/fiddler/rail_config.md) - [nemoguardrails.library.gcp_moderate_text](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gcp_moderate_text.md) - [nemoguardrails.library.gcp_moderate_text.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gcp_moderate_text/actions.md) - [nemoguardrails.library.gcp_moderate_text.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gcp_moderate_text/rail.md) - [nemoguardrails.library.gliner](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gliner.md) - [nemoguardrails.library.gliner.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gliner/actions.md) - [nemoguardrails.library.gliner.models](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gliner/models.md) - [nemoguardrails.library.gliner.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gliner/rail.md) - [nemoguardrails.library.gliner.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gliner/rail_config.md) - [nemoguardrails.library.gliner.request](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/gliner/request.md) - [nemoguardrails.library.guardrails_ai](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/guardrails_ai.md) - [nemoguardrails.library.guardrails_ai.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/guardrails_ai/actions.md) - [nemoguardrails.library.guardrails_ai.errors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/guardrails_ai/errors.md) - [nemoguardrails.library.guardrails_ai.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/guardrails_ai/rail.md) - [nemoguardrails.library.guardrails_ai.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/guardrails_ai/rail_config.md) - [nemoguardrails.library.guardrails_ai.registry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/guardrails_ai/registry.md) - [nemoguardrails.library.hallucination](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hallucination.md) - [nemoguardrails.library.hallucination.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hallucination/actions.md) - [nemoguardrails.library.hallucination.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hallucination/rail.md) - [nemoguardrails.library.hf_classifier](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hf_classifier.md) - [nemoguardrails.library.hf_classifier.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hf_classifier/actions.md) - [nemoguardrails.library.hf_classifier.backends](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hf_classifier/backends.md) - [nemoguardrails.library.hf_classifier.chunking](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hf_classifier/chunking.md) - [nemoguardrails.library.hf_classifier.compatibility](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hf_classifier/compatibility.md) - [nemoguardrails.library.hf_classifier.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hf_classifier/rail.md) - [nemoguardrails.library.hf_classifier.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/hf_classifier/rail_config.md) - [nemoguardrails.library.injection_detection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/injection_detection.md) - [nemoguardrails.library.injection_detection.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/injection_detection/actions.md) - [nemoguardrails.library.injection_detection.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/injection_detection/rail.md) - [nemoguardrails.library.injection_detection.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/injection_detection/rail_config.md) - [nemoguardrails.library.injection_detection.yara_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/injection_detection/yara_config.md) - [nemoguardrails.library.jailbreak_detection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection.md) - [nemoguardrails.library.jailbreak_detection.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/actions.md) - [nemoguardrails.library.jailbreak_detection.errors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/errors.md) - [nemoguardrails.library.jailbreak_detection.heuristics](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/heuristics.md) - [nemoguardrails.library.jailbreak_detection.heuristics.checks](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/heuristics/checks.md) - [nemoguardrails.library.jailbreak_detection.model_based](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/model_based.md) - [nemoguardrails.library.jailbreak_detection.model_based.checks](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/model_based/checks.md) - [nemoguardrails.library.jailbreak_detection.model_based.errors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/model_based/errors.md) - [nemoguardrails.library.jailbreak_detection.model_based.input_length](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/model_based/input_length.md) - [nemoguardrails.library.jailbreak_detection.model_based.models](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/model_based/models.md) - [nemoguardrails.library.jailbreak_detection.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/rail.md) - [nemoguardrails.library.jailbreak_detection.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/rail_config.md) - [nemoguardrails.library.jailbreak_detection.request](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/request.md) - [nemoguardrails.library.jailbreak_detection.server](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/jailbreak_detection/server.md) - [nemoguardrails.library.language_detector](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/language_detector.md) - [nemoguardrails.library.language_detector.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/language_detector/actions.md) - [nemoguardrails.library.language_detector.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/language_detector/rail.md) - [nemoguardrails.library.language_detector.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/language_detector/rail_config.md) - [nemoguardrails.library.llama_guard](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/llama_guard.md) - [nemoguardrails.library.llama_guard.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/llama_guard/actions.md) - [nemoguardrails.library.llama_guard.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/llama_guard/rail.md) - [nemoguardrails.library.pangea](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/pangea.md) - [nemoguardrails.library.pangea.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/pangea/actions.md) - [nemoguardrails.library.pangea.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/pangea/rail.md) - [nemoguardrails.library.pangea.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/pangea/rail_config.md) - [nemoguardrails.library.patronusai](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/patronusai.md) - [nemoguardrails.library.patronusai.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/patronusai/actions.md) - [nemoguardrails.library.patronusai.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/patronusai/rail.md) - [nemoguardrails.library.patronusai.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/patronusai/rail_config.md) - [nemoguardrails.library.policyai](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/policyai.md) - [nemoguardrails.library.policyai.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/policyai/actions.md) - [nemoguardrails.library.policyai.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/policyai/rail.md) - [nemoguardrails.library.polygraf](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/polygraf.md) - [nemoguardrails.library.polygraf.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/polygraf/actions.md) - [nemoguardrails.library.polygraf.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/polygraf/rail.md) - [nemoguardrails.library.polygraf.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/polygraf/rail_config.md) - [nemoguardrails.library.polygraf.request](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/polygraf/request.md) - [nemoguardrails.library.privateai](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/privateai.md) - [nemoguardrails.library.privateai.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/privateai/actions.md) - [nemoguardrails.library.privateai.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/privateai/rail.md) - [nemoguardrails.library.privateai.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/privateai/rail_config.md) - [nemoguardrails.library.privateai.request](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/privateai/request.md) - [nemoguardrails.library.prompt_security](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/prompt_security.md) - [nemoguardrails.library.prompt_security.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/prompt_security/actions.md) - [nemoguardrails.library.prompt_security.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/prompt_security/rail.md) - [nemoguardrails.library.regex](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/regex.md) - [nemoguardrails.library.regex.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/regex/actions.md) - [nemoguardrails.library.regex.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/regex/rail.md) - [nemoguardrails.library.regex.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/regex/rail_config.md) - [nemoguardrails.library.self_check](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check.md) - [nemoguardrails.library.self_check.facts](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/facts.md) - [nemoguardrails.library.self_check.facts.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/facts/actions.md) - [nemoguardrails.library.self_check.facts.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/facts/rail.md) - [nemoguardrails.library.self_check.input_check](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/input_check.md) - [nemoguardrails.library.self_check.input_check.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/input_check/actions.md) - [nemoguardrails.library.self_check.input_check.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/input_check/rail.md) - [nemoguardrails.library.self_check.output_check](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/output_check.md) - [nemoguardrails.library.self_check.output_check.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/output_check/actions.md) - [nemoguardrails.library.self_check.output_check.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/output_check/rail.md) - [nemoguardrails.library.self_check.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/self_check/utils.md) - [nemoguardrails.library.sensitive_data_detection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/sensitive_data_detection.md) - [nemoguardrails.library.sensitive_data_detection.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/sensitive_data_detection/actions.md) - [nemoguardrails.library.sensitive_data_detection.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/sensitive_data_detection/rail.md) - [nemoguardrails.library.sensitive_data_detection.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/sensitive_data_detection/rail_config.md) - [nemoguardrails.library.tool_safety_check](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/tool_safety_check.md) - [nemoguardrails.library.tool_safety_check.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/tool_safety_check/actions.md) - [nemoguardrails.library.tool_safety_check.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/tool_safety_check/rail.md) - [nemoguardrails.library.topic_safety](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/topic_safety.md) - [nemoguardrails.library.topic_safety.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/topic_safety/actions.md) - [nemoguardrails.library.topic_safety.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/topic_safety/rail.md) - [nemoguardrails.library.trend_micro](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/trend_micro.md) - [nemoguardrails.library.trend_micro.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/trend_micro/actions.md) - [nemoguardrails.library.trend_micro.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/trend_micro/rail.md) - [nemoguardrails.library.trend_micro.rail_config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/trend_micro/rail_config.md) - [nemoguardrails.library.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/utils.md) - [nemoguardrails.library.utils.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/utils/actions.md) - [nemoguardrails.library.utils.language_detection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/utils/language_detection.md) - [nemoguardrails.library.zscaler_aiguard](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/zscaler_aiguard.md) - [nemoguardrails.library.zscaler_aiguard.actions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/zscaler_aiguard/actions.md) - [nemoguardrails.library.zscaler_aiguard.rail](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/library/zscaler_aiguard/rail.md) - [nemoguardrails.llm](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm.md) - [nemoguardrails.llm.cache](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/cache.md) - [nemoguardrails.llm.cache.interface](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/cache/interface.md) - [nemoguardrails.llm.cache.lfu](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/cache/lfu.md) - [nemoguardrails.llm.cache.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/cache/utils.md) - [nemoguardrails.llm.call](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/call.md) - [nemoguardrails.llm.clients](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/clients.md) - [nemoguardrails.llm.clients.base](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/clients/base.md) - [nemoguardrails.llm.clients.constants](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/clients/constants.md) - [nemoguardrails.llm.clients.openai_compatible](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/clients/openai_compatible.md) - [nemoguardrails.llm.completion_parsing](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/completion_parsing.md) - [nemoguardrails.llm.constants](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/constants.md) - [nemoguardrails.llm.filters](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/filters.md) - [nemoguardrails.llm.frameworks](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/frameworks.md) - [nemoguardrails.llm.frameworks.default](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/frameworks/default.md) - [nemoguardrails.llm.frameworks.registry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/frameworks/registry.md) - [nemoguardrails.llm.openai_reasoning](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/openai_reasoning.md) - [nemoguardrails.llm.output_parsers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/output_parsers.md) - [nemoguardrails.llm.prompts](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/prompts.md) - [nemoguardrails.llm.providers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/providers.md) - [nemoguardrails.llm.taskmanager](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/taskmanager.md) - [nemoguardrails.llm.telemetry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/telemetry.md) - [nemoguardrails.llm.types](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/llm/types.md) - [nemoguardrails.logging](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging.md) - [nemoguardrails.logging.explain](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging/explain.md) - [nemoguardrails.logging.llm_tracker](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging/llm_tracker.md) - [nemoguardrails.logging.processing_log](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging/processing_log.md) - [nemoguardrails.logging.simplify_formatter](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging/simplify_formatter.md) - [nemoguardrails.logging.stats](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging/stats.md) - [nemoguardrails.logging.verbose](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/logging/verbose.md) - [nemoguardrails.manifests](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/manifests.md) - [nemoguardrails.manifests.catalog](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/manifests/catalog.md) - [nemoguardrails.manifests.config_schema](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/manifests/config_schema.md) - [nemoguardrails.manifests.manifest](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/manifests/manifest.md) - [nemoguardrails.manifests.registry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/manifests/registry.md) - [nemoguardrails.manifests.surface_reference](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/manifests/surface_reference.md) - [nemoguardrails.patch_asyncio](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/patch_asyncio.md) - [nemoguardrails.rails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails.md) - [nemoguardrails.rails.llm](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm.md) - [nemoguardrails.rails.llm.buffer](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/buffer.md) - [nemoguardrails.rails.llm.config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/config.md) - [nemoguardrails.rails.llm.llmrails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/llmrails.md) - [nemoguardrails.rails.llm.options](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/options.md) - [nemoguardrails.rails.llm.rails_config_fields](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/rails_config_fields.md) - [nemoguardrails.rails.llm.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/rails/llm/utils.md) - [nemoguardrails.registry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/registry.md) - [nemoguardrails.server](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server.md) - [nemoguardrails.server.api](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/api.md) - [nemoguardrails.server.app](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/app.md) - [nemoguardrails.server.datastore](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/datastore.md) - [nemoguardrails.server.datastore.datastore](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/datastore/datastore.md) - [nemoguardrails.server.datastore.memory_store](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/datastore/memory_store.md) - [nemoguardrails.server.datastore.redis_store](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/datastore/redis_store.md) - [nemoguardrails.server.exception_handlers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/exception_handlers.md) - [nemoguardrails.server.experimental](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental.md) - [nemoguardrails.server.experimental.application](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/application.md) - [nemoguardrails.server.experimental.cli](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/cli.md) - [nemoguardrails.server.experimental.provider](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider.md) - [nemoguardrails.server.experimental.provider.contract_export](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/contract_export.md) - [nemoguardrails.server.experimental.provider.endpoint](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/endpoint.md) - [nemoguardrails.server.experimental.provider.errors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/errors.md) - [nemoguardrails.server.experimental.provider.integration](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/integration.md) - [nemoguardrails.server.experimental.provider.payload](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/payload.md) - [nemoguardrails.server.experimental.provider.projection_policy](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/projection_policy.md) - [nemoguardrails.server.experimental.provider.sse](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/sse.md) - [nemoguardrails.server.experimental.provider.stream](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/stream.md) - [nemoguardrails.server.experimental.provider.stream_classifier](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/stream_classifier.md) - [nemoguardrails.server.experimental.provider.stream_policy](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/stream_policy.md) - [nemoguardrails.server.experimental.provider.transport](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/transport.md) - [nemoguardrails.server.experimental.provider.types](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/provider/types.md) - [nemoguardrails.server.experimental.providers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers.md) - [nemoguardrails.server.experimental.providers.openai](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.endpoint](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/endpoint.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.request_binding](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/request_binding.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.request_projection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/request_projection.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.response_binding](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/response_binding.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.response_projection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/response_projection.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.stream_classifier](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/stream_classifier.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.stream_hooks](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/stream_hooks.md) - [nemoguardrails.server.experimental.providers.openai.chat_completions.stream_projection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/chat_completions/stream_projection.md) - [nemoguardrails.server.experimental.providers.openai.dialects](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/dialects.md) - [nemoguardrails.server.experimental.providers.openai.dialects.litellm](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/dialects/litellm.md) - [nemoguardrails.server.experimental.providers.openai.dialects.litellm.chat_completions](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/dialects/litellm/chat_completions.md) - [nemoguardrails.server.experimental.providers.openai.dialects.litellm.responses](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/dialects/litellm/responses.md) - [nemoguardrails.server.experimental.providers.openai.dialects.litellm.stream](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/dialects/litellm/stream.md) - [nemoguardrails.server.experimental.providers.openai.errors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/errors.md) - [nemoguardrails.server.experimental.providers.openai.integration](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/integration.md) - [nemoguardrails.server.experimental.providers.openai.responses](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses.md) - [nemoguardrails.server.experimental.providers.openai.responses.endpoint](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/endpoint.md) - [nemoguardrails.server.experimental.providers.openai.responses.request_binding](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/request_binding.md) - [nemoguardrails.server.experimental.providers.openai.responses.request_projection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/request_projection.md) - [nemoguardrails.server.experimental.providers.openai.responses.response_binding](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/response_binding.md) - [nemoguardrails.server.experimental.providers.openai.responses.response_projection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/response_projection.md) - [nemoguardrails.server.experimental.providers.openai.responses.stream_classifier](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/stream_classifier.md) - [nemoguardrails.server.experimental.providers.openai.responses.stream_hooks](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/stream_hooks.md) - [nemoguardrails.server.experimental.providers.openai.responses.stream_projection](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/responses/stream_projection.md) - [nemoguardrails.server.experimental.providers.openai.source](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/providers/openai/source.md) - [nemoguardrails.server.experimental.rails](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/rails.md) - [nemoguardrails.server.experimental.rails.config](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/rails/config.md) - [nemoguardrails.server.experimental.routers](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/routers.md) - [nemoguardrails.server.experimental.routers.passthrough](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/experimental/routers/passthrough.md) - [nemoguardrails.server.hooks](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/hooks.md) - [nemoguardrails.server.hooks.adapters](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/hooks/adapters.md) - [nemoguardrails.server.hooks.app](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/hooks/app.md) - [nemoguardrails.server.hooks.checking](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/hooks/checking.md) - [nemoguardrails.server.hooks.schemas](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/hooks/schemas.md) - [nemoguardrails.server.hooks.tool_policy](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/hooks/tool_policy.md) - [nemoguardrails.server.metrics](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/server/metrics.md) - [nemoguardrails.singleton](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/singleton.md) - [nemoguardrails.streaming](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/streaming.md) - [nemoguardrails.telemetry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/telemetry.md) - [nemoguardrails.testing](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/testing.md) - [nemoguardrails.testing.chat_harness](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/testing/chat_harness.md) - [nemoguardrails.testing.fake_model](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/testing/fake_model.md) - [nemoguardrails.testing.fixtures](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/testing/fixtures.md) - [nemoguardrails.testing.http](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/testing/http.md) - [nemoguardrails.tracing](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing.md) - [nemoguardrails.tracing.adapters](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/adapters.md) - [nemoguardrails.tracing.adapters.base](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/adapters/base.md) - [nemoguardrails.tracing.adapters.filesystem](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/adapters/filesystem.md) - [nemoguardrails.tracing.adapters.opentelemetry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/adapters/opentelemetry.md) - [nemoguardrails.tracing.adapters.registry](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/adapters/registry.md) - [nemoguardrails.tracing.constants](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/constants.md) - [nemoguardrails.tracing.interaction_types](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/interaction_types.md) - [nemoguardrails.tracing.span_extractors](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/span_extractors.md) - [nemoguardrails.tracing.span_format](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/span_format.md) - [nemoguardrails.tracing.span_formatting](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/span_formatting.md) - [nemoguardrails.tracing.spans](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/spans.md) - [nemoguardrails.tracing.tracer](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/tracing/tracer.md) - [nemoguardrails.types](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/types.md) - [nemoguardrails.utils](https://docs.nvidia.com/nemo/guardrails/v0.25.0/guardrails-python-sdk/nemoguardrails/utils.md)