Developer SDK & Pre-Built Connectors

# ztds_llamaindex_transform.py
from typing import List, Optional
from llama_index.core.schema import BaseNode, TransformComponent
from llama_index.core.ingestion import IngestionPipeline
from llama_index.core.node_parser import SentenceSplitter
from privacyscrubber import ZTDSEngine

class ZTDSTransformation(TransformComponent):
    """Pre-indexing ingestion sanitizer preventing raw PII vector storage."""
    profile: str = "fintech"

    def __init__(self, profile: str = "fintech"):
        super().__init__()
        self.profile = profile
        self._engine = ZTDSEngine(profile=self.profile)

    def __call__(self, nodes: List[BaseNode], **kwargs) -> List[BaseNode]:
        for node in nodes:
            # 1. Deterministic surrogate replacement ([IBAN_1], [SSN_1])
            sanitized_text, token_map = self._engine.sanitize(node.get_content())
            node.set_content(sanitized_text)

            # 2. Add cryptographically verifiable audit tags
            node.metadata["ztds_sanitized"] = True
            node.metadata["ztds_tokens_masked"] = len(token_map)
        return nodes

# Production RAG Ingestion Pipeline
pipeline = IngestionPipeline(
    transformations=[
        SentenceSplitter(chunk_size=512, chunk_overlap=32),
        ZTDSTransformation(profile="fintech") # Vector DB receives 0 bytes cleartext
    ]
)
nodes = pipeline.run(documents=documents)

# ztds_crewai_role_filter.py
from crewai import Agent, Task, Crew, Process
from privacyscrubber import ZTDSEngine

class ZTDSCrewMiddleware:
    def __init__(self, profile: str = "bizops"):
        self.engine = ZTDSEngine()
        self.profile = profile
        self.session_maps = {}

    def before_agent_execution(self, task_description: str, task_id: str) -> str:
        # Sanitize task input before LLM agent sees it
        sanitized, token_map = self.engine.sanitize(task_description, profile=self.profile)
        self.session_maps[task_id] = token_map
        return sanitized

    def after_agent_execution(self, task_output: str, task_id: str) -> str:
        # Restore surrogate tokens in RAM before returning to caller
        token_map = self.session_maps.get(task_id, {})
        revealed = self.engine.reveal(task_output, token_map)
        self.session_maps.pop(task_id, None) # Auto-purge RAM mapping
        return revealed

// ztds-ollama-stream.js
const { PrivacyScrubberEngine } = require("@privacyscrubber/sdk");

const engine = new PrivacyScrubberEngine();

async function proxyOllamaPrompt(prompt, profile = "dev") {
  // 1. Sanitize prompt before local or remote Ollama call
  const { sanitizedText, tokenMap } = engine.sanitize(prompt, { profile });

  const response = await fetch("http://localhost:11434/api/generate", {
    method: "POST",
    headers: { "Content-Type": "application/json" },
    body: JSON.stringify({ model: "llama3:8b", prompt: sanitizedText, stream: true })
  });

  const reader = response.body.getReader();
  const decoder = new TextDecoder();
  let fullOutput = "";

  while (true) {
    const { done, value } = await reader.read();
    if (done) break;
    const chunk = JSON.parse(decoder.decode(value));
    fullOutput += chunk.response;
  }

  // 2. Instant RAM reverse scrub
  return engine.reveal(fullOutput, tokenMap);
}

// ~/.cursor/mcp.json or claude_desktop_config.json
{
  "mcpServers": {
    "privacyscrubber-ztds": {
      "command": "npx",
      "args": ["-y", "@privacyscrubber/mcp-server@latest"],
      "env": {
        "ZTDS_INVARIANTS_ENFORCE": "true",
        "ZTDS_TELEMETRY": "false"
      }
    }
  }
}

# Claude Code CLI Registration:
claude mcp add privacyscrubber npx -y @privacyscrubber/mcp-server@latest

// ztds-pinecone-rag.ts
import { Pinecone } from "@pinecone-database/pinecone";
import { OpenAIEmbeddings } from "@langchain/openai";
import { PrivacyScrubberEngine } from "@privacyscrubber/sdk";

const engine = new PrivacyScrubberEngine();
const pinecone = new Pinecone();
const embeddings = new OpenAIEmbeddings();

