Guardrails Agent工作流

Requirements

Python 3.10, 3.11, 3.12 or 3.13.

Installation

To install using pip:

> pip install nemoguardrails

For more detailed instructions, see the Installation Guide.

Use Cases

You can use programmable guardrails in different types of use cases:

1. Question Answering over a set of documents (a.k.a. Retrieval Augmented Generation): Enforce fact-checking and output moderation.
2. Domain-specific Assistants (a.k.a. chatbots): Ensure the assistant stays on topic and follows the designed conversational flows.
3. LLM Endpoints: Add guardrails to your custom LLM for safer customer interaction.
4. LangChain Chains (optional): If you use LangChain for any use case, you can add a guardrails layer around your chains. To enable this integration, set the NEMOGUARDRAILS_LLM_FRAMEWORK=langchain environment variable or call set_default_framework("langchain").

Usage

To add programmable guardrails to your application you can use the Python API or a guardrails server (see the Server Guide for more details). Using the Python API is similar to using the LLM directly. Calling the guardrails layer instead of the LLM requires only minimal changes to the code base, and it involves two simple steps:

1. Loading a guardrails configuration and creating an LLMRails instance.
2. Making the calls to the LLM using the generate/generate_async methods.

```python from nemoguardrails import LLMRails, RailsConfig

Load a guardrails configuration from the specified path.

config = RailsConfig.from_path("PATH/TO/CONFIG") rails = LLMRails(config)

completion = rails.generate( messages=[{"role": "user", "content": "Hello world!"}] )

Sample output:

The input and output format for the generate method is similar to the Chat Completions API from OpenAI.

Async API

The NeMo Guardrails library is an async-first toolkit as the core mechanics are implemented using the Python async model. The public methods have both a sync and an async version. For example: LLMRails.generate and LLMRails.generate_async.

Guardrails Configuration

A guardrails configuration defines the LLM(s) to be used and one or more guardrails. A guardrails configuration can include any number of input/dialog/output/retrieval/execution rails. A configuration without any configured rails will essentially forward the requests to the LLM.

The standard structure for a guardrails configuration folder looks like this:

.
├── config
│   ├── actions.py
│   ├── config.py
│   ├── config.yml
│   ├── rails.co
│   ├── ...

The config.yml contains all the general configuration options, such as LLM models, active rails, and custom configuration data". The config.py file contains any custom initialization code and the actions.py contains any custom python actions. For a complete overview, see the Configuration Guide.

Below is an example config.yml:

```yaml

config.yml

models: - type: main engine: openai model: gpt-3.5-turbo-instruct

rails: # Input rails are invoked when new input from the user is received. input: flows: - check jailbreak - mask sensitive data on input

# Output rails are triggered after a bot message has been generated. output: flows: - self check facts - self check hallucination - activefence moderation on input

config: # Configure the types of entities that should be masked on user input. sensitive_data_detection: input: entities: - PERSON - EMAIL_ADDRESS

The `.co` files included in a guardrails configuration contain the Colang definitions (see the next section for a quick overview of what Colang is) that define various types of rails. Below is an example `greeting.co` file which defines the dialog rails for greeting the user.

define flow user express greeting bot express greeting bot offer to help

define bot express greeting "Hello there!"

define bot offer to help "How can I help you today?"

Below is an additional example of Colang definitions for a dialog rail against insults:

define flow user express insult bot express calmly willingness to help ```

Integration with LangChain (Optional)

LangChain integration is opt-in. To enable it, set the NEMOGUARDRAILS_LLM_FRAMEWORK=langchain environment variable or call set_default_framework("langchain"). Then install the LangChain packages your configuration requires. After you enable the integration, you can wrap a guardrails configuration around a LangChain chain (or any Runnable), and you can call a LangChain chain from within a guardrails configuration. For more information, refer to the LangChain Integration Documentation.