Skip to main content

OGuardAI for agents and machines

Everything below is generated from the same facts the runtime enforces. This site calls no runtime; capabilities are shown as a shape, not a live response.

$ oguardai 0.1.0

Self-hosted data protection runtime for AI systems, built by Oronts GmbH in Munich. It detects sensitive values in text, JSON, chat messages, files and images, replaces them with typed semantic tokens of the form {{type:id:cap}}, lets any model work on the tokens, and restores them deterministically under policy.

Proprietary core; Apache-2.0 SDKs, examples and documentation. Self-hosted; this site calls no runtime.

$ Install

The registry, image and package installs below are private today and provided under a written agreement with Oronts. Request access

Container
docker run -p 3000:3000 -e GUARDAI_HOST=0.0.0.0 -e GUARDAI_ALLOW_DEV_NON_LOOPBACK=1 ghcr.io/oronts/oguardai/server:latest
Helm
helm install oguardai oci://ghcr.io/oronts/charts/oguardai --version 0.1.0
Docker Compose
docker compose -f deploy/docker/docker-compose.yml up
Release binary
curl -fsSL https://github.com/oronts/OGuardAI/releases/download/v0.1.0/oguardai-0.1.0-x86_64-unknown-linux-gnu.tar.gz | tar xz -C /usr/local/bin
TypeScript SDK / Python SDK / Go SDK / Java SDK / MCP server
npm install @oguardai/sdk
pip install oguardai-sdk
go get github.com/oronts/OGuardAI/sdks/go
git clone https://github.com/oronts/OGuardAI && cd OGuardAI/sdks/java && mvn install
npx @oguardai/mcp-server

$ CLI

oguardai <command>

  run           Start the HTTP server.
  transform     Protect text via the server's transform endpoint.
  rehydrate     Restore tokens via the server using session state.
  detect        Detect sensitive entities via the server.
  capabilities  List the server's entity types, languages and detectors.
  diagnostics   Show the server's runtime configuration and health snapshot.
  revoke        Revoke an entity value, or read the revocation count.
  config        Config operations, such as validate.
  health        Check server health.

$ HTTP endpoints

# transform
POST   /v1/transform
POST   /v1/transform/stream

# rehydrate
POST   /v1/rehydrate
POST   /v1/output-guard
POST   /v1/rehydrate/metadata
POST   /v1/rehydrate/stream

# detect
POST   /v1/detect

# policy
POST   /v1/entity-types
POST   /v1/patterns
POST   /v1/evaluate-policy

# batch
POST   /v1/batch/transform
POST   /v1/batch/detect

# rag
POST   /v1/rag/ingest
POST   /v1/rag/ingest/batch
POST   /v1/rag/query
POST   /v1/rag/context
POST   /v1/rag/answer
POST   /v1/rag/answer/metadata
POST   /v1/rag/delete

# revocation
POST   /v1/revoke
POST   /v1/revoke/bulk
GET    /v1/revocations/count

# sessions
POST   /v1/sessions/status
DELETE /v1/sessions

# files
POST   /v1/transform/file
POST   /v1/rehydrate/file
POST   /v1/transform/image
POST   /v1/redact/image

# operations
GET    /v1/health
GET    /v1/capabilities
GET    /v1/diagnostics
POST   /v1/admin/policy/validate
POST   /v1/admin/policy/reload
GET    /metrics
GET    /livez
GET    /readyz

Machine contract and per-route detail: /docs/api/reference and /docs/api/explorer.

$ Request round trip

# 1. Protect. The response carries safe_text and a sealed session_state.
curl -X POST http://localhost:3000/v1/transform \
  -H 'X-API-Key: $GUARDAI_API_KEY' \
  -H 'content-type: application/json' \
  -d '{"text":"Email max.mustermann@example.de"}'

# The model works on safe_text, for example {{email:e_001:9f7b3ffd1ca0}}.

# 2. Restore under a channel your policy allows.
curl -X POST http://localhost:3000/v1/rehydrate \
  -H 'X-API-Key: $GUARDAI_API_KEY' \
  -H 'content-type: application/json' \
  -d '{"session_state":"...","text":"...","output_channel":"user_output"}'

$ SDKs and frameworks

OpenAI Python
from openai import OpenAI

client = OpenAI(
    base_url="http://localhost:8081/v1"
)
# Standard OpenAI usage. OGuardAI masks PII automatically.
OpenAI Node
import OpenAI from "openai";

const client = new OpenAI({
  baseURL: "http://localhost:8081/v1"
});
// One line change. Detected PII is masked before it reaches OpenAI.
Anthropic
import Anthropic from "@anthropic-ai/sdk";