export async function indexDocumentSecurely(docId: string, rawText: string, profile = "medical") {
  // 1. Sanitize document client-side before embedding calculation
  const { sanitizedText, tokenMap } = engine.sanitize(rawText, { profile });

  // 2. Generate vector embedding from sanitized text ONLY
  const vector = await embeddings.embedQuery(sanitizedText);

  // 3. Upsert to Pinecone - zero PII in vector coordinates or metadata
  const index = pinecone.Index("enterprise-knowledge");
  await index.upsert([{
    id: docId,
    values: vector,
    metadata: {
      textSnippet: sanitizedText.slice(0, 500),
      ztdsVerified: true,
      entityCount: Object.keys(tokenMap).length
    }
  }]);
  // tokenMap is NOT stored in Pinecone. Volatile local RAM or tenant-isolated KMS only.
}

// app/api/chat/route.ts
import { NextRequest, NextResponse } from "next/server";
import { PrivacyScrubberEngine } from "@privacyscrubber/sdk";

export const runtime = "edge";

const engine = new PrivacyScrubberEngine();

export async function POST(req: NextRequest) {
  const { messages, profile } = await req.json();
  const lastMessage = messages[messages.length - 1];

  // In-memory Edge sanitization (<0.8ms)
  const { sanitizedText, tokenMap } = engine.sanitize(lastMessage.content, {
    profile: profile || "general"
  });
  messages[messages.length - 1].content = sanitizedText;

  // Forward to upstream model
  const upstreamRes = await fetch("https://api.openai.com/v1/chat/completions", {
    method: "POST",
    headers: {
      Authorization: `Bearer ${process.env.OPENAI_API_KEY}`,
      "Content-Type": "application/json"
    },
    body: JSON.stringify({ model: "gpt-4o", messages })
  });

  const completion = await upstreamRes.json();
  const rawReply = completion.choices[0].message.content;

  // Reverse reveal before returning to client
  const revealedReply = engine.reveal(rawReply, tokenMap);
  return NextResponse.json({ reply: revealedReply });
}

# envoy-ztds-filter.yaml
static_resources:
  listeners:
  - name: llm_proxy_listener
    address:
      socket_address: { address: 127.0.0.1, port_value: 8080 }
    filter_chains:
    - filters:
      - name: envoy.filters.network.http_connection_manager
        typed_config:
          "@type": type.googleapis.com/envoy.extensions.filters.network.http_connection_manager.v3.HttpConnectionManager
          stat_prefix: egress_llm
          route_config:
            name: local_route
            virtual_hosts:
            - name: openai_upstream
              domains: ["*"]
              routes:
              - match: { prefix: "/v1/chat/completions" }
                route: { cluster: ztds_local_sidecar }
  clusters:
  - name: ztds_local_sidecar
    connect_timeout: 0.25s
    type: STATIC
    lb_policy: ROUND_ROBIN
    load_assignment:
      cluster_name: ztds_local_sidecar
      endpoints:
      - lb_endpoints:
        - endpoint:
            address: { socket_address: { address: 127.0.0.1, port_value: 9090 } } # Local @privacyscrubber/sdk daemon

// ztds-kafka-stream.js
const { Kafka } = require("kafkajs");
const { PrivacyScrubberEngine } = require("@privacyscrubber/sdk");

const kafka = new Kafka({ clientId: "ztds-filter", brokers: ["localhost:9092"] });
const consumer = kafka.consumer({ groupId: "sanitizer-group" });
const producer = kafka.producer();
const engine = new PrivacyScrubberEngine();

async function run() {
  await consumer.connect();
  await producer.connect();
  await consumer.subscribe({ topic: "raw-customer-transcripts", fromBeginning: true });

  await consumer.run({
    eachMessage: async ({ topic, partition, message }) => {
      const rawText = message.value.toString();
      // In-memory sanitization
      const { sanitizedText } = engine.sanitize(rawText, { profile: "support" });

      // Publish clean data to downstream topic
      await producer.send({
        topic: "clean-transcripts-ztds",
        messages: [{ key: message.key, value: sanitizedText }]
      });
    }
  });
}
run();

// content-script-ztds.js
(function() {
  const engine = window.PrivacyScrubberEngine;
  let activeTokenMap = {};

  document.addEventListener("keydown", (e) => {
    if (e.key === "Enter" && !e.shiftKey) {
      const target = e.target;
      if (target && (target.tagName === "TEXTAREA" || target.isContentEditable)) {
        const rawText = target.value || target.innerText;
        const { sanitizedText, tokenMap } = engine.sanitize(rawText);
        activeTokenMap = tokenMap;
        if (target.value) target.value = sanitizedText;
        else target.innerText = sanitizedText;
      }
    }
  }, true);
})();