Overview

Guard adds guardrails to your large language model (LLM) application. This page covers what Guard checks for and how to run it on prompts and responses.

What Guard protects against

Guard is part of the Python software development kit (SDK). You build an ordered list of guards, and each guard checks a piece of text for one kind of problem. Use Guard to stop leaked secrets, prompt-injection attempts, and malformed output before they reach the model or your users.

The SDK includes the following guards.

Import the guard classes from acceldata_aio_tracer or from acceldata_aio_tracer.guard. For every parameter of each guard, see the Python SDK reference.

How it works

1. You pick the guards and their order. Each guard has an action that sets what it does when it finds a problem:

• allow: let the text through.
• warn: let the text through and record the finding.
• redact: let a rewritten copy of the text through. For example, PII replaces an email address with [REDACTED:email].
• deny: block the text.

2. The guards run at a phase. The preflight phase checks the prompt before the model call. The postflight phase checks the response after the model call. A guard that doesn't support the current phase is skipped.
3. The guards run in list order. When a guard redacts text, the guards after it receive the redacted text. When a guard returns deny, the run stops and no later guard runs.
4. You get one overall result. The overall action is the most severe action any guard returned, from least to most severe: allow, warn, redact, deny.
5. Each check is recorded. Every guard evaluation adds a guard.evaluation event to the current span of your trace and increments the guard.requests metric, if metrics are set up.

Turn on Guard

To turn Guard on, build a Pipeline and call evaluate on each prompt and response. Before you start, install the SDK as described in Instrument your code.

from acceldata_aio_tracer import PII, Moderation, Pipeline, PromptInjection
pipeline = Pipeline(guards=[PromptInjection(), PII(), Moderation()])
prompt = "My email is jane.doe@example.com. Summarize my last order."
result = pipeline.evaluate(prompt, phase="preflight")
if result.action.value == "deny":
    raise RuntimeError(f"Prompt blocked: {result.explanation}")
if result.transformed_text is not None:
    prompt = result.transformed_text
print(result.action.value)
print(prompt)

The PII guard finds the email address and redacts it, so the example prints:

redact
My email is [REDACTED:email]. Summarize my last order.

To check the model's response, call pipeline.evaluate(response_text, phase="postflight") with the response text.

The PipelineResult that evaluate returns has these fields:

• action: the overall action.
• results: one result for each guard that ran.
• transformed_text: the final text, if a guard changed it. Otherwise, None.
• explanation: what each guard found, joined with semicolons.

Choose what happens when a guard fails

A pipeline is fail-open by default. If a guard raises an exception, its result counts as allow, and the SDK logs a warning such as Guard 'pii' raised during preflight evaluation; fail-open -> allow. To raise the guard's exception instead, create the pipeline with Pipeline(guards=[...], fail_open=False).

Next steps

• Python SDK
• Instrument your code
• Explore traces
• Redaction overview