@privacyscrubber/mcp-server

CISO-Approved Zero-Trust PII & Secrets Redaction MCP Server for Cursor, Windsurf, and Claude Desktop. Locally scrubs PII, secrets, credentials, and custom regex rules from files and text contexts before they reach remote LLM providers to prevent API leaks and ensure HIPAA/SOC 2 compliance at the developer endpoint.

⭐ Support Zero-Trust Open Source: If PrivacyScrubber protects your API keys and code from leaks, please Star this repository or run gh repo star moxno/privacyscrubber-mcp in your terminal!

🔒 Zero-Trust Data Flow

All sensitive parameters, identifiers, and variables are intercepted locally inside your machine's RAM. They are replaced by tokens (e.g. [EMAIL_1]) before being sent to the AI. Once the AI responds, the tokens are safely swapped back to original values in your local context.

[Raw Input / Files] ──> [MCP sanitize_text] ──> [Masked Tokens] ──> [LLM API]
                               │                                       │
                        (In-Memory Map)                             (Result)
                               │                                       │
[Original Output] <─── [MCP reveal_text] <─────────────────────────────┘

Related MCP server: trustboost-pii-sanitizer

🚀 Installation

1. Install via Smithery

To automatically configure and run with your preferred client, install using Smithery:

npx -y @smithery/cli install @privacyscrubber/mcp-server --write-to-clients

2. Instant Run with NPX

Run the server directly without local installation:

npx -y @privacyscrubber/mcp-server

3. Programmatic Node.js / TypeScript SDK (Lightweight Presidio Alternative)

Need direct, in-memory zero-trust PII sanitization in your backend microservice, Next.js app, or RAG vector pipeline rather than an MCP server? Use our official zero-dependency SDK:

npm install @privacyscrubber/sdk

import OpenAI from 'openai';
import { wrapOpenAI } from '@privacyscrubber/sdk';

// Transparently masks PII before sending to LLM and rehydrates responses:
const openai = wrapOpenAI(new OpenAI({ apiKey: process.env.OPENAI_API_KEY }));

// Outbound prompt is sanitized in local RAM before leaving your machine:
// "Schedule a call with [NAME_1] at [EMAIL_1] regarding API key [AWS_KEY_1]."
const completion = await openai.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Schedule a call with Alice Smith at alice@acme.com with AKIAIOSFODNN7EXAMPLE.' }]
});

// Incoming LLM answer is automatically rehydrated with "Alice Smith (alice@acme.com)":
console.log(completion.choices[0].message.content);

⚡ Why @privacyscrubber/sdk vs Microsoft Presidio?

Microsoft Presidio is the Python standard, but deploying it in a Node.js / TypeScript stack requires running heavy Python microservices, Docker containers, and 500MB+ spaCy NLP models with 35–120ms latency. @privacyscrubber/sdk runs 100% in-process with zero dependencies:

👉 View @privacyscrubber/sdk on NPM | Full documentation, Express middleware, LangChain transforms, and 25 compliance profiles.

🤖 AI Orchestrator Recipes: LangChain, LlamaIndex, CrewAI & AutoGPT

If you are building autonomous agents, RAG vector pipelines, or backend services rather than single-user IDE prompts, use @privacyscrubber/sdk to sanitize data in-memory:

1. LangChain.js & LCEL Pipelines

import { ChatOpenAI } from '@langchain/openai';
import { createLangChainTransform } from '@privacyscrubber/sdk';

const transform = createLangChainTransform({ defaultProfile: 'Dev' });

// 1. Sanitize in local RAM before LLM call:
const { scrubbedText, tokenMap } = transform.preprocess(
  "Deploying database with user admin and pwd postgresql://user:SecretPass123@db.internal:5432/prod"
);

// 2. Outbound LLM receives only [DB_URI_1]
const model = new ChatOpenAI({ model: 'gpt-4o' });
const response = await model.invoke(scrubbedText);

// 3. Inbound response is automatically restored with original secrets in local RAM:
const finalOutput = transform.postprocess(response.content, tokenMap);

2. LlamaIndex.TS & RAG Vector Ingestion

