Developer SDK: Zero-Egress Node.js & Browser PII Sanitization for AI Pipelines

// 1. Install zero-dependency SDK: npm i @privacyscrubber/sdk @anthropic-ai/sdk
import Anthropic from '@anthropic-ai/sdk';
import { sanitize, restore } from '@privacyscrubber/sdk';

const anthropic = new Anthropic({ apiKey: process.env.ANTHROPIC_API_KEY });

// 2. In-flight boundary interceptor for Claude 3.5 Sonnet / Opus
export async function callClaudeSecurely(rawPrompt: string) {
  // Pre-flight redaction in local server RAM (<0.4ms latency, 0 bytes cloud egress)
  const { scrubbedText, tokenMap, telemetry } = sanitize(rawPrompt, {
    profile: 'medical',      // HIPAA Safe Harbor (§164.514) compliance
    detectSecrets: true,
    licenseKey: process.env.PRIVACYSCRUBBER_KEY // $299/mo SDK: Unlimited production nodes
  });

  // Transmit strictly safe deterministic tokens ([NAME_1], [MRN_1]) to Anthropic cloud
  const response = await anthropic.messages.create({
    model: 'claude-3-5-sonnet-20241022',
    max_tokens: 1024,
    messages: [{ role: 'user', content: scrubbedText }]
  });

  // Deterministically rehydrate authentic patient identities in volatile RAM
  const replyText = response.content[0].type === 'text' ? response.content[0].text : '';
  const { restoredText } = restore(replyText, tokenMap);

  return {
    reply: restoredText,
    riskLevel: telemetry.riskLevel,    // CLEAN | LOW | MODERATE | CRITICAL
    auditProof: telemetry.sha256Receipt // Cryptographic CISO audit receipt
  };
}

// 1. Install zero-dependency SDK: npm i @privacyscrubber/sdk @langchain/core @langchain/openai
import { ChatOpenAI } from '@langchain/openai';
import { RunnableLambda } from '@langchain/core/runnables';
import { createLangChainTransform, PrivacyScrubberEngine } from '@privacyscrubber/sdk';

// Pattern A: 1-Line Middleware Helper
const transform = createLangChainTransform({
  defaultProfile: 'Healthcare',
  detectSecrets: true,
  licenseKey: process.env.PRIVACYSCRUBBER_KEY // $299/mo SDK: Unlimited production nodes
});
const { scrubbedText, tokenMap } = transform.preprocess(
  'Patient Maria Santos (MRN-884210) prescribed Metformin 500mg by Dr. Robert Chen.'
);

// Pattern B: Stateful LCEL Chain for Multi-Turn Autonomous Agents (LangGraph / CrewAI)
const engine = new PrivacyScrubberEngine({ defaultProfile: 'Dev' });
const model = new ChatOpenAI({ model: 'gpt-4o', temperature: 0 });

const secureAgentChain = RunnableLambda.from(async (inputPrompt: string) => {
  // In-memory token dictionary preserves token numbering across multi-turn agent execution traces
  const { scrubbedText, tokenMap } = engine.sanitize(inputPrompt);
  const response = await model.invoke(scrubbedText);
  return engine.restore(response.content as string, tokenMap);
});

const result = await secureAgentChain.invoke('Investigate AWS_KEY=AKIAIOSFODNN7EXAMPLE for user alice@corp.internal');

// 1. Install zero-dependency SDK: npm i @privacyscrubber/sdk llamaindex
import { Document } from 'llamaindex';
import { sanitize } from '@privacyscrubber/sdk';

// 2. Pre-Ingestion Node Sanitizer: Prevents GDPR Article 17 Vector Poisoning
// Ingesting raw PII into vector embeddings makes deletion impossible without full index re-clustering.
// ZTDS tokenization enables O(1) constant-time erasure via KMS session key purge ($0 re-index cost).
export function sanitizeDocumentsForIndex(documents: Document[]): Document[] {
  return documents.map(doc => {
    // In-memory chunk sanitization (<0.065ms per chunk in RAM)
    const { scrubbedText, tokenMap, telemetry } = sanitize(doc.getText(), {
      profile: 'finance', // Masks credit cards, IBANs, SSNs, bank details
      detectSecrets: true,
      licenseKey: process.env.PRIVACYSCRUBBER_KEY // $299/mo SDK: Unlimited production nodes
    });

    // Store encrypted tokenMap in local customer-controlled KMS vault for authorized staff review
    kmsVault.storeTokenMap(doc.id_, tokenMap);

    // Return sanitized document with statutory compliance audit tags
    return new Document({
      text: scrubbedText,
      metadata: {
        ...doc.metadata,
        psRiskLevel: telemetry.riskLevel,
        psAuditHash: telemetry.sha256Receipt,
        psCompliantFrameworks: telemetry.frameworksList.join(',')
      }
    });
  });
}

