RAG Application

Retrieval-augmented generation (RAG) applications combine user queries with retrieved knowledge base content before sending to an LLM. This creates governance challenges on both sides — the input may contain PII or injection attempts, and the output may leak sensitive data from the knowledge base. This flow shows how TealTiger governs the full RAG pipeline.

Orchestration Flow

User submits query

A user asks: “What are the salary ranges for senior engineers in the New York office?”

TealGuard — PII detection + prompt injection

TealGuard scans the input for PII (names, SSNs, emails) and prompt injection patterns. The query mentions “New York” (a location, not PII in this context) and contains no injection — it passes.

TealEngine — Input policy evaluation

TealEngine evaluates the query against input policies. The topic (salary data) is flagged as sensitive, so the engine sets classification: CONFIDENTIAL on the request context. This classification propagates to all downstream modules.

Retrieval from knowledge base

The RAG system retrieves relevant documents from the vector store: HR salary bands, compensation guidelines, and office-specific adjustments. Some retrieved chunks contain individual employee names and salaries.

TealMemory — Read governance

TealMemory enforces read governance on the retrieved documents. Each document has a classification level. The user’s clearance is checked against the document classification. Documents classified above the user’s level are filtered out before they reach the LLM. Individual salary records (classified RESTRICTED) are excluded — only aggregate band data (classified CONFIDENTIAL) passes through.

LLM generates response

The LLM generates a response using the filtered context: “Senior engineers in the New York office are in Band 7, with a salary range of

180,000–

240,000.”

TealGuard — Output content moderation

TealGuard scans the LLM output for content moderation violations and PII leakage. The response contains salary ranges (aggregate, not individual) and no PII — it passes.

TealSecrets — Output secret scan

TealSecrets scans the response for any leaked secrets — API keys, tokens, or credentials that might have been in the retrieved documents. The response is clean.

Response to user

The user receives the salary range information. No individual employee data was exposed.

TealAudit — Full evidence chain

TealAudit logs the complete evidence chain: input scan, classification assignment, documents retrieved, documents filtered by TealMemory, LLM response, output scan results. The correlation ID ties every event together.

Flow Diagram

Code Example

import {
  TealEngineV12,
  TealGuard,
  TealSecrets,
  TealMemory,
  TealAudit,
  PolicyMode,
} from 'tealtiger';

// --- Initialize modules ---

const guard = new TealGuard({
  promptInjection: { enabled: true, mode: PolicyMode.ENFORCE },
  contentModeration: { enabled: true, mode: PolicyMode.ENFORCE },
  piiDetection: {
    enabled: true,
    mode: PolicyMode.ENFORCE,
    action: 'REDACT', // Redact PII in input before retrieval
  },
});

const secrets = new TealSecrets({
  patterns: 'all',
  confidence: { minimum: 'MEDIUM' },
  action: 'REDACT',
});

const memory = new TealMemory({
  defaultScope: 'request',
  classification: {
    enforceReadGovernance: true,
    levels: ['PUBLIC', 'INTERNAL', 'CONFIDENTIAL', 'RESTRICTED'],
  },
});

const audit = new TealAudit({
  enabled: true,
  redactPII: true,
  outputs: ['file', 'http'],
});

const engine = new TealEngineV12({
  modules: [guard, secrets, memory, audit],
  mode: PolicyMode.ENFORCE,
});

// --- Orchestration flow ---