import { sanitize } from '@privacyscrubber/sdk';
import { Document, VectorStoreIndex } from 'llamaindex';

// Strip customer PII and credentials BEFORE vector embedding into Pinecone / Chroma:
const rawText = "Customer John Doe (SSN: 042-88-9124, email: john@example.com) requested refund.";
const { scrubbedText, tokenMap, telemetry } = sanitize(rawText, { profile: 'Finance' });

// Vector store indexes only syntax-preserving tokens [NAME_1], [SSN_1], [EMAIL_1]:
const document = new Document({ text: scrubbedText, metadata: { psRiskLevel: telemetry.riskLevel } });
const index = await VectorStoreIndex.fromDocuments([document]);

3. CrewAI & Multi-Agent Swarms (Sidecar Mode / Python Interop)

# Run lightweight zero-dependency local daemon (<1ms in-memory, 0 external network calls):
npx @privacyscrubber/sdk sidecar --port 3100

# In your Python CrewAI / AutoGen Agent tools:
import requests

def sanitize_agent_input(prompt: str) -> tuple[str, dict]:
    res = requests.post("http://127.0.0.1:3100/sanitize", json={"text": prompt, "profile": "Dev"}).json()
    return res["scrubbedText"], res["tokenMap"]

def restore_agent_output(ai_response: str, token_map: dict) -> str:
    res = requests.post("http://127.0.0.1:3100/restore", json={"text": ai_response, "tokenMap": token_map}).json()
    return res["restoredText"]

4. AutoGPT / Multi-Turn Autonomous Agents

import { PrivacyScrubberEngine, createGuardedTools } from '@privacyscrubber/sdk';

const engine = new PrivacyScrubberEngine({ defaultProfile: 'Dev' });
// Equips agent with tools that intercept commands, file reads, and git diffs before model exposure:
const guardedTools = createGuardedTools(engine);

🏢 Enterprise & Production Licensing:

• Self-Serve Developer SDK ($299/mo flat or $2,990/yr): Unlimited internal backend nodes, microservices, and RAG pipelines. Get SDK License

• PrivacyScrubber TEAMS ($99/mo flat): Unlimited team seats, centralized policy enforcement, encrypted session handoff. Deploy TEAMS

• Enterprise Air-Gapped License: On-premise source code distribution, zero-network custom models. Contact Enterprise

🛡️ Architecture & Security Deep-Dive (Zero-Trust vs Cloud DLP)

When AI IDEs (Cursor, Claude Desktop, Windsurf) connect to model providers, developer credentials, database connection strings, and internal customer PII are at continuous risk of prompt exfiltration. The @privacyscrubber/mcp-server enforces four immutable architectural guarantees:

1. Stdio Air-Gapped Transport: The MCP server communicates exclusively over local standard input/output (stdio) child processes spawned by your IDE. It opens zero external listening ports and initiates zero remote network requests.

2. Volatile RAM-Only Token Map: The mapping table between synthetic tokens ([AWS_KEY_1], [EMAIL_1]) and raw cleartext is maintained exclusively in ephemeral node memory and is wiped the moment your IDE session closes.

3. Deterministic AST Lookarounds vs Cloud Proxy Overhead: Unlike cloud DLP gateways (Nightfall, Skyflow) that add 200–400ms latency and transmit unencrypted code to third parties, @privacyscrubber/mcp-server runs locally in <2ms with zero data egress.

4. Permanent Standards & Academic Validation:

   • IETF Specification: draft-sibiryakov-ztds-protocol-01 — Revision 01 · 2026-09-23 · 13 pages

   • CERN / Zenodo Foundation: DOI 10.5281/zenodo.22058770

   • Center for Open Science (OSF): DOI 10.17605/OSF.IO/5BYJF

   • Patent Pending: Israel Patent Office Application IL 331905 (WIPO DAS Code: B17B)

⚙️ Client Integrations

Claude Desktop

Add this to your Claude Desktop config file:

• macOS: ~/Library/Application Support/Claude/claude_desktop_config.json

• Windows: %APPDATA%\Claude\claude_desktop_config.json

