Guardrails: Enhancing LLM Reliability and Structured Data Generation

Introduction

Guardrails is an open-source Python framework developed by guardrails-ai, aimed at enhancing the reliability and safety of applications built with large language models (LLMs). It serves two primary functions: implementing Input/Output Guards to detect, quantify, and mitigate specific risks, and enabling the generation of structured data from LLMs. With Guardrails, developers can ensure their AI applications are more robust and produce predictable, well-formatted outputs.

Installation

To get started with Guardrails, you can install it using pip:

pip install guardrails-ai

After installation, you can configure the Guardrails Hub CLI:

guardrails configure

Examples

Guardrails offers powerful capabilities for both validating LLM inputs/outputs and generating structured data.

Creating Input and Output Guards for LLM Validation

Guardrails allows you to define and apply validators to your LLM interactions. For instance, you can use pre-built validators from the Guardrails Hub to check for specific patterns or content.

First, install a guardrail, for example, regex_match:

guardrails hub install hub://guardrails/regex_match

Then, create a Guard and use the validator:

from guardrails import Guard, OnFailAction
from guardrails.hub import RegexMatch

guard = Guard().use(
    RegexMatch, regex="\\(?\\d{3}\\)?-? *\\d{3}-? *-?\\d{4}", on_fail=OnFailAction.EXCEPTION
)

guard.validate("123-456-7890")  # Guardrail passes

try:
    guard.validate("1234-789-0000")  # Guardrail fails
except Exception as e:
    print(e)

You can also combine multiple guardrails to enforce complex validation rules:

guardrails hub install hub://guardrails/competitor_check
guardrails hub install hub://guardrails/toxic_language

from guardrails import Guard, OnFailAction
from guardrails.hub import CompetitorCheck, ToxicLanguage

guard = Guard().use(
    CompetitorCheck(["Apple", "Microsoft", "Google"], on_fail=OnFailAction.EXCEPTION),
    ToxicLanguage(threshold=0.5, validation_method="sentence", on_fail=OnFailAction.EXCEPTION)
)

guard.validate(
    """An apple a day keeps a doctor away.
    This is good advice for keeping your health."""
)  # Both the guardrails pass

try:
    guard.validate(
        """Shut the hell up! Apple just released a new iPhone."""
    )  # Both the guardrails fail
except Exception as e:
    print(e)

Using Guardrails to Generate Structured Data from LLMs

Guardrails can ensure that LLM outputs adhere to a predefined structure, such as a Pydantic BaseModel.

Define your desired output structure:

from pydantic import BaseModel, Field

class Pet(BaseModel):
    pet_type: str = Field(description="Species of pet")
    name: str = Field(description="a unique pet name")

Then, use Guardrails to call the LLM and format its output:

from guardrails import Guard
import openai

prompt = """
    What kind of pet should I get and what should I name it?

    ${gr.complete_json_suffix_v2}
"""
guard = Guard.for_pydantic(output_class=Pet, prompt=prompt)

raw_output, validated_output, *rest = guard(
    llm_api=openai.completions.create,
    engine="gpt-3.5-turbo-instruct"
)

print(validated_output)

This will produce structured output like:

{
    "pet_type": "dog",
    "name": "Buddy"
}

Why Use Guardrails

Guardrails addresses critical challenges in LLM development by providing a robust framework for reliability and safety. By implementing Input/Output Guards, it helps prevent undesirable or unsafe content from entering or leaving your LLM applications. Its ability to enforce structured outputs simplifies downstream processing and integration, making LLM interactions more predictable and manageable. This leads to more stable, secure, and production-ready AI systems.