// 1. Install zero-dependency SDK: npm i @privacyscrubber/sdk ai @ai-sdk/openai
import { openai } from '@ai-sdk/openai';
import { streamText } from 'ai';
import { sanitize, wrapAiStream } from '@privacyscrubber/sdk';

export async function POST(req: Request) {
  const { messages } = await req.json();
  const lastPrompt = messages[messages.length - 1].content;

  // 1. In-process ZTDS pre-flight redaction in local server RAM (<0.4ms)
  const { scrubbedText, tokenMap } = sanitize(lastPrompt, {
    profile: 'legal',
    detectSecrets: true,
    licenseKey: process.env.PRIVACYSCRUBBER_KEY // $299/mo SDK: Unlimited production nodes
  });

  // 2. Forward safe deterministic tokens to external model
  messages[messages.length - 1].content = scrubbedText;
  const result = await streamText({
    model: openai('gpt-4o'),
    messages
  });

  // 3. Transparent real-time chunk detokenization via wrapAiStream
  // Split tokens ([EM + AIL_1]) are rehydrated seamlessly across stream chunks
  const restoredStream = wrapAiStream(result.toTextStreamResponse().body, tokenMap);
  return new Response(restoredStream, {
    headers: { 'Content-Type': 'text/event-stream' }
  });
}

<!-- 1-Line Browser DOM Form Interceptor: In-Memory Client-Side Sanitization -->
<script type="module">
  import { sanitize } from 'https://cdn.jsdelivr.net/npm/@privacyscrubber/sdk@2.3.9/browser.js';

  const form = document.querySelector('#support-form');

  form.addEventListener('submit', async (event) => {
    event.preventDefault();
    const textarea = form.querySelector('textarea[name="message"]');

    // 1. In-browser RAM sanitization (<0.4ms latency, 0 bytes external egress)
    const { scrubbedText, tokenMap } = sanitize(textarea.value, {
      profile: 'support' // Protects credit cards, emails, phone numbers, tax IDs
    });

    // 2. Dual-Envelope Architecture:
    // Envelope A (Public): Transmit safe tokens to public CRM (Zendesk / HubSpot / AI Triage)
    await fetch('/api/public-tickets', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ message: scrubbedText })
    });

    // Envelope B (Private): Store encrypted tokenMap in your isolated private vault
    await secureVault.storeSession(ticketId, tokenMap);
  });
</script>

# 1. Install LiteLLM: pip install litellm
import litellm
from litellm.integrations.custom_logger import CustomLogger
from ztds import ZTDSGuardrail  # In-memory zero-trust sanitization engine

# 2. Register ZTDS in LiteLLM callbacks (intercepts 100+ model providers)
ztds_guardrail = ZTDSGuardrail(profile="finance", preserve_context=True)
litellm.callbacks = [ztds_guardrail]

# 3. Transparently execute completions across any upstream model
# Prompts are sanitized in local RAM before leaving your private perimeter;
# completions are automatically detokenized back in volatile memory.
response = litellm.completion(
    model="openai/gpt-4o",
    messages=[
        {"role": "system", "content": "You are an automated loan underwriting auditor."},
        {"role": "user", "content": "Review application for John Vance (SSN: 000-12-3456, IBAN: DE89370400440532013000)."}
    ]
)

print(response.choices[0].message.content)
# Telemetry: Invariant 1 (Zero Egress) Verified • Latency <0.4ms

// 1. Add MCP Stdio Server to Cursor / Claude Desktop / Windsurf config:
{
  "mcpServers": {
    "privacyscrubber": {
      "command": "npx",
      "args": ["-y", "@privacyscrubber/mcp-server@latest"],
      "env": {
        "PRIVACY_SCRUBBER_LICENSE": "PS_TEAMS_AIRGAPPED_KEY"
      }
    }
  }
}

// 2. MCP Tools automatically registered in IDE agent loop:
// • sanitize_text(text, profile): masks PII locally via JSON-RPC stdio
// • restore_tokens(text, session_id): re-hydrates tokens from local volatile RAM
// • scan_document(content, format): redacts PDF/CSV/JSON files before model context
// Runs 100% locally on your machine with 0 network calls.