Atlas Guardrails

Atlas Guardrails provides monitoring, observability, and guardrails for Large Language Model interactions. Track, validate, and secure your LLM API calls with minimal — often zero — changes to your existing application code.

• Observers wrap your LLM client so traffic is monitored automatically, no call-site changes.
• Guardrails give you explicit guard/observe calls when you want fine-grained control.
• Blocking mode can enforce policy (rewrite or block non-compliant requests/responses).
• Traceability correlates inputs and outputs and records processing traces.

Installation

# SDK only
pip install atlas-guardrails

# SDK + the OpenAI client observer
pip install "atlas-guardrails[openai-observers]"

# Pre-release (alpha) build from the develop branch
pip install --pre atlas-guardrails

atlas-guardrails automatically pulls in its companion package atlas-guardrails-core at the same version; both share the atlas_guardrails import namespace.

git clone git@github.com:Varonis-Systems/Atlas-alltrue-llm-observability.git
cd Atlas-alltrue-llm-observability

# Using uv (recommended — installs the workspace + dev dependencies)
uv sync --extra openai-observers

# Or using pip
pip install -e ".[openai-observers]"

Quickstart

Set your credentials (created in the Atlas application):

export ALLTRUE_API_URL="<your-atlas-api-url>"  # e.g. https://api.prod.alltrue-be.com
export ALLTRUE_API_KEY="<your-api-key>"
export ALLTRUE_ENDPOINT_IDENTIFIER="<your-endpoint-identifier>"

Then monitor every OpenAI chat completion with no changes to your call sites:

import os
from openai import OpenAI
from atlas_guardrails.observers.openai import OpenAIObserver

observer = OpenAIObserver(
    alltrue_api_key=os.environ["ALLTRUE_API_KEY"],
    alltrue_endpoint_identifier=os.environ["ALLTRUE_ENDPOINT_IDENTIFIER"],
    blocking=False,  # monitor only; set True to enforce policy
)
observer.register()

# Your existing code — now observed automatically.
completion = OpenAI().chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "What day is today?"}],
)
print(completion.choices[0].message.content)

observer.unregister()

Prefer explicit validation instead of patching the client? Use ChatGuardrails:

from atlas_guardrails.guardrails.chat import ChatGuardrails, GuardrailsException

guardrails = ChatGuardrails(
    alltrue_api_key=os.environ["ALLTRUE_API_KEY"],
    alltrue_endpoint_identifier=os.environ["ALLTRUE_ENDPOINT_IDENTIFIER"],
)

try:
    guarded = await guardrails.guard_input(["What day is today?"])
except GuardrailsException as exc:
    print(f"Input blocked: {exc}")

Configuration essentials

Constructor arguments win over environment variables, and a .env file in the working directory is loaded automatically. See the full configuration reference for every option (logging, blocking, batching, timeouts, control directives).

Documentation

• docs/USAGE.md — full usage guide: observers, guardrails, blocking vs non-blocking, batch mode, control directives, traceability, statistics, and troubleshooting.
• docs/RELEASING.md — versioning, branching model, and CI/CD.

Features

• Zero-touch observers for the OpenAI client (sync and async).
• Explicit guardrails for custom pipelines and non-OpenAI flows.
• Blocking mode to validate and, if needed, rewrite or block requests/responses.
• Require-approval (HOLD) flow for human-in-the-loop policies.
• Traceability via a chat_id plus retrievable processing traces.
• Processing statistics — per-call cost, latency, and policy outcomes via a collector callback.
• Batch mode to reduce request volume when monitoring.
• Async and sync support.

Releasing

atlas-guardrails and atlas-guardrails-core are versioned and published together. Pushes to develop produce alpha pre-releases (pip install --pre atlas-guardrails); the develop → main PR cuts the final release. See docs/RELEASING.md for the full branching model, conventional-commit rules, and CI/CD setup.

License

This project is licensed under the Apache License 2.0. See the LICENSE file for details.