const client = new Anthropic({
  baseURL: "http://localhost:8082"
});
// Same proxy, Claude Messages API. Provider-neutral.
TypeScript SDK
import { OGuardAIClient } from "@oguardai/sdk";

const og = new OGuardAIClient({ baseUrl: "http://localhost:3000" });
const reply = await og.guardedCall(callLLM, text);
// Detect, tokenize, call your model, rehydrate. In-process.
Python SDK
from guardai_sdk import OGuardAIClient

og = OGuardAIClient("http://localhost:3000")
safe = og.transform(text, policy="healthcare-clinical")
answer = og.rehydrate(llm(safe.safe_text), session_state=safe.session_state)
# Full Detect -> Transform -> LLM -> Rehydrate control.
Go SDK
import oguardai "github.com/oronts/OGuardAI/sdks/go"

og, _ := oguardai.NewClient(oguardai.Config{BaseURL: "http://localhost:3000"})
reply, _ := og.GuardedCall(ctx, callLLM, text, oguardai.GuardedCallOptions{})
// Detect, tokenize, call your model, rehydrate. In-process.
Java SDK
import com.oronts.oguardai.OGuardAIClient;

OGuardAIClient og = OGuardAIClient.builder().baseUrl("http://localhost:3000").build();
String reply = og.guardedCall(callLLM, text);
// Detect, tokenize, call your model, rehydrate. In-process.
LangChain
from guardai_sdk.integrations.langchain import protect

guarded = protect(chain, client, policy="crm-sales")
result = guarded.invoke(inputs)
# PII masked on the way in, restored on the way out.
MCP server
// .mcp.json: expose protection as tools to any MCP client
{ "mcpServers": { "oguardai": {
    "command": "npx", "args": ["@oguardai/mcp-server"] } } }
// guardai_transform / guardai_rehydrate / guardai_revoke in Claude, Cursor, Windsurf.
Direct HTTP
# Transform: mask PII
resp = requests.post("http://localhost:3000/v1/transform",
    json={"input": "Email sara@oronts.com"})

# Rehydrate: restore originals
resp = requests.post("http://localhost:3000/v1/rehydrate", ...)
Docker
# One command. Dev mode on port 3000.
docker run -p 3000:3000 \
  -e GUARDAI_SESSION_SECRET=$(openssl rand -base64 32) \
  ghcr.io/oronts/oguardai/server:latest

# Verify
curl http://localhost:3000/livez

$ Capabilities

Shape of GET /v1/capabilities. Run oguardai capabilities against your deployment for the live values; the endpoint returns no raw data by construction.

Required fields
entity_types
languages
detectors
restore_modes
ner_active
max_batch_size
max_session_entities
max_session_bytes
Optional fields
gender_inference
detection_floor
Restore modes
full
partial
masked
formatted
abstract
none
Channel ceilings
log_safe: none
export: masked
Framework adapters
LangChain
LlamaIndex
Haystack
CrewAI
OpenAI Agents
Vercel AI
Mastra

$ MCP

// .mcp.json: expose protection as tools to any MCP client
{ "mcpServers": { "oguardai": {
    "command": "npx", "args": ["@oguardai/mcp-server"] } } }
// guardai_transform / guardai_rehydrate / guardai_revoke in Claude, Cursor, Windsurf.

@oguardai/mcp-server (guardai-mcp), 23 tools. Five admin tools stay hidden unless GUARDAI_MCP_EXPOSE_ADMIN, and guardai_revoke unless GUARDAI_MCP_EXPOSE_REVOKE. Rehydrate runs in host code after the model loop, never as a model tool.

$ Machine index

$ Context for your agent

OGuardAI 0.1.0 (https://OGuard.ai)

Self-hosted data protection runtime for AI systems, built by Oronts GmbH in Munich. It detects sensitive values in text, JSON, chat messages, files and images, replaces them with typed semantic tokens of the form {{type:id:cap}}, lets any model work on the tokens, and restores them deterministically under policy.

Facts an agent should not guess:
- A token always has three segments {{type:id:cap}}; a capless or guessed token never resolves.
- Restore reads only the AES-256-GCM sealed session_state that travels with the request; the runtime stores no raw values, and revocation stores HMAC-SHA-256 digests.
- The format floor always runs; person, company and location need the NER sidecar.
- log_safe restores nothing and export at most masked; every other channel follows the policy.
- Nothing ships as a log shipper, database connector or generic HTTP proxy; the proxy serves /v1/chat/completions, /v1/messages, /v1/embeddings on port 8081 with header X-GuardAI-API-Key only.
- Every docs page is available as markdown: append .md to any docs page URL.
- Machine index: https://OGuard.ai/llms.txt and https://OGuard.ai/llms-full.txt.

$ Contact