Skip to content

Meet DeepintShield at Bengaluru Tech Summit 2026, 17 to 19 November, BIEC Hall 1, booth H1A106. Book 20 minutes

Start For Free

Platform · Runtime Guardrails & PII

LLM guardrails and PII redaction that run inside your boundary

LLM guardrails are checks that inspect what goes into and comes out of a model. DeepintShield can apply them at five stages: input, RAG, action, MCP and output. Local patterns and ML detectors catch prompt injection, jailbreaks, secrets and personal data, then your policy passes, redacts, blocks or flags the content.

  • 460+ detection patterns
  • Redaction in streamed responses
  • Detection runs in your deployment
LLM guardrails illustration: a shield filtering a stream of documents before they reach the model

Why prompt filters are not enough

A filter on the user’s prompt sees one door. Attacks and leaks use the others.

Injection arrives through other doors

Hidden instructions come through retrieved documents, tool results and MCP responses, not only through the user’s prompt.

Sensitive data leaks both ways

Personal data and secrets end up in prompts, model answers, streamed output and request logs.

Outside scanners add exposure

Sending every prompt to a third-party classifier moves the sensitive content you wanted to protect outside your boundary.

How runtime guardrails work

1. Inspect at each stage

The gateway checks input and output; the SDK and MCP gateway add RAG, action and MCP checks.

2. Score with patterns and ML

Local patterns run without network or model calls; ML detectors add classifiers on Team and above.

3. Apply your policy

Each finding is passed, redacted, blocked or flagged, in sync, async or shadow mode.

4. Record the finding

Guardrail violations and injection attempts land in the hash-chained audit log for review.

LLM guardrail features

One policy engine covers detection, redaction and rollout, on every plan.

Five stages, one policy

Input, RAG, action, MCP and output checks share one versioned policy, bound to a virtual key.

460+ patterns, 6 ML detectors

462 detection patterns in 102 preset families run locally; the ML detector sidecar is on Team and above.

Inline PII and secrets redaction

Rewrite emails, card numbers, national IDs, API keys and private keys in prompts, responses and streamed output.

OWASP guardrail cards

OWASP LLM Top-10 guardrail cards come with every plan, plus OWASP Agentic ASI cards for agent risks.

Sync, async or shadow

Run a policy inline, after the response, or in shadow mode to log findings without changing traffic.

Safety providers in one policy

On Team and above, add AWS Bedrock Guardrails, Azure AI Content Safety, Google Model Armor or your own webhook.

Pattern counts are configuration entries, not a measure of detection accuracy. Multimodal checks are off by default.

Set guardrail policy in the console

Turn on deterministic guardrails, choose the PII categories to check on input and output, add custom regex rules and pick what happens on a violation. Domain packs cover banking and financial services, healthcare and insurance. The Developer plan includes one guardrail policy; Team and above allow unlimited policies. Compare plans.

  • Default replacement text is [REDACTED]
  • Secrets are stored only as a length hint in findings
  • A redaction that cannot be mapped becomes a block

Guardrails on every gateway call

Route your client through DeepintShield and the policies bound to its virtual key check input and output on every request. Blocked requests return HTTP 403 guardrail_blocked. For explicit checks in Python, the SDK’s guard() raises an error on a block, evaluate_guardrail() returns a verdict, and guard_turn() checks input, tools and output in order. Tool calls through the MCP gateway can be checked on the MCP stage.

Python
import openai

client = openai.OpenAI(
    base_url="https://app.deepintshield.com/openai",
    api_key="sk-ds-your-virtual-key"
)

Mapped to

  • OWASP LLM Top 10
  • OWASP Agentic Top 10
  • NIST AI RMF
  • MITRE ATLAS
  • ISO/IEC 42001
  • EU AI Act

Product facts

  • 462 detection patterns
  • 102 preset families
  • Streaming redaction
  • Sync, async or shadow

LLM guardrail questions

What are LLM guardrails?

LLM guardrails are runtime checks on what goes into and comes out of a language model. In DeepintShield they can run at five stages (input, RAG, action, MCP and output), and each finding is passed, redacted, blocked or flagged. See where each stage sits in the request path.

How does DeepintShield detect prompt injection?

It matches local patterns first, then optional ML detectors. 462 patterns in 102 preset families cover prompt injection, retrieval and memory, credentials, tools and agentic controls, and run without network or model calls; the ML detector sidecar adds classifiers on Team and above. An unmatched request is not proof of safety, so keep tool permissions tight as well. Read the pattern catalogue.

Is my data sent to a third party?

Not by the built-in detectors. Pattern matching runs locally and PII detection runs inside your own deployment. Content goes to an outside service only if you add a safety provider, such as AWS Bedrock Guardrails or Google Model Armor, to a policy.

How much latency do guardrails add?

It depends on your policies and workload, so measure your own. Eligible deterministic guard decisions are reused in about 1.42 µs (local microbenchmark, no I/O), output checks can run as async post-guards, and per-category timeouts cap slow detectors. Read the performance docs.

Can I test a policy before it blocks anything?

Yes. Run the policy in shadow mode or with the Monitor only action, and findings are logged while traffic is unchanged. When the results look right, enforce it on one virtual key before you widen it. See the rollout steps.

Further reading on LLM guardrails

Put guardrails on every stage, not only the prompt

Start free with one guardrail policy on the Developer plan, or book a demo on your own traffic.

Start For Free