Guardrails AI × Sentiqra

Add Sentiqra as a structured classification step before or alongside generative-model guardrails. Use the LLM for reasoning and Sentiqra where you need a fixed classification taxonomy and versioned output.

Why This Integration Matters

As enterprises deploy LLM-based applications, the question "how does Sentiqra fit into our LLM safety stack?" becomes a top procurement objection for AI-native buyers. Guardrails AI is the leading open-source framework for adding programmable constraints to LLM outputs.

By integrating Sentiqra as a deterministic pre-classification layer in Guardrails AI, user prompts are classified for harmful content before reaching the LLM. This creates a two-layer defence: Sentiqra's deterministic taxonomy catches known harmful patterns with zero false negatives on flagged concepts, while the LLM handles creative generation on sanitised inputs.

This ties directly to Sentiqra's MCP positioning and the "grounding AI agents in deterministic evidence" pitch. This is the reference architecture that makes Sentiqra the essential first layer in any AI agent's safety stack.

Reference Architecture

┌───────────────────────────────────────────────────────────────────┐
│                Your Application                                   │
│                                                                   │
│  Boundary 1 - input screening          Boundary 2 - tool execution│
│                                                                   │
│  ┌──────────┐   ┌──────────────┐     ┌──────────┐  ┌────────────┐ │
│  │  User     │──▶│ Sentiqra     │     │ Agent    │─▶│ Tool       │ │
│  │  Prompt   │   │ Pre-Classify │     │ proposes │  │ Gateway    │ │
│  │           │   │              │     │ tool+args│  │ (yours)    │ │
│  │           │   │ Harmful?     │     └──────────┘  │            │ │
│  │           │   │ - Yes → block│                   │ 1. actor + │ │
│  │           │   │ - No  → pass │                   │    args    │ │
│  │           │   └──────────────┘                   │    allowed?│ │
│  │           │          │                          │ 2. gateway │ │
│  │           │          │                          │    runs    │ │
│  │           │          ▼                          │    required│ │
│  │           │   ┌──────────────┐                   │    checks  │ │
│  │           │   │  LLM (GPT-4, │                   │ 3. bound   │ │
│  │           │   │  Claude, etc)│                   │    approval│ │
│  │           │   └───────┬──────┘                   └─────┬──────┘ │
│  │           │           │                          ┌────▼─────┐   │
│  │           │◀── Response                      execute  OR  refuse│
│  └──────────┘                                                               │
│                                                                             │
│  Screening is evidence, not authorization: a passed prompt does not         │
│  grant the agent's proposed tool call - the gateway authorizes and          │
│  re-checks the actual action + arguments before anything executes.          │
└───────────────────────────────────────────────────────────────────────────┘

Data flow: User prompt enters → Sentiqra classifies it deterministically using the 200-concept taxonomy → if harmful, the guardrail blocks the request and returns a safe fallback → if not harmful, the prompt passes to the LLM for generation. When the application also lets the agent invoke tools, enforcement moves to a second boundary: the tool gateway - your code, not the model - evaluates the actual proposed action and arguments, invokes the required Sentiqra checks itself, applies authorization and policy, then executes or refuses. A clean screening result is never the permission to execute.

Working Code

Actual, tested, copy-pasteable code. Not pseudocode. Not aspirational.

import os
import requests
from typing import Any, Dict

from guardrails import Guard
from guardrails.validator_base import (
    FailResult,
    PassResult,
    ValidationResult,
    Validator,
    register_validator,
)

@register_validator(name="sentiqra/harmful_content", data_type="string")
class SentiqraHarmfulContentValidator(Validator):
    """Block prompts that Sentiqra flags as harmful."""

    def validate(self, value: str, metadata: Dict[str, Any]) -> ValidationResult:
        response = requests.post(
            "https://sentiqra.tech/v1/analyze",
            headers={
                "Authorization": f"Bearer {os.environ['SENTIQRA_API_KEY']}",
                "Content-Type": "application/json",
            },
            json={
                "text": value,
                "language": metadata.get("language", "en"),
                "analyzers": ["trust-safety"],
            },
            timeout=10,
        )
        signals = response.json()["signals"]
        top = signals[0] if signals else None

        if top and top["score"] > 0.7:
            return FailResult(
                error_message=f"Blocked by Sentiqra: {top['code']} (score: {top['score']})"
            )
        return PassResult()

# Attach the validator to a Guard (guardrails-ai >= 0.5 API)
guard = Guard().use(
    SentiqraHarmfulContentValidator(on_fail="exception")
)

# Use with any LLM - Sentiqra checks the prompt first
from openai import OpenAI
llm = OpenAI()

def safe_complete(prompt: str, language: str = "en") -> str:
    guard.validate(prompt, metadata={"language": language})
    return llm.chat.completions.create(
        model="gpt-4o",
        messages=[{"role": "user", "content": prompt}],
    ).choices[0].message.content

# tool calls the agent can propose - none execute without the gateway
EXECUTORS = {"send_email": send_email, "refund": issue_refund}
gateway = Gateway(load_policy("agent-policy.json"),
                  key=bytes.fromhex(os.environ["SENTIQRA_GATEWAY_KEY"]),
                  check=make_check("https://sentiqra.tech",
                                   os.environ["SENTIQRA_API_KEY"]),
                  executors=EXECUTORS)

def dispatch(proposed: dict, session) -> dict:
    # tenant + actor come from YOUR session - never from the analyzed text
    context = {"tenant": session.tenant_id, "actor": session.agent_id}
    decision = gateway.plan(proposed["tool"], proposed["arguments"], context)
    if decision["decision"] != "approved":
        return decision                      # denied: check failure, signal,
                                             # or authorization - audited
    # approval is bound to the exact args digest, actor, tenant, tool,
    # policy version, and validity window; mutated args refuse at execute()
    return gateway.execute(decision["approval"], proposed["tool"],
                           proposed["arguments"], context)

pip install "guardrails-ai>=0.5" openai requests

Security & Compliance Posture

• ✓
  EU AI Act - Risk Classification: Sentiqra's deterministic classification provides evidence that inputs were screened before reaching the LLM, which may support risk classification documentation under the AI Act.
• ✓
  Deterministic Evidence: Unlike LLM-based safety filters (which are probabilistic and non-reproducible), Sentiqra's detection is deterministic - the same input under the same pinned configuration and output profile produces the same canonical analysis. This is critical for audit defensibility.
• ✓
  Deterministic Coverage: Sentiqra's taxonomy-based approach is designed so that configured signals fire consistently for matching input - unlike probabilistic LLM-based filters, output is reproducible for the same input and configuration.
• ✓
  MCP Integration: This reference architecture aligns with Sentiqra's MCP (Model Context Protocol) server, enabling AI agents to call Sentiqra as a deterministic safety tool.
• ✓
  Audit Trail: Every blocked prompt has a Sentiqra detection record with the specific indicator, confidence, and configuration ID - providing evidence for AI safety audits.

Deployment Notes