{
  "mcpServers": {
    "privacyscrubber": {
      "command": "npx",
      "args": ["-y", "@privacyscrubber/mcp-server"],
      "env": {
        "PRIVACYSCRUBBER_KEY": "YOUR_OPTIONAL_PRO_LICENSE_KEY"
      }
    }
  }
}

Cursor / Windsurf

1. Navigate to Settings -> Features -> MCP.

2. Add new MCP server:

   • Name: privacyscrubber

   • Type: command

   • Command: npx -y @privacyscrubber/mcp-server

3. Optional: Set PRIVACYSCRUBBER_KEY as an environment variable in your system shell.

Cline / Roo Code

Add to cline_mcp_settings.json:

{
  "mcpServers": {
    "privacyscrubber": {
      "command": "npx",
      "args": ["-y", "@privacyscrubber/mcp-server"],
      "env": {
        "PRIVACYSCRUBBER_KEY": "YOUR_OPTIONAL_PRO_LICENSE_KEY"
      }
    }
  }
}

Claude Code CLI

Add directly from your terminal:

claude mcp add privacyscrubber -- npx -y @privacyscrubber/mcp-server

🛠️ Provided Tools & JSON-RPC Specifications

1. sanitize_text

Redacts PII, secrets, API keys, and credentials from a text block and populates the volatile local replacement mapping.

• Arguments:

  • text (string, required): The raw content or logs to sanitize.

  • profile (string, optional): Gated industry detection profile (e.g., 'General', 'Dev', 'Medical', 'Legal', 'Compliance'). Defaults to 'General'.

• JSON-RPC Call Example:

  {
    "method": "tools/call",
    "params": {
      "name": "sanitize_text",
      "arguments": {
        "text": "Contact me at dev-key-1234 or jane.doe@company.com",
        "profile": "General"
      }
    }
  }

• Response Example:

  {
    "content": [
      {
        "type": "text",
        "text": "Contact me at [SECRET_1] or [EMAIL_1]"
      }
    ]
  }

2. reveal_text

Detokenizes the AI response back to the original values locally.

• Arguments:

  • text (string, required): The response from the LLM containing tokenized placeholders.

• JSON-RPC Call Example:

  {
    "method": "tools/call",
    "params": {
      "name": "reveal_text",
      "arguments": {
        "text": "Please reach out to [EMAIL_1] regarding the update."
      }
    }
  }

• Response Example:

  {
    "content": [
      {
        "type": "text",
        "text": "Please reach out to jane.doe@company.com regarding the update."
      }
    ]
  }

3. sanitize_file

Reads a local file, extracts text, sanitizes it, and returns the redacted template for LLM analysis.

• Supported Formats: Plain text (source code, logs, CSV, JSON, markdown) and Microsoft Word (.docx) documents.

• Arguments:

  • filePath (string, required): Absolute file path to read and sanitize.

  • profile (string, optional): The industry detection profile.

4. guard_exec (Command Execution Firewall)

Safely executes terminal commands in an isolated child process, masking stdout/stderr PII, database credentials, and API keys in local RAM before passing them to the AI agent. Includes a CISO audit receipt in stderr.

• Arguments:

  • command (string, required): The shell command to execute (e.g. cat .env, docker logs web, git diff).

  • cwd (string, optional): Working directory.

  • profile (string, optional): Detection profile (defaults to Dev).

  • timeout_ms (number, optional): Timeout in ms (defaults to 15000).

5. guard_read_file (Credential-Masking File Reader)

Reads files (.env, configs, source code, database dumps) and tokenizes all passwords, JWTs, and PII in volatile memory, returning safe redacted content for AI reasoning.

• Arguments:

  • file_path (string, required): Path to file.

  • profile (string, optional): Detection profile (defaults to Dev).

  • max_lines (number, optional): Line cap for large files (defaults to 500).

6. guard_git_diff (Pre-Commit & Diff Sanitizer)

Inspects staged (--cached) or unstaged repository diffs, redacting any newly introduced secrets or PII in local RAM before AI code review or commit message generation.

