MCP Security Sanitizer

io.github.saurabhdrhPublished by GitHub account saurabhdrhv1.0.0Updated Oct 27, 2026

Redacts common secrets, email addresses, and phone numbers.

VerifiedSSEWeb executableDeveloper ToolsSecurity & Monitoring

Overview

AI-generated overview

Regex-based sanitizer that lets an assistant redact API keys, tokens, emails and phone numbers from text, and count detected risks.

What you can do
  • Redact secrets: mask OpenAI-style keys, bearer tokens and named key/password/token assignments as a redaction placeholder.
  • Redact PII: mask email addresses and common North American phone numbers.
  • Audit text: return counts of recognized secrets, emails and phone numbers without changing the text.
When to use it
Useful when you want a quick, token-free pre-check or scrub of pasted text before it goes to a model or into a note. Suited to demos and local development rather than compliance-grade redaction.
Requirements
The manifest lists a remote SSE endpoint with no authentication or headers declared. The README's own setup runs the server locally with Python 3.11+ and uv, and its sample client needs a Groq API key in a .env file plus an optional model setting.
Before you install
Regex matching only catches the patterns implemented, so it cannot guarantee detection of every secret or PII value; the README warns against sending regulated or highly sensitive data without extra controls and testing. The README also notes the SSE transport is a network boundary and recommends authentication, TLS and network restrictions for production. The sample client sends sanitized text to Groq, a third party.

Installation

In SourceWeft

  1. Open MCP Security Sanitizer in the dashboard and add it to a workspace.
  2. Enable the server for the chats that should use its tools.

Web executable via SSE. Remote servers run from the web runtime once configured in a workspace.

Use with an agent

Paste this prompt into Claude Code, Codex, Cursor or another agent — or into SourceWeft chat. The agent reads this server's install guide, shows you its publisher, endpoint and sign-in, and adds it to your client once you agree. Keys never go into a command.

Read https://sourceweft.com/mcp/io.github.saurabhdrh%2Fmcp-security-sanitizer/install.md and connect the MCP server it describes to my client. Before changing any config, show me its publisher, endpoint and sign-in method and wait for my OK. Never put an API key in a command or in a file I would commit; ask me where it should come from.

Read the install guide the agent follows

Other MCP clients

Add this to your client's mcpServers config.

{
  "mcpServers": {
    "security-sanitizer": {
      "type": "sse",
      "url": "https://mcp-security-sanitizer-server.onrender.com/sse"
    }
  }
}

README

MCP Security Sanitizer

A small MCP server and interactive LangChain/Groq chatbot. The server exposes local regex-based tools for redacting common secrets and personally identifiable information (PII), and the client sanitizes each message before sending it to the language model.

Important limitation: Regex matching only recognizes the patterns implemented here. It cannot guarantee detection of every secret or PII value. The client guarantees that both configured sanitizer tools are called before each non-empty user message is passed to Groq; the system prompt is defense-in-depth, not the enforcement mechanism. Do not send regulated or highly sensitive data without adding appropriate controls and validating detection coverage for your environment.

Architecture

text
User input   |   vPython client --MCP/SSE--> local regex scrubbers   |                         1. mask_api_keys_and_secrets   |                         2. mask_pii_data   vSanitized text --> LangChain agent --> Groq

Sanitization uses local Python regular expressions in the MCP server and consumes 0 LLM tokens. The client makes the sanitizer calls synchronously before invoking the agent, so raw input is not sent to Groq by this chat flow. An MCP transport is still a network boundary; this configuration binds the server to loopback (127.0.0.1) and is intended for local development.

The logging interceptor prints tool names and argument field names but withholds all argument and result contents, so it does not log unsanitized input or potentially sensitive sanitizer output.

Tools

ToolBehavior
mask_api_keys_and_secrets(text)Redacts OpenAI-style sk-... keys, Bearer tokens, and common named key/secret/password/token assignments as [REDACTED_SECRET].
mask_pii_data(text)Redacts email addresses as [REDACTED_EMAIL] and common North American phone formats as [REDACTED_PHONE].
audit_text_for_risks(text)Returns counts of recognized secrets, email addresses, and phone numbers.

Requirements

  • Python 3.11+
  • uv
  • A Groq API key

Setup

From the project directory, resolve dependencies, create the project-local .venv, and write or update uv.lock:

bash
uv sync

You do not need to activate .venv when using uv run; it selects the project environment automatically.

Create a .env file in the project directory (beside pyproject.toml):

dotenv
GROQ_API_KEY=your_groq_api_keyGROQ_MODEL=openai/gpt-oss-120b

Keep .env out of version control. The client loads this file at startup and checks that GROQ_API_KEY is set before connecting to Groq. A .env placed inside .venv is also recognized as a fallback, but the project directory is the recommended location because .venv is generated and can be deleted and recreated. GROQ_MODEL is optional; if omitted, the client uses openai/gpt-oss-120b. If Groq reports that a model is unavailable, set GROQ_MODEL to a model ID enabled for your account. The API key is used by ChatGroq; it is not sent to the MCP server.

