Skip to main content
Guardrails are runtime checks that help you enforce constraints on your AI system’s inputs and outputs.
Guardrails are currently in beta. We are actively working to expand it. Reach out if you have any questions or feedback.

​
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 offers an open-source Python library that you can use. You can use one of the built-in guardrails (such as the PII guardrail), or implement your own.

Openlayer Guardrails GitHub repository

Check out the source code of the Openlayer Guardrails library.
 You can install it with: 
pip install openlayer-guardrails

​
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}")