• Arguments:

  • staged (boolean, optional): If true, inspects staged changes (git diff --cached). Defaults to false.

  • cwd (string, optional): Working directory.

  • profile (string, optional): Detection profile (defaults to Dev).

7. guard_apply_patch (Safe Patch Applicator)

Reverses token placeholders ([API_KEY_1], [SECRET_1]) in AI-generated code or text by looking up the local RAM session map, creating a .bak backup, and writing authentic cleartext directly to disk. The remote LLM never sees real secrets.

• Arguments:

  • file_path (string, required): Path to target file.

  • content (string, required): Content containing tokens to restore on disk.

  • create_backup (boolean, optional): Backup existing file before write (defaults to true).

8. create_agent_rules (1-Click Agent Rule Injection)

Automatically scaffolds CISO-grade Zero-Trust directives into .cursorrules, .windsurfrules, CLAUDE.md, .github/copilot-instructions.md, or .clinerules.

• Arguments:

  • agent_types (array, optional): ["all"], ["cursor"], ["windsurf"], ["claude_code"], ["copilot"], ["cline"]. Defaults to ["all"].

  • workspace_dir (string, optional): Workspace directory.

9. check_status

Returns a visual dashboard showing your current tier, session request count, active profiles, and upgrade instructions. Use it at any time to check your license status or get setup help.

• Arguments: (none required)

• JSON-RPC Call Example:

  {
    "method": "tools/call",
    "params": { "name": "check_status", "arguments": {} }
  }

• Response Example (Free Tier):

  ╔══════════════════════════════════════════════════╗
  ║       PrivacyScrubber MCP Server v2.2.4          ║
  ╠══════════════════════════════════════════════════╣
  ║  🔓 Tier: FREE                                   ║
  ║  📊 Session requests: 5                          ║
  ║  📁 Input size limit: 15,000 characters/request  ║
  ╠══════════════════════════════════════════════════╣
  ║  🏷️  Profiles: General only — PRO unlocks 25 more ║
  ║  📋 Custom rules: 🔒 Locked — requires PRO       ║
  ╠══════════════════════════════════════════════════╣
  ║  💳 Upgrade to PRO — $110 Lifetime               ║
  ║     https://privacyscrubber.com/pricing?utm_source=npm&utm_medium=readme&utm_campaign=mcp_server          ║
  ╠══════════════════════════════════════════════════╣
  ║  After purchase, add your key to MCP config:     ║
  ║  "PRIVACYSCRUBBER_KEY": "<your-key-here>"        ║
  ║  Full setup guide:                               ║
  ║  https://privacyscrubber.com/features/mcp/?utm_source=npm&utm_medium=readme&utm_campaign=mcp_server       ║
  ╚══════════════════════════════════════════════════╝

🛡️ Standalone CLI: ps-guard

PrivacyScrubber bundles ps-guard for Unix pipe, pre-commit, and agentic workflows:

# Pipe any output through RAM redaction
cat .env | npx ps-guard --profile dev

# Execute commands through the ZTDS safety wrapper
npx ps-guard -- npm test

# Review git diff with secrets redacted
npx ps-guard --diff --staged

# Generate rules for all AI IDEs (.cursorrules, .windsurfrules, CLAUDE.md, copilot, cline)
npx ps-guard --rules

🌐 Browser Extension & Web Client

Looking for real-time protection directly inside your web browser?

• Chrome Extension: Get the PrivacyScrubber Chrome Extension to sanitize prompts directly inside ChatGPT, Claude, and Gemini in real-time.

• Web Sandbox: Use the zero-server browser sanitization tools at PrivacyScrubber Homepage.

📄 License & Commercial Upgrade

By default, the server runs under the Free Tier (restricted to 15,000 characters per request and the basic General PII profile). To unlock 30 specialized engineering, medical, legal, and financial PII profiles, as well as team-wide custom rules, you can purchase a commercial license.

Feature Comparison

👉 Acquire a PRO / TEAMS License Key at privacyscrubber.com/pricing

🔐 After Purchase: Activate PRO in Your MCP Client

After purchasing a PRO license at privacyscrubber.com/pricing, you will receive a license key. Add it to your MCP client config as an environment variable: PRIVACYSCRUBBER_KEY.

Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