async function handleRAGQuery(
  userQuery: string,
  userId: string,
  userClearance: string
) {
  const context = engine.createContext({
    userId,
    userClearance,
    agentId: 'rag-application',
    environment: 'production',
  });

  // Step 1: TealGuard scans input (PII + injection)
  const inputScan = await guard.scan({
    content: userQuery,
    direction: 'input',
    context,
  });

  if (inputScan.action === 'DENY') {
    await audit.log({
      type: 'input_blocked',
      reason: inputScan.reasonCodes,
      correlationId: context.correlationId,
    });
    return { blocked: true, reason: inputScan.reasonCodes };
  }

  // Use redacted query for retrieval (PII stripped)
  const safeQuery = inputScan.redactedContent || userQuery;

  // Step 2: TealEngine evaluates and classifies the request
  const inputDecision = await engine.evaluate({
    action: 'query',
    content: safeQuery,
    context,
  });

  const requestClassification = inputDecision.metadata?.classification || 'INTERNAL';

  // Step 3: Retrieve documents from knowledge base
  const retrievedDocs = await vectorStore.search(safeQuery, { topK: 10 });

  // Step 4: TealMemory enforces read governance
  const filteredDocs = await memory.filterByClassification({
    documents: retrievedDocs,
    userClearance,
    requestClassification,
    context,
  });

  const docsFiltered = retrievedDocs.length - filteredDocs.length;
  if (docsFiltered > 0) {
    console.log(`TealMemory filtered ${docsFiltered} documents above user clearance`);
  }

  // Step 5: LLM generates response from filtered context
  const llmResponse = await generateResponse(safeQuery, filteredDocs);

  // Step 6: TealGuard scans output
  const outputScan = await guard.scan({
    content: llmResponse,
    direction: 'output',
    context,
  });

  if (outputScan.action === 'DENY') {
    await audit.log({
      type: 'output_blocked',
      reason: outputScan.reasonCodes,
      correlationId: context.correlationId,
    });
    return { blocked: true, reason: ['OUTPUT_MODERATION_FAILED'] };
  }

  // Step 7: TealSecrets scans output for leaked secrets
  const secretsScan = await secrets.scan({
    content: llmResponse,
    direction: 'output',
    context,
  });

  const finalResponse = secretsScan.findings.length > 0
    ? secretsScan.redactedContent
    : llmResponse;

  // Step 8: TealAudit logs the full evidence chain
  await audit.log({
    type: 'rag_query_completed',
    correlationId: context.correlationId,
    metadata: {
      docsRetrieved: retrievedDocs.length,
      docsFiltered,
      docsUsed: filteredDocs.length,
      classification: requestClassification,
      secretsFound: secretsScan.findings.length,
      outputModeration: outputScan.action,
    },
  });

  return {
    response: finalResponse,
    docsUsed: filteredDocs.length,
    classification: requestClassification,
    correlationId: context.correlationId,
  };
}

Key Governance Points

Step	Module	Enforcement	What it checks
1	TealGuard	Input scan	PII detection, prompt injection
2	TealEngine	Classification	Assigns sensitivity level to the request
3	TealMemory	Read governance	Filters documents above user clearance
4	TealGuard	Output scan	Content moderation on LLM response
5	TealSecrets	Secret scan	Leaked credentials in response
6	TealAudit	Evidence chain	Full pipeline logged with correlation ID

RAG applications are especially vulnerable to indirect prompt injection — malicious instructions embedded in retrieved documents. TealGuard should scan both the user query and the retrieved context before sending to the LLM.

Use TealMemory’s classification levels to implement data loss prevention (DLP) at the retrieval layer. Documents classified as RESTRICTED never reach the LLM, regardless of what the user asks.

TealMemory API

Memory governance scopes and classification enforcement

Guardrail Internals

How TealGuard’s PII detection and content moderation work

Audit & Redaction

How PII is automatically redacted in audit logs

Zero Trust for Agentic AI

Why every step in the pipeline needs governance

Getting Started

Core Concepts

Governance Domains

Policy Authoring

Architecture

Integrations

Deployment

API Reference

Cookbook

Compliance & GRC

Guides

Reference

Versions

Playground

Dashboard

Blog

Orchestration Flow

Flow Diagram

Code Example

Key Governance Points

TealMemory API

Guardrail Internals

Audit & Redaction

Zero Trust for Agentic AI

​Orchestration Flow

​Flow Diagram

​Code Example

​Key Governance Points

​Related Documentation

TealMemory API

Guardrail Internals

Audit & Redaction

Zero Trust for Agentic AI

Orchestration Flow

Flow Diagram

Code Example

Key Governance Points

Related Documentation