ztds-mcp
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@ztds-mcpMask the PII in this support ticket before sending it to the LLM."
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
ZTDS MCP Server (ztds-mcp)
Open-source reference implementation of the Zero-Trust Data Sanitization (ZTDS) protocol for the Model Context Protocol (MCP) ecosystem. Conforms to the open architectural specification and IETF Internet-Draft draft-sibiryakov-ztds-protocol-00.
Runs 100% locally with zero network calls, zero external subprocessors, zero disk writes, and zero telemetry.
The 4 Core Protocol Invariants
Invariant 1: Zero External Egress Prior to Sanitization
Cleartext PII, PHI, and credentials never cross the local execution boundary unmasked.Invariant 2: Deterministic Context-Preserving Reversible Tokenization
Sensitive values are replaced by synthetic tokens ([EMAIL_TOKEN_1],[API_SECRET_TOKEN_1]) maintaining syntactic context for LLMs.Invariant 3: Verifiable Ephemeral RAM Isolation (Theorem 2 Zeroization)
Mapping tables exist strictly in volatile memory and are zeroized upon session termination.Invariant 4: Subprocessor Chain Exclusion
Operates strictly as a local computational utility under GDPR Recital 26, rendering Data Processing Agreements (DPAs) unnecessary.
Related MCP server: privacy-gateway-mcp
Installation & Client Configuration
1. Claude Desktop
Add to your claude_desktop_config.json:
{
"mcpServers": {
"ztds": {
"command": "npx",
"args": ["-y", "ztds-mcp"]
}
}
}Config file locations:
macOS:
~/Library/Application Support/Claude/claude_desktop_config.jsonWindows:
%APPDATA%\Claude\claude_desktop_config.jsonLinux:
~/.config/Claude/claude_desktop_config.json
2. Cursor IDE
Add to your Cursor MCP settings (Settings -> Features -> MCP -> Add New MCP Server):
Name:
ztdsType:
commandCommand:
npx -y ztds-mcp
Or add to .cursor/mcp.json in your workspace:
{
"mcpServers": {
"ztds": {
"command": "npx",
"args": ["-y", "ztds-mcp"]
}
}
}3. Windsurf / Codeium
Add to ~/.codeium/windsurf/mcp_config.json:
{
"mcpServers": {
"ztds": {
"command": "npx",
"args": ["-y", "ztds-mcp"]
}
}
}Available MCP Tools
Tool | Description |
| Masks sensitive PII/credentials with deterministic surrogate tokens prior to LLM transmission. |
| Restores original cleartext from volatile in-memory mapping into LLM output. |
| Scans text for exposed credentials and PII, returning SHA-256 integrity receipt and risk score. |
| Retrieves RFC v1.0 standard details, academic citations, and enterprise documentation. |
| Purges and zeroizes all volatile session token mappings (Theorem 2). |
Universal Baseline vs Commercial Production Profiles
This open-source server covers universal baseline entities (Email, Phone, SSN, Credit Cards, IPv4, IBAN, API Secrets).
For production enterprise workloads requiring:
30+ Specialized Industry Profiles: HIPAA PHI (18 identifiers), PCI-DSS (cardholder data & CVV), GLBA Financial, SEC 17a-4, CJIS Law Enforcement, FERPA Student Records, European National IDs.
Agentic Guard Automation: Autonomous zero-trust tool wrappers (
guard_exec,guard_read_file,guard_apply_patch).Team Seat Licensing: Offline air-gapped license tokens without cloud telemetry.
Headless SDK: Backend RAG pipeline redaction for Node.js / TypeScript / Python.
Deploy the production commercial engine:
# Production MCP Server
npm install -g @privacyscrubber/mcp-server
# Headless Backend SDK
npm install @privacyscrubber/sdkWebsite: https://privacyscrubber.com
Verification & Self-Test
To run the offline test suite:
node test.jsConforms to standard JSON-RPC 2.0 stdio protocol. Zero runtime dependencies.
License
Apache-2.0. Maintained by the ZTDS AI Consortium (Working Group WG-1). Website: https://ztds.ai
Available Tools
5 toolsztds_auditC
Audit text for PII/secrets exposure against ZTDS RFC v1.0 standard and generate an attestation receipt.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The text to inspect for exposure risks. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden, yet it says nothing about whether the input text is persisted, what permissions are needed, or whether the operation has any side effects. It does at least signal that a secondary artifact (an attestation receipt) is produced, which hints at a non-trivial return shape.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
One tight sentence with the action front-loaded and no filler. It is arguably under-specified rather than padded, so conciseness itself is fine.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a one-parameter tool with no output schema, the description is adequate but thin: it names the standard and the receipt but doesn't describe what the audit result or receipt contains, nor whether text leaves the session.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema coverage is 100% for the single 'text' parameter, so the schema already documents the input fully. The description adds only the compliance framing and does not clarify the text's expected size, encoding, or format.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb+resource pair ('Audit text for PII/secrets exposure') and names the governing standard (ZTDS RFC v1.0). It implies a read-only inspection role distinct from ztds_sanitize/ztds_restore, but never explicitly contrasts with them.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to reach for this tool versus ztds_sanitize (which presumably redacts) or ztds_info. The agent must infer that 'audit' means inspect-without-modifying purely from the name.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ztds_infoA
Retrieve ZTDS open specification details (RFC v1.0, IETF draft-02) and enterprise upgrade guide.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, but the tool takes zero parameters and the verb 'Retrieve' clearly marks it as a non-mutating read, so the behavioral risk surface is small. The description adds version context (RFC v1.0, IETF draft-02) but says nothing about authentication requirements, whether the content is static/cached, or the form the content is returned in.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single sentence with the verb and resource front-loaded and zero filler. Nothing in it is redundant with the schema or annotations, and nothing needs trimming.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
With no output schema, the description should carry more of the return-value burden; it names the two content areas but not the format (text/markdown/JSON) or whether the response is static. For a zero-arg reference tool this is mostly adequate, but a sentence on return shape and any auth requirement would close the gap.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool accepts no parameters, so there is nothing for the description to disambiguate; the baseline for a zero-param tool applies. The description correctly does not invent parameter semantics and instead spends its words on what the call returns.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb (Retrieve) and a concrete resource (ZTDS open specification details plus enterprise upgrade guide), with version identifiers that pin down the content. It is clearly the informational/reference tool among operational siblings (sanitize, restore, audit, reset_session), though it never names them explicitly.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is implied rather than stated: an agent can infer this is the lookup tool to consult for spec/upgrade reference material before operating on ZTDS. There is no explicit when-to-use condition, no prerequisites, and no mention of alternatives or how to proceed after retrieving the material.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ztds_reset_sessionC
Zeroize and purge volatile in-memory token mappings (Theorem 2 RAM zeroization).
| Name | Required | Description | Default |
|---|---|---|---|
| sessionId | No | Optional session identifier to clear. If omitted, clears all sessions. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. "Zeroize and purge" hints at destruction and "volatile in-memory" suggests transience, but the description never states whether the operation is irreversible, whether it requires authentication or a privileged context, or what happens to tokens still in use. That is a material gap for a destructive write tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no filler; it is efficient, though the parenthetical "(Theorem 2 RAM zeroization)" is internal jargon that does little for tool selection.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The one-parameter, no-output-schema surface is simple and fully covered by the schema, and no return values need explaining. The missing piece is destructive-operation context (irreversibility, scope of clearing) that no annotation supplies.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100% and the schema itself explains the optional sessionId and the omit-to-clear-all fallback, so the description adds nothing beyond it. Baseline 3 applies when the schema does all the work.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description names a specific verb pair ("Zeroize and purge") and resource ("volatile in-memory token mappings"), so an agent knows this is a destructive memory-cleanup operation. It does not, however, explicitly distinguish itself from sibling ztds_sanitize, which an agent could plausibly confuse it with.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
There is no statement of when to use this tool, when not to, or which sibling (e.g. ztds_sanitize) to prefer instead. The only routing signal is implicit in the schema's "if omitted, clears all sessions" note.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ztds_restoreB
Restore authentic cleartext values into LLM-generated output from local in-memory token mapping.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The sanitized response text received from the LLM containing surrogate tokens. | |
| sessionId | No | Optional session identifier used during initial sanitization. |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden. It does disclose the key mechanism ("local in-memory token mapping"), which usefully implies statefulness and that the mapping is scoped to the local process. It does not state failure behavior on an unknown/expired session, whether the restore is read-only or consumes the mapping, or any auth requirements.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single tight sentence that front-loads the action and the payload, with no filler. It is appropriately sized, though it could carry one more clause about session requirements at little cost.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is simple (two parameters, no nested objects, no output schema) and the description covers the core transformation and its state source. It omits session-scoping semantics and failure modes, which matter for a stateful in-memory restore operation, so it is adequate but not complete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters are already documented, including that sessionId is optional and set during sanitization. The description adds no format, matching, or fallback semantics for text or sessionId. Baseline 3 is appropriate when the schema does the heavy lifting.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description pairs a specific verb ("Restore") with a specific resource ("authentic cleartext values") and the target artifact ("LLM-generated output"), which is far more precise than a tautology. It does not name or explicitly contrast with ztds_sanitize, though the inverse relationship is inferable from the sibling names.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
Usage is only implied: the agent can infer this is the reverse step of ztds_sanitize and applies to text containing surrogate tokens. There is no explicit statement of when to call it versus ztds_reset_session or ztds_audit, and no stated prerequisite that it must run in the same process/session that performed the sanitization.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
ztds_sanitizeB
Sanitize sensitive PII and secrets in prompt text locally using ZTDS RFC v1.0 zero-egress invariants.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The raw text to sanitize before sending to LLM context. | |
| sessionId | No | Optional session identifier to preserve token consistency across conversational turns (default: "default"). |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full behavioral burden, but it does disclose a meaningful trait: sanitization runs 'locally' with 'zero-egress invariants', meaning text never leaves the host. However, it omits whether the operation is reversible (implied by sibling ztds_restore), what happens to session state, or how detection boundaries are determined.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
A single front-loaded sentence with no wasted clauses. The jargon ('ZTDS RFC v1.0 zero-egress invariants') is slightly opaque but does not impede scanning or intent.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a mutation tool with no annotations and no output schema, the description covers the core action and the local/zero-egress trait but leaves the agent without reversibility expectations, return behavior, or the relationship to ztds_restore. Adequate but with clear gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 100%, so both parameters (text and sessionId) are already fully documented in the schema. The description adds no syntax, format, or default details beyond that, so the baseline 3 applies.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description gives a specific verb (Sanitize) and resource (sensitive PII and secrets in prompt text), which clearly distinguishes the action. It does not name sibling ztds_restore, which is the natural inverse, but the sanitize-vs-restore distinction is inferable from the verbs themselves.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
No explicit when-to-use, when-not, or alternative routing is provided. A sibling ztds_restore exists for reversing sanitization, but the description never mentions it or states the conditions under which this tool should be chosen over ztds_audit or ztds_info. Usage is only vaguely implied.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
5 tool updates
v0.1.0- First observed
ztds_audit - First observed
ztds_info - First observed
ztds_reset_session - First observed
ztds_restore - First observed
ztds_sanitize
TDQS
Scored across 5 tools
Each tool has a clearly distinct function: sanitize redacts PII/secrets, restore reverses token mapping, audit checks exposure and generates receipts, info retrieves specification details, and reset_session zeroizes in-memory mappings. There is no functional overlap between any pair of tools.
All tools share a consistent ztds_ prefix and snake_case, with most names using a verb form (sanitize, restore, audit, reset_session). The exception is ztds_info, which is noun-based rather than verb-based, creating a minor deviation.
Five tools is well-scoped for a focused zero-trust data sanitization server. Each tool earns its place by covering a distinct operation in the sanitization/restoration/audit lifecycle, without redundancy.
The surface covers the full lifecycle: sanitize (redact), restore (unmask), audit (verify and attest), reset_session (cleanup), plus info for specification details. No obvious gaps for the stated purpose of local PII/secrets management.
Maintenance
Related MCP Connectors
Detect and redact PII and secrets before text reaches an LLM, with reversible placeholders.
Detect and redact PII and secrets (API keys, tokens) in text, HTML or PDF before it reaches an LLM.
Deterministic runtime safety for AI agents: scan PII, gate tool actions, verify LLM output.
Deterministic trust gate for AI output: leaked-secret, prompt-injection & PII in one call.
Related MCP Servers
- AlicenseAqualityDmaintenanceScans prompts for PII and masks or redacts sensitive data locally before sending to an LLM, supporting multiple anonymization modes.1MIT
- AlicenseAqualityCmaintenanceEnables safe interaction with cloud LLMs by redacting sensitive entities into reversible placeholders, enforcing deterministic egress policies with human approval, and rehydrating responses so real data never leaves the process.4MIT
- FlicenseNot gradedqualityBmaintenanceEnables local zero-knowledge encryption of a personal vault and sanitization of PII such as credentials, credit cards, and addresses before dispatch to cloud LLMs, with client-side rehydration of masked data.7-
- FlicenseNot gradedqualityBmaintenanceEnables agents to encrypt and sanitize sensitive data such as credentials, credit card numbers, and addresses locally before dispatching prompts to cloud LLMs, then rehydrate the masked values client-side. It runs deterministically with zero external dependencies over MCP JSON-RPC stdio, so no plaintext PII leaves the user's machine.7-