Guardrails AI

By Guardrails AI

Validate and structure LLM input/output with composable validators from the Guardrails Hub.

Website ↗ Repository ↗ Docs ↗

v0.10.22026-06-04PythonApache-2.0

#guardrails #validation #safety #python

7.2k Open source Paid

Doc version 1.0 · Updated June 28, 2026

Related concepts

Harness Engineering Doc version 1.0 · Updated June 28, 2026 Wrapping an LLM in scaffolding — a control loop, tools, a sandbox, guardrails, and evaluation — so it behaves reliably in production.

Related tools

NeMo Guardrails

Guardrails & Safety

instructor

Structured Output & Typing

Overview

Guardrails AI is a Python framework that validates and structures LLM input and output using composable validators pulled from the Guardrails Hub.
You build a Guard from one or more validators — PII, jailbreak, format, factuality — and it intercepts the model’s text to pass, fix, or reject it.

flowchart LR
  llm[LLM output] --> guard[Guard]
  guard --> validators[validators]
  guard --> ok[valid / fixed]

The Code samples tab shows building a Guard from a Hub validator and checking output.

When to use it

Choose Guardrails AI when LLM I/O must obey concrete rules — strip PII, enforce a schema, block jailbreaks — and you want to mix and match ready-made validators from the Hub rather than hand-roll checks.

Example

Python · validate output

When to use

Reach for Guardrails AI when an LLM's I/O must satisfy rules — no PII, valid JSON, a known format — before it reaches users or downstream code.

How it flows

You compose Hub validators onto a Guard; validate checks the text and either passes, fixes, or raises on failure.

Structure

flowchart LR
  llm[LLM output] --> guard[Guard]
  guard --> validators[validators]
  guard --> ok[valid / fixed]

from guardrails import Guard, OnFailAction
from guardrails.hub import RegexMatch  # guardrails hub install hub://guardrails/regex_match

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

outcome = guard.validate("123-456-7890")
print(outcome.validation_passed)  # -> True

Example

Guardrails AI — implementation sample

A real, runnable mini-project. Download it and run with Docker.

View samples/guardrails-ai_1 on GitHub ↗

June 28, 2026

Guardrails AI — implementation sample

A tiny Guardrails AI sample: it asks an LLM for JSON, then validates that output against a Pydantic schema — coercing types and enforcing age >= 0 — before you trust it.

Configure

cd samples/guardrails-ai_1
cp .env.sample .env
# edit .env: set OPENAI_API_KEY (used for the LLM call)

Run with Docker

cd samples/guardrails-ai_1
docker build -t aas-guardrails .
docker run --rm --env-file .env aas-guardrails

Run with Docker (in a devcontainer with DooD)

The foreground docker run may print nothing under Docker-outside-of-Docker — run detached and follow the logs:

docker logs -f "$(docker run -d --env-file .env aas-guardrails)"

Run locally

cd samples/guardrails-ai_1
pip install -r requirements.txt
python app.py

Example run

The model returns the JSON (with Rex, dog, 3), and the Guard parses and validates it against the schema. One run with gpt-4o-mini:

validation passed: True
validated output: {'name': 'Rex', 'species': 'dog', 'age': 3}

Files

.env.sample

# Copy to `.env` and add your OpenAI API key (used for the guarded LLM call).
#   cp .env.sample .env
OPENAI_API_KEY=

MODEL=gpt-4o-mini

app.py

"""Guardrails AI: validate an LLM's output against a typed schema.

The model is asked for JSON (our prompt), then a Guard built from a Pydantic
schema parses and validates that output — coercing types and enforcing
constraints (here, age >= 0) before you trust it. The LLM call uses
OPENAI_API_KEY via LiteLLM.

Run:
    docker build -t aas-guardrails .
    docker run --rm --env-file .env aas-guardrails
"""

import os

from dotenv import load_dotenv
from pydantic import BaseModel, Field
from guardrails import Guard
from litellm import completion

load_dotenv()

MODEL = os.environ.get("MODEL", "gpt-4o-mini")


class Pet(BaseModel):
    name: str = Field(description="the pet's name")
    species: str = Field(description="the kind of animal, e.g. dog or cat")
    age: int = Field(description="age in whole years", ge=0)


def main() -> None:
    # 1) The model produces output from our prompt — we control what it sees.
    raw = completion(
        model=MODEL,
        temperature=0,
        messages=[
            {
                "role": "user",
                "content": (
                    "Extract the pet into a JSON object with keys name, species, age. "
                    "Return only the JSON.\n\nSentence: Rex is a three-year-old dog."
                ),
            }
        ],
    ).choices[0].message.content

    # 2) Guardrails parses + validates that output against the Pet schema.
    guard = Guard.for_pydantic(Pet)
    outcome = guard.parse(raw)

    print("raw model output:", raw)
    print("validation passed:", outcome.validation_passed)
    print("validated output:", outcome.validated_output)


if __name__ == "__main__":
    main()

Dockerfile

FROM python:3.13-slim

ENV PYTHONUNBUFFERED=1

WORKDIR /app

COPY requirements.txt .
RUN pip install --no-cache-dir -r requirements.txt

COPY app.py .

ENTRYPOINT ["python", "app.py"]