Run

Start the MCP server in one terminal:

bash
uv run server.py

It listens on http://127.0.0.1:8000 using the SSE transport, with the MCP endpoint at /sse.

Server startup screenshot

The image below illustrates the expected server terminal after startup. It is a generated example rather than a direct screenshot from your machine; process IDs and log formatting can differ by FastMCP/Uvicorn version.

[Illustrative MCP server startup terminal]

In a second terminal, start the interactive chatbot:

bash
uv run client.py

Alternatively, activate the project environment in each terminal and run Python directly. For example, in Windows PowerShell:

bash
.\.venv\Scripts\Activate.ps1python server.py

In a second activated terminal:

bash
.\.venv\Scripts\Activate.ps1python client.py

Type exit or quit to end the chat.

Sample prompts to try

With both the server and client running, paste one of these prompts into the client. Every value below is synthetic test data; do not use real credentials or personal information for testing.

Email and phone

text
Write a friendly appointment reminder for [email protected] and ask them tocall (415) 555-0134 if they need to reschedule.

The text passed to the agent should replace those values with:

text
[email protected]  -> [REDACTED_EMAIL](415) 555-0134    -> [REDACTED_PHONE]

API key and named password

text
Explain why this demo credential should not be shared: sk-1234567890abcdef.The test password is password=hunter2.

Both credential values should be replaced with [REDACTED_SECRET] before the message is sent to Groq.

Bearer token and mixed data

text
Help me write a support note for [email protected]. The test phone is212-555-0199 and the example authorization header is Bearerabc123.def456.ghi789.

The email, phone number, and Bearer token should be masked by the applicable tool. The interactive client intentionally does not print sanitized text to the terminal; it logs which tools ran while withholding their arguments and results. The expected replacements above describe what is passed onward, not what is displayed in the console.

What you see in the terminals

Run the server and client in separate terminals. The server stays running while the client connects to it.

Terminal 1 — MCP server (timestamps and process IDs vary):

text
INFO Starting MCP server 'MCP Security Sanitizer' with transport 'sse'     on http://127.0.0.1:8000/sseINFO:     Started server process [process-id]INFO:     Waiting for application startup.INFO:     Application startup complete.

Terminal 2 — client (example sanitizer call; the fake values below are for testing only):

text
Secure assistant ready. Type 'exit' or 'quit' to stop.
You: Contact [email protected] at (415) 555-0134; test key sk-1234567890abcdef.
[MCP] Calling mask_api_keys_and_secrets (arguments: text)[MCP] mask_api_keys_and_secrets completed; result content withheld.
[MCP] Calling mask_pii_data (arguments: text)[MCP] mask_pii_data completed; result content withheld.
Assistant: [The assistant's reply appears here after the sanitized message is            sent to the configured Groq model.]

The interceptor intentionally withholds tool arguments and results from the terminal, so the unsanitized input is not printed by the MCP logs. The message passed to the agent has these substitutions:

text
Contact [REDACTED_EMAIL] at [REDACTED_PHONE]; test key [REDACTED_SECRET].

The assistant reply depends on the Groq model and is not a fixed output. The illustration below shows the server startup and the local sanitizer calls. It is an example terminal view, not a raw desktop screenshot; the sanitizer check does not make a Groq request. Startup timestamps and process IDs vary by run.

[Illustrative MCP server and sanitizer client terminal output]

Configuration and production considerations

  • The client requires both sanitizer tools. If either is unavailable or returns an unsupported result, the request fails instead of being sent unsanitized.
  • The server uses SSE as requested. For production deployments, configure authentication, TLS, network restrictions, monitoring, and lifecycle management appropriate to your environment.
  • Update the regexes and add tests against your organization's actual secret and PII formats before relying on the service for compliance.
  • uv run manages and uses the project environment without requiring manual activation. To run python server.py or python client.py directly, first activate .venv in that terminal.

Source: README.md at commit 1710258

Tools

3

mask_api_keys_and_secrets

Redact OpenAI-style API keys, bearer tokens, and common named secrets.

Parameterstextrequired

mask_pii_data

Redact email addresses and common North American phone numbers.

Parameterstextrequired

audit_text_for_risks

Count recognizable secrets, email addresses, and phone numbers.

Parameterstextrequired

Version history

1
  1. v1.0.0LatestOct 23, 2026

Score

90% of the applicable checks met

How complete this listing is, computed from the registry entry, the endpoint and public sources. Not a rating of the server and not a statement that it is safe or working today: reachability is a dated check, and no installs or reviews go into the score.

  • Reached in the last 30 daysRequired25 pts
  • Auth declaredRequired10 pts
  • Tools listedRequired15 pts
  • DescriptionRequired15 pts
  • Logo10 pts
  • Documentation15 pts
  • License10 pts

    Declare a license in the repository or the registry entry.