What Guardrails also does, and what it is not
Twenty-six lessons covered the parts of Guardrails you need to guard an application. This page names the rest honestly, so nothing is left as an unexplained gap, and then clears up the name it shares with a different product.
Pages this course did not teach
| Area | What it is | Why it was left out |
|---|---|---|
| Performance | Latency budgets, where the time goes in a Guard | Advice rather than an API; worth reading once your desk is live |
| Concurrency | How the validation loop is orchestrated internally | A design note on the library, not something you call |
| Async streaming | Streaming through AsyncGuard | Lessons 21 and 22 separately; combining them adds no new idea |
| Streaming structured data | Objects arriving field by field | Needs a real model to be worth watching |
| Handling fix results for streaming | How overlapping repairs are merged | Lesson 21 names the merge; the detail is one page when you hit it |
| FAQs | Assorted answers | Reference |
| Chatbot sample app | A guarded chat loop | Lesson 24 is this, built up rather than handed over |
| Summarizer sample app | Length and quality rules on a summary | Same shape as lesson 24 with different validators |
Whole areas this course stayed out of
- The Guardrails Server. A FastAPI service that holds your guards, so any language can call them over REST. It has its own CLI (
guardrails start), a Docker image, a Postgres mode and a deployment guide for AWS. - Validators that carry a model. Toxicity, PII detection, competitor lists, topic relevance, gibberish, jailbreak detection. Same
Guard().use(...)you already know, with a download attached. Start with the hub listing and read what each one pulls. - Remote validation inference. Running those models on a server instead of in your process. The Guardrails-hosted version shuts down on 6 August 2026;
use_local=Trueor your ownvalidation_endpointare what remain. - Telemetry. Guardrails emits OpenTelemetry spans, with pages for Grafana, Arize, OpenLIT and MLflow.
- Integrations. LangChain, LlamaIndex and MLflow GenAI have their own pages.
- RAIL. The original XML format for describing a guard. Still supported, no longer the recommended way, and the migration guides from 0.2 onwards trace how it got there.
The other Guardrails
Search for guardrails and you will find two libraries with almost the same name. They are not the same thing and they do not compete cleanly.
| Guardrails AI | NVIDIA NeMo Guardrails | |
|---|---|---|
| The package | guardrails-ai | nemoguardrails |
| The unit | A validator: a Python check on one value | A rail: a conversational flow |
| How you write rules | Python classes and on_fail actions | Colang, a language for dialogue flows |
| Where it sits | Around one model call, on input or output | Around the conversation, deciding what to do next |
| Typical use | This reply must not promise a refund | If the user asks about politics, change the subject |
Guardrails AI is narrow and sharp: one value, one rule, one decision about what to do when the rule fails. NeMo Guardrails is broader and heavier: it models the conversation, and a rail can decide to run a different flow rather than repair a string. Applications use both, with NeMo choosing what happens and Guardrails AI checking what is about to be said.
If you followed the on-fail actions in part 3, you have the thing that distinguishes Guardrails AI. Almost nothing else gives you seven named answers to the question of what to do when a check fails.
Where to go next
- Read the Migrating to 0.11.0 page before you copy anything from an older tutorial; the hub changed underneath almost every example online.
- Pick one model-backed validator from the hub and add it to the desk from lesson 24 with
on_fail="noop". Measure for a week before letting it act. - Put the desk behind the Guardrails Server if something other than Python needs to call it.
- A Guard holds validators; a validator returns PassResult or FailResult; on_fail decides what happens next.
- The default on_fail is exception, not noop, whatever the documentation says.
- Chained use() calls on the same target overwrite each other. Pass validators together.
- validated_output is None whenever the Guard will not vouch for a value; the history says why.
- Guardrails does not put the schema in your prompt unless you interpolate it.
- A model is a callable that takes messages and returns a string, which is why none of this needs a key.
- Pick one row from the first table and read that page. It will take ten minutes and you already know the vocabulary.
- Add a model-backed validator to the lesson 24 desk and time the call before and after.
- Write the one rule your own application needs most as a validator, with an error_message you would be happy for a model to read.
Little by little, you're building something great.