Skip to main content
Guardrails are runtime checks that help you enforce constraints on your AI system’s inputs and outputs.

​
Guardrails vs. Tests

Guardrails complement tests, in particular in monitoring mode. While your Openlayer tests run continuously on top of your live data and trigger a notification in case of failure, guardrails validate inputs and outputs in real time and block or modify them if they don’t meet your constraints. Together, they give you both proactive coverage (through tests) and reactive protection (through guardrails).
Guardrails are not a replacement for tests. They are a complementary tool to help you ensure that your AI system is safe and compliant. Furthermore, it is worth noting that guardrails introduce latency in your system, as they need to validate inputs and outputs in real time.

​
Guardrails library

Openlayer has a Python library for guardrails. You can use one of the built-in guardrails (such as the PII or prompt injection), or implement custom guardrails following the interface defined in the BaseGuardrail class. You can install it with: 
pip install openlayer-guardrails
Some guardrails require additional dependencies. Install them using the extras for the specific guardrail you need:
GuardrailExtraInstall command
PIIGuardrailpiipip install openlayer-guardrails[pii]
PromptInjectionGuardrailprompt-injectionpip install openlayer-guardrails[prompt-injection]
If you try to use a guardrail without its required dependencies, you’ll see an error message with the exact install command needed.

​
With Openlayer tracing

Guardrails work well with Openlayer tracing. In this case, you can pass the desired guardrails to the trace decorator, and they will be applied to the inputs and outputs of the traced function.
Prerequisites: Besides the openlayer-guardrails, you need to have the openlayer library installed and have tracing correctly configured in your project to run the example below.
from openlayer_guardrails import PIIGuardrail
from openlayer.lib.tracing import trace

# Create the guardrail object with the desired configuration
pii_guard = PIIGuardrail()

# Apply to traced functions
@trace(guardrails=[pii_guard])
def process_user_data(user_input: str):
    return f"Processed: {user_input}"

# PII is automatically handled
result = process_user_data("My email is john@example.com")
# Output: "Processed: My email is [EMAIL-REDACTED]"
In this case, the guardrails are automatically traced as well, and you can see them in the Openlayer platform if tracing is correctly configured. Guardrails trace

​
Standalone usage

Openlayer guardrails can also be used standalone, without tracing. Here’s an example: 
# Import the guardrail
from openlayer_guardrails import PIIGuardrail

# Create the guardrail object with the desired configuration
pii_guard = PIIGuardrail(
    block_entities={"CREDIT_CARD", "US_SSN"},
    redact_entities={"EMAIL_ADDRESS", "PHONE_NUMBER"}
)

# Call the guardrail on the data
data = {"message": "My email is john@example.com and SSN is 123-45-6789"}
result = pii_guard.check_input(data)

if result.action.value == "block":
    print(f"Blocked: {result.reason}")
elif result.action.value == "modify":
    print(f"Modified data: {result.modified_data}")