{
  "mcpServers": {
    "privacyscrubber": {
      "command": "npx",
      "args": ["-y", "@privacyscrubber/mcp-server"],
      "env": {
        "PRIVACYSCRUBBER_KEY": "YOUR_LICENSE_KEY_HERE"
      }
    }
  }
}

Restart Claude Desktop after saving.

Cursor

1. Go to Settings → Features → MCP Servers.

2. Find privacyscrubber and click Edit.

3. Add the environment variable: PRIVACYSCRUBBER_KEY=YOUR_LICENSE_KEY_HERE.

4. Restart Cursor.

Alternatively, export it system-wide so all tools pick it up:

# macOS / Linux — add to ~/.zshrc or ~/.bashrc
export PRIVACYSCRUBBER_KEY="YOUR_LICENSE_KEY_HERE"

Windsurf

Edit ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "privacyscrubber": {
      "command": "npx",
      "args": ["-y", "@privacyscrubber/mcp-server"],
      "env": {
        "PRIVACYSCRUBBER_KEY": "YOUR_LICENSE_KEY_HERE"
      }
    }
  }
}

Verify Activation

After adding the key, ask your AI agent to call check_status:

Use the check_status tool from PrivacyScrubber MCP

🔗 Ecosystem & Production Architecture Guides

• 🌐 Web App: https://privacyscrubber.com

• 📦 Node.js / TypeScript SDK: @privacyscrubber/sdk

• 🧩 Chrome Extension: Chrome Web Store

• 🛡️ RAG & Vector Databases: Sanitizing PII Before Vector DB Ingestion (Pinecone, Chroma, Qdrant)

• 🤖 LangChain & LlamaIndex: In-Memory PII Middleware for AI Agent Pipelines

• ⚡ AWS Comprehend Alternative: In-Memory Redaction Without Egress or Cloud Overhead

📚 Academic Foundations & Regulatory Verification

PrivacyScrubber and the Zero-Trust Data Sanitization (ZTDS) protocol are backed by published scientific, clinical, and legal treatises:

Citing PrivacyScrubber in Research & Audits

@software{sibiryakov2026privacyscrubber,
  author = {Sibiryakov, Ilya},
  title = {PrivacyScrubber: Zero-Trust Data Sanitization (ZTDS) Engine & MCP Server},
  year = {2026},
  publisher = {Zenodo},
  doi = {10.5281/zenodo.22058770},
  url = {https://github.com/moxno/privacyscrubber-mcp}
}

📄 License

MIT © Ilya Sibiryakov (BrandMeWeb)

⚖️ Intellectual Property & Virtual Patent Marking

The Zero-Trust Data Sanitization (ZTDS) architecture, in-memory deterministic tokenization, cryptographic session handoff, and stdio execution methods implemented in this package are proprietary technology of Ilya Sibiryakov (BrandMeWeb) and are protected under Patent Pending status:

• Patent Office: State of Israel Ministry of Justice, Patent Office (ILPO)

• Application Number: 331905 (Tracking ID: 94221)

• Filing / Priority Date: September 14, 2026 (Paris Convention Art. 4 & 35 U.S.C. § 119 Priority)

• Official Title: SYSTEM AND METHOD FOR CLIENT-SIDE ZERO-TRUST DATA SANITIZATION AND CRYPTOGRAPHIC SESSION HANDOFF IN ARTIFICIAL INTELLIGENCE WORKFLOWS

• Virtual Patent Marking: privacyscrubber.com/patents/ in accordance with 35 U.S.C. § 287(a).

🌐 Internet Engineering Task Force (IETF) Specification

• Specification Title: The Zero-Trust Data Sanitization (ZTDS) Protocol for Frontier Artificial Intelligence Ingestion

• Document Category: IETF Internet-Draft (Individual Submission)

• IETF Datatracker: https://datatracker.ietf.org/doc/draft-sibiryakov-ztds-protocol/

• Archive Plaintext: https://www.ietf.org/archive/id/draft-sibiryakov-ztds-protocol-01.txt