phantomswap
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., "@phantomswapMask my resume with the 'jobsearch' session before sending it to AI."
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.
๐ญ PhantomSwap
"Your data, ghosted." โ Privacy-first, bidirectional data masking & unmasking service for safe AI interactions.
๐ก The Problem & The Solution
When collaborating with Large Language Models (LLMs) on resumes, portfolio websites, codebases, or sensitive documents, personal identifiers (PII) like names, emails, phone numbers, colleges, and internal company project names are exposed.
PhantomSwap solves this locally:
Define a Swap Session: Map your real personal data to realistic fake placeholders.
๐ญ Mask: Swap real values with fake placeholders before sending your text or code to AI.
๐ค Send to AI: Let AI build your portfolio website, optimize your resume, or refactor your code.
๐ Unmask: Seamlessly restore all real personal values back across the generated text or entire codebase directories!
100% Local Execution โ Your real data never leaves your computer.
Related MCP server: mcp-redact
๐ Key Features
โก Bidirectional Replacement Engine: Guaranteed collision-safe two-pass replacement avoiding chain-replacement corruption.
๐จ Modern Dark Glassmorphism UI: Beautiful web dashboard with live stats, copy buttons, search, and directory inspector.
๐ Bulk Directory Processing: Recursively mask and unmask entire projects (e.g. AI-generated portfolio website folders) with automatic
.baksafety backups.๐ค Native MCP Server: Integrated Model Context Protocol server for AI coding assistants (Claude Desktop, Cursor, Windsurf).
โจ๏ธ Rich CLI: Feature-complete terminal CLI with rich formatted tables and pipe support.
๐ Task Audit History: Complete tracking and logging of every masking operation.
๐๏ธ Architecture
flowchart TD
subgraph Interfaces
UI["๐จ Web UI Dashboard (Port 8000)"]
CLI["โจ๏ธ Terminal CLI (Typer + Rich)"]
MCP["๐ค MCP Server (Claude / Cursor / Windsurf)"]
API["๐ REST API (FastAPI)"]
end
subgraph Core
ENGINE["๐ง Two-Pass Replacement Engine"]
FILEOPS["๐ Bulk File & Directory Ops"]
end
subgraph Storage
DB[("๐พ Local SQLite DB (phantomswap.db)")]
BAK[("๐ก๏ธ Automatic .bak File Backups")]
end
UI --> API
CLI --> API
API --> ENGINE
API --> FILEOPS
MCP --> ENGINE
MCP --> FILEOPS
API --> DB
MCP --> DB
FILEOPS --> BAK๐ Quick Start
1. Setup & Installation
Using uv (Fastest):
# Create virtual environment and install dependencies
uv venv
uv pip install -r requirements.txtOr using standard Python (venv):
# Windows
py -m venv .venv
.venv\Scripts\pip install -r requirements.txt
# Linux / macOS
python3 -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt2. Run the Web Dashboard & API
Local:
# With uv
uv run python -m app.main
# Or with python virtualenv
.venv\Scripts\python -m app.mainOr with Docker / Docker Compose:
# Build and run container with persistent SQLite volume
docker compose up --build -dOpen your browser at:
๐ Web Dashboard: http://127.0.0.1:8000
๐ Interactive Swagger API Docs: http://127.0.0.1:8000/docs
โจ๏ธ Command Line Interface (CLI)
# List swap sessions
uv run python -m cli.main sessions list
# Create a new session
uv run python -m cli.main sessions create my-resume \
--description "Masking resume personal details" \
-m "Shiva Patel:Alex Johnson" \
-m "shiva.patel@gmail.com:alex.johnson@example.com" \
-m "IIT Delhi:State University"
# Mask text directly from terminal
uv run python -m cli.main mask --session my-resume --text "Shiva Patel graduated from IIT Delhi."
# Output: Alex Johnson graduated from State University.
# Unmask text
uv run python -m cli.main unmask --session my-resume --text "Alex Johnson graduated from State University."
# Output: Shiva Patel graduated from IIT Delhi.
# Mask an entire directory (e.g. portfolio project)
uv run python -m cli.main dir mask D:\projects\MyPortfolio --session my-resume --ext .html,.css,.js
# Unmask the directory when AI generation is complete
uv run python -m cli.main dir unmask D:\projects\MyPortfolio --session my-resume --ext .html,.css,.js
# View task history
uv run python -m cli.main history๐ค Model Context Protocol (MCP) Integration
PhantomSwap includes a built-in MCP server that allows AI assistants to mask and unmask sensitive project context autonomously.
Claude Desktop Configuration
Add the following to your claude_desktop_config.json:
{
"mcpServers": {
"phantomswap": {
"command": "uv",
"args": [
"run",
"--directory",
"d:/DEVELOPMENT/MulipleStringChanger",
"python",
"-m",
"mcp_server.server"
]
}
}
}Available MCP Tools:
phantomswap_list_sessions: List all available masking profiles.phantomswap_get_session: Retrieve replacement mappings.phantomswap_create_session: Create new session with key-value pairs.phantomswap_mask_text: Anonymize text before sending to AI.phantomswap_unmask_text: Restore original values in AI responses.phantomswap_mask_directory: Bulk mask project directories.phantomswap_unmask_directory: Bulk unmask project directories.
๐งช Testing
Run the automated test suite with pytest:
uv run pytest tests/ -v๐ License
MIT License ยฉ 2026. Built with privacy in mind.
Available Tools
7 toolsphantomswap_create_sessionB
Create a new swap session with key-value mappings. mappings should be a list of objects like: [{"real_value": "Real", "fake_value": "Fake"}]
| Name | Required | Description | Default |
|---|---|---|---|
| name | Yes | ||
| mappings | Yes | ||
| description | Yes | ||
| case_sensitive | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
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 of behavioral disclosure. It describes the mapping format but does not explain what happens when a session is created, whether it persists, how naming collisions are handled, or what the response contains. This is a significant transparency gap.
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?
The description is two sentences with no filler. The essential example for the most complex parameter is front-loaded, making it quick to parse.
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?
Given four parameters and no annotations, this description is incomplete. It covers the mappings parameter well but omits semantics for the other required parameters and any context about session creation behavior. An agent would likely need to guess at several details.
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 0%, so the description must compensate. It provides a helpful example for 'mappings', but leaves 'name', 'description', and 'case_sensitive' semantically unexplained beyond their schema titles and default value.
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 states a specific verb and resource: 'Create a new swap session with key-value mappings.' This clearly distinguishes it from sibling tools like phantomswap_list_sessions or phantomswap_mask_text. The purpose is immediately understandable.
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?
The verb 'create' implies when to use it, but there is no explicit guidance about when to choose this over alternatives, no preconditions, and no mention of what a 'swap session' is used for afterward. The context is inferable but not stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phantomswap_get_sessionA
Get full details and all key-value mappings of a specific swap session.
| Name | Required | Description | Default |
|---|---|---|---|
| session_name_or_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the behavioral disclosure burden. 'Get' clearly signals a read operation, and 'full details and all key-value mappings' hints at the response scope. However, it does not mention behavior for nonexistent sessions, authentication requirements, or the fact that no state is modified. This is adequate for a simple getter but not rich.
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?
The description is a single, front-loaded sentence with no filler or redundancy. It states the verb, the resource, and the scope of returned data efficiently.
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 low-complexity getter with one self-descriptive parameter and an output schema, the description covers the core operation. The output schema handles return-value details, so not explaining them is acceptable. Minor gaps remain around not-found behavior and explicit relationship to sibling tools, keeping it from a 5.
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 0%, so the description should compensate for the parameter's meaning. It only says 'a specific swap session,' which largely restates what session_name_or_id already conveys. It does not explain accepted formats, whether both name and ID resolve to the same session, or what happens on ambiguous or missing values.
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 uses a clear verb ('Get') and identifies the exact resource ('a specific swap session'). It also states the tool returns 'full details and all key-value mappings,' which distinguishes it from list_sessions and makes the operational scope obvious.
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 context is only implied: the agent can infer this tool is for retrieving a single session while list_sessions is for enumerating them. The description does not explicitly state when to prefer this tool, when not to use it, or how it relates to create_session or the masking/unmasking siblings.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phantomswap_list_sessionsA
List all available PhantomSwap swap sessions with their summary details.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the behavioral disclosure burden. It does convey a read-only enumeration behavior and that results are summary-level, which is useful. However, it does not mention potential pagination, ordering, empty results, or any side effects/caveats, leaving some gaps for a no-annotation 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. Every phrase earns its place by identifying the action, the resource scope, and the output nature.
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 zero-parameter listing tool with an output schema present, the description is largely sufficient. It would be more complete with explicit guidance on when to use list versus get, but given the low complexity and rich schema context, the gap is minor.
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?
There are zero parameters and schema coverage is effectively complete, so there is nothing for the description to elaborate. The baseline of 4 applies; the description adds no parameter-specific detail because none is needed.
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 uses a specific verb ('List') and resource ('all available PhantomSwap swap sessions') and clarifies the output ('summary details'). This clearly distinguishes it from sibling tools like get_session (one session) and create_session (new session).
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?
The description states what the tool does but gives no explicit guidance on when to choose it over alternatives such as phantomswap_get_session. There is no mention of use cases, exclusions, or routing logic; any usage inference is left to the agent.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phantomswap_mask_directoryB
Mask all files in a directory using a swap session.
| Name | Required | Description | Default |
|---|---|---|---|
| directory_path | Yes | ||
| file_extensions | No | ||
| session_name_or_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description must disclose behavioral traits, but it does not. It does not mention whether masking modifies files in place, whether it is reversible, what happens to subdirectories, or whether any session state is consumed or changed.
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?
The description is one short sentence with no filler and front-loads the main action. It is concise, though it sacrifices useful detail for brevity.
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 tool with 3 parameters, 0% schema coverage, and no annotations, the description is far too thin. It omits the role of file_extensions, behavior on nested directories, session requirements, and side effects. The presence of an output schema does not compensate for these missing operational details.
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 0%, so the description must compensate for missing parameter meaning. It only indirectly references session_name_or_id and directory_path, and says nothing about file_extensions, which is a meaningful optional parameter with no schema documentation.
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 states a specific action ('Mask all files in a directory') and the mechanism ('using a swap session'). It clearly differentiates from siblings like phantomswap_mask_text and phantomswap_unmask_directory by specifying directory-level masking.
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?
The description implies when to use this tool: when masking all files in a directory rather than a single text value. However, it provides no explicit guidance about prerequisites such as needing an existing swap session, nor exclusions versus alternative tools like mask_text or unmask_directory.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phantomswap_mask_textC
Mask sensitive information in text by swapping real values with fake placeholders.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| session_name_or_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It explains that values are swapped with fake placeholders, but does not disclose whether the session stores the mapping, whether masking is reversible, what side effects occur, or what the output represents. This is minimal transparency for a stateful-looking operation.
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?
The description is a single concise sentence with no filler, which is positive. However, it is under-specified for a tool with two required parameters and a session-based workflow, so the conciseness is not fully 'appropriate' to the tool's needs.
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 definition lacks key context about sessions, session lifecycle, availability of an inverse operation, and any constraints around masking text. An output schema exists but cannot compensate for missing usage semantics. Overall, the description is too sparse for an agent to confidently select and invoke the tool correctly.
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 0%, and the description only implicitly explains 'text' while leaving 'session_name_or_id' completely unexplained. The agent cannot infer how to choose or specify a session, what the session is used for, or what format the identifiers take.
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 states a specific action ('Mask sensitive information in text') and a clear resource ('text'), with the method 'swapping real values with fake placeholders'. It implies differentiation from siblings like phantomswap_mask_directory by targeting text, but does not explicitly name alternatives or distinguish 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?
No guidance is provided on when to use this tool versus alternatives such as phantomswap_unmask_text, phantomswap_mask_directory, or session-related tools. The description does not mention prerequisites like having a session, which seems important given the required session_name_or_id parameter.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phantomswap_unmask_directoryC
Unmask all files in a directory using a swap session.
| Name | Required | Description | Default |
|---|---|---|---|
| directory_path | Yes | ||
| file_extensions | No | ||
| session_name_or_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It does not explain the effects of unmasking files, whether files are modified in place, whether a valid swap session is required or consumed, or what side effects may occur. 'Unmask' implies mutation, but the consequences and prerequisites are unstated.
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?
The description is a single, front-loaded sentence with no filler or redundant phrasing. It is efficient, though it sacrifices necessary detail for brevity.
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 has three parameters and no annotations, but the description only covers a generic action. It omits the optional file_extensions behavior, session requirements, and any operational context. The presence of an output schema reduces the need to explain return values, but the behavioral and prerequisite gaps remain significant.
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 0%, so the description must compensate by explaining parameters. It indirectly covers 'directory_path' and 'session_name_or_id' through the phrase 'directory using a swap session,' but it completely ignores 'file_extensions' and gives no format, behavior, or filtering details for any parameter.
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 clearly states the operation ('Unmask all files'), the target resource ('in a directory'), and the mechanism ('using a swap session'). This distinguishes it from siblings like phantomswap_unmask_text and phantomswap_mask_directory through verb and scope.
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 guidance is given on when to use this tool versus alternatives such as phantomswap_unmask_text or phantomswap_mask_directory. The wording implies directory-level unmasking, but it never states when this is the right choice or when another sibling should be used.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
phantomswap_unmask_textC
Unmask text by restoring fake placeholders back to original real values.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | ||
| session_name_or_id | Yes |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are present, so the description carries the full burden of behavioral disclosure. It explains the core transformation but omits any context about session dependence, side effects, permissions, or error behavior, which is significant for a tool requiring a session_name_or_id.
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?
The description is a single clear, front-loaded sentence with no filler or redundancy. While it is too terse to fully inform the agent, its structure efficiently communicates the primary action and resource.
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?
Despite having an output schema, the description lacks essential context about session usage, placeholder semantics, and its relationship to sibling mask tools. With two required parameters and no annotations, an agent cannot confidently determine prerequisites or expected behavior.
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 0%, and the description does not compensate. The 'text' parameter is only implied by the verb, and 'session_name_or_id' is completely unexplained, leaving the agent without a clear understanding of how the session relates to unmasking.
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 clearly states the verb 'Unmask' applied to the resource 'text', with the mechanism 'restoring fake placeholders back to original real values'. It distinguishes itself from siblings such as unmask_directory by the explicit 'text' resource and from mask_text by the inversion of the operation.
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 guidance about when to use this tool versus alternatives like mask_text or unmask_directory. No conditions, exclusions, or related-tool routing are provided, so the agent must infer usage from the tool name alone.
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.
7 tool updates
v1.0.0- First observed
phantomswap_create_session - First observed
phantomswap_get_session - First observed
phantomswap_list_sessions - First observed
phantomswap_mask_directory - First observed
phantomswap_mask_text - First observed
phantomswap_unmask_directory - First observed
phantomswap_unmask_text
TDQS
Scored across 7 tools
Each tool has a clearly distinct purpose: session management (list/get/create) versus masking operations (mask/unmask text or directory). There is no meaningful overlap between any two tools.
All tools follow the consistent phantomswap_<verb>_<target> pattern using snake_case. The session tools use list/get/create and the masking tools use mask/unmask, making the naming highly predictable.
Seven tools is well-scoped for a session-based masking utility on three session management tools and four mask/unmask operations. Every tool earns its place and there are no redundant additions.
The core workflow is covered: sessions can be created, listed, and retrieved, and masking/unmasking works for both text and directories. Missing session update/delete operations are minor administrative gaps that can be worked around by creating new sessions.
Maintenance
Related MCP Connectors
Redact PII from text before it reaches a model. Nothing stored, no third-party AI.
Gives your AI assistant persistent memory and intelligence about your work patterns.
Classify data safety before storing or sharing. GDPR, HIPAA, PCI-DSS, CCPA. AI-powered.
The WAF for agents. Pattern-based + heuristic firewall scans prompts, RAG documents, tool argume...
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables anonymization and deanonymization of sensitive data in text using Microsoft Presidio. Supports session-based storage to reversibly replace sensitive information like passwords and secrets with placeholder tokens.-
- AlicenseNot gradedqualityDmaintenanceLocal-first CLI and MCP server for redacting sensitive text before sharing logs, configs, and errors with AI tools.MIT
- AlicenseAqualityDmaintenanceScans prompts for PII and masks or redacts sensitive data locally before sending to an LLM, supporting multiple anonymization modes.1MIT
- AlicenseAqualityBmaintenanceSanitizes text and files by removing PII, secrets, and custom patterns locally before sending to LLMs, with optional reverse-scrubbing.3105 npm2MIT