SENTINEL — LLM Trust & Safety Infrastructure Layer

Production-grade security middleware for enterprise AI deployments. Drop-in SDK · 19-agent parallel mesh · <72ms P99 · HIPAA/GDPR/SOC2/DPDP

Quick Start (3 lines)

import openai, sentinel

client = sentinel.wrap(
    openai.OpenAI(api_key="sk-..."),
    tenant_id="my-org",
    api_key="sk-sentinel-...",
)

# All existing code works unchanged:
response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Help me with this contract."}],
)

Architecture

SDK (wrap) → FastAPI Gateway → 19-Agent Parallel Mesh → Risk Aggregator → Circuit Breaker → LLM API
                     ↓                    ↓                      ↓
               Postgres            Redis             FAISS Index         Kafka
            (audit trail)     (policy cache)     (attack vectors)   (event stream)

The 19-Agent Mesh

v1 Core (7 agents)

v2 Enterprise (5 agents)

v3 Advanced (3 agents)

v4 Production (4 agents)

ML Models Used

Install

# SDK only (lightweight, for client-side integration)
pip install sentinel-guardrails-sdk

# Full gateway server with ML agents
pip install sentinel-guardrails-sdk[full]

# Server without ML (uses heuristic fallbacks)
pip install sentinel-guardrails-sdk[server]

Free vs Pro Tiers

Multi-Language Integration

Sentinel's gateway exposes a standard REST API, making it accessible from any language:

Node.js / TypeScript

const response = await fetch('https://gateway.sentinel-ai.dev/v1/screen', {
  method: 'POST',
  headers: {
    'Authorization': 'Bearer sntnl-your-key',
    'Content-Type': 'application/json',
  },
  body: JSON.stringify({
    messages: [{ role: 'user', content: 'Check this prompt' }],
    tenant_id: 'my-org',
  }),
});
const result = await response.json();

Java

HttpRequest request = HttpRequest.newBuilder()
    .uri(URI.create("https://gateway.sentinel-ai.dev/v1/screen"))
    .header("Authorization", "Bearer sntnl-your-key")
    .header("Content-Type", "application/json")
    .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
    .build();
HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());

React (Frontend)

const screenPrompt = async (userMessage) => {
  const res = await fetch('/api/sentinel/screen', {
    method: 'POST',
    headers: { 'Content-Type': 'application/json' },
    body: JSON.stringify({ messages: [{ role: 'user', content: userMessage }] }),
  });
  return res.json();
};

Deploy with Docker

# Full stack (Postgres + Redis + Kafka + Gateway + Dashboard)
cp .env.example .env        # set SECRET_KEY and OPENAI_API_KEY
docker compose up --build -d
curl http://localhost:8000/health

# Lightweight dev (just Postgres + Redis)
docker compose -f docker-compose.dev.yml up -d
python -m uvicorn sentinel.gateway.main:app --reload

Run Locally (Development)

# 1. Start database + cache
docker compose -f docker-compose.dev.yml up -d

# 2. Install dependencies
pip install -e ".[full,dev]"
python -m spacy download en_core_web_sm

# 3. Start gateway
cp .env.example .env
python -m uvicorn sentinel.gateway.main:app --reload --port 8000

# 4. Start dashboard (optional)
cd dashboard && npm install && npm run dev

Run Benchmark

python tests/red_team/run_benchmark.py

Expected results:

• Detection rate: 91% (v4 upgrade from 87%)
• False positive rate: 1.8%
• P99 latency: <72ms

SDK Integration Options

# Option 1: OpenAI wrapper (zero code changes)
client = sentinel.wrap(openai_client, tenant_id="...", api_key="...")

# Option 2: LangChain callback
from sentinel.sdk.langchain_handler import SentinelCallbackHandler
handler = SentinelCallbackHandler(tenant_id="...", api_key="...")
llm = ChatOpenAI(callbacks=[handler])

# Option 3: LlamaIndex node postprocessor
from sentinel.sdk.llamaindex_node import SentinelNodePostprocessor
postprocessor = SentinelNodePostprocessor(tenant_id="...", api_key="...")
query_engine = index.as_query_engine(node_postprocessors=[postprocessor])

API Endpoints

License

MIT — See LICENSE for details.