Click on "Install 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., "@Stript MCP Bridge Anonymize the file on my desktop: ~/Desktop/report.docx"
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.
@stript/mcp is a local Model Context Protocol server that lets
Claude (Desktop and Code) anonymize documents through the Stript desktop app on your own
machine — so personal data never enters the conversation.
Requires the Stript desktop app with AI integrations enabled in Settings. The bridge does nothing on its own; it is a thin, local client to the app.
Claude hands the bridge a local reference — a file path, the clipboard, or an existing Stript
document id. The bridge asks the local Stript app to detect personal data and replace it with
consistent placeholders like [PERSON_1]. Only the anonymized text is returned to the conversation.
Restored (real-PII) output is written to your clipboard or a local file and is never returned to
the model.
Related MCP server: ai-security-gateway-mcp
Claude Desktop — install the signed Stript.mcpb from the Stript app
(Settings → Install for Claude Desktop), or from https://downloads.stript.io/Stript.mcpb.
Claude Code:
claude mcp add stript -- npx -y @stript/mcpTool | Purpose | Nature |
Check the Stript app status | Confirm the app is running and reachable | read-only |
Anonymize a document with Stript | Detect + replace PII in a file on disk | writes anonymized output |
Anonymize the clipboard text with Stript | Same, for the current clipboard (opt-in; Claude asks first) | writes anonymized output |
Fetch a Stript anonymization result | Retrieve a completed result | read-only |
Restore original values into placeholder text | Put the real values back (to clipboard or a local file) | writes locally, never to chat |
Restore original values into a file | Restore a full file on disk | writes locally, never to chat |
The bridge talks only to 127.0.0.1: the Stript app's local backend and a loopback broker
inside the signed app. It makes no external network calls with your content.
A per-launch, scope-restricted token gates every call; ports and token rotate on each launch.
Restored real values never enter tool results — they are written to your clipboard or a local file only.
New documents meter through the same local path as the app; the bridge keeps only a small local usage-metering mirror and nothing else persistent.
Stript is local-first. From the Stript Privacy Policy:
"Your documents are processed exclusively on your own device."
"No document content, file name, path, document identifier, source commitment, mapping, detection result, entity information, or export activity is transmitted to us or any third party."
This bridge inherits that guarantee:
Collects and transmits no document content. All detection and anonymization run locally in the Stript app; the bridge only shuttles data between Claude and the local app over loopback.
Stores nothing beyond a local usage-metering mirror on your own machine.
Shares nothing with third parties — it makes no off-device network calls.
The broader Stript product's data handling — optional account email, payment processing via Lemon Squeezy, hosting and privacy-preserving analytics via Cloudflare, transactional email via Resend, and the associated retention periods and contact details — is described in full in the Privacy Policy. Direct privacy questions to the contact listed there.
npm ci
npm run build # bundles dist/index.js (esm, node20)
npm test # vitest
npm run check # tsc --strict (bridge + card UI)MIT. The Stript desktop app this bridge connects to is a separate, proprietary product.
Use this when the user wants to work with a document that may contain personal data, for example summarize it, translate it, or draft a reply. Ask the user for the file path. Never ask the user to paste document content into the chat. Stript detects and replaces personal data locally and only the anonymized text enters the conversation. Placeholders like [PERSON_1] can be restored later with stript_restore. Set mode to review when the user wants to check the detections in the Stript app first, Stript then opens the document and you wait for the user. Processing a new document uses one of the 5 Free Evaluation documents, already processed documents are free.
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | auto anonymizes headlessly, review opens the Stript app for the user first | auto |
| path | Yes | Absolute or ~ path of the document to anonymize | |
| project | No | Stript project id, defaults to the configured project |
| Name | Required | Description |
|---|---|---|
| next | No | |
| types | No | |
| status | Yes | |
| warnings | No | |
| evaluation | No | |
| project_id | No | |
| document_id | No | |
| output_file | No | |
| replacements | No | |
| residual_risk | No | |
| anonymized_text | No | |
| degraded_reasons | No | |
| detections_total | No | |
| reduced_accuracy | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description adds substantial behavioral context beyond the sparse annotations: it explains local detection and replacement of personal data, that only anonymized text enters the conversation, the review mode interaction (opens app and waits), and the quota behavior. It does not explicitly state whether the original file is modified, but the destructiveHint annotation is false, so no contradiction exists.
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 longer than the ideal but every sentence contributes unique information (trigger, user instruction, constraint, behavior, restore hint, mode guidance, quota). It is front-loaded with the 'Use this when' guidance and well-structured, earning a high score despite its length.
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 moderate complexity (modes, quota, restore, local processing). The description covers the main aspects including when to use, the review flow, quota limits, and the restore path. It does not detail the output format, but an output schema exists, so that is not required. It is sufficiently complete for effective tool selection and invocation.
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%, so parameters are already documented. The description adds minor context about mode (review opens the app) but this is also in the schema description. It does not significantly enhance understanding of path or project parameters, so a baseline score of 3 is appropriate.
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 tool anonymizes a document with Stript, specifying the trigger condition ('when the user wants to work with a document that may contain personal data') and giving concrete examples (summarize, translate, draft a reply). It distinguishes from siblings by mentioning stript_restore for restoring placeholders and describing the review mode.
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 explicitly says 'Use this when...' and provides examples, states to ask for the file path, and gives a strong directive ('Never ask the user to paste document content'). It also clarifies when to use review mode and mentions the free evaluation document quota, giving clear context for appropriate usage.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use this to fetch the anonymized result of a Stript document, for example after a pending_review status or after the app was restarted mid-review. If the document is still in review, this call WAITS for the user to finish the review in Stript and returns the result as soon as they click Anonymize. When it returns pending_review instead, call it again immediately to keep waiting, and repeat while the result says pending_review and the user has not cancelled. The document_id is optional, without it the most recent document in the project is fetched, so a plain "fetch my Stript result" works. Returns only anonymized content, never the original document text. Reading a stored result is free, it never consumes an evaluation document.
| Name | Required | Description | Default |
|---|---|---|---|
| document_id | No | The Stript document id to fetch. Omit for the most recent document. |
| Name | Required | Description |
|---|---|---|
| next | No | |
| types | No | |
| status | Yes | |
| warnings | No | |
| evaluation | No | |
| project_id | No | |
| document_id | No | |
| output_file | No | |
| replacements | No | |
| residual_risk | No | |
| anonymized_text | No | |
| degraded_reasons | No | |
| detections_total | No | |
| reduced_accuracy | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses important blocking behavior ('this call WAITS for the user to finish the review'), the pending_review return/retry pattern, and resource implications ('Reading a stored result is free, it never consumes an evaluation document'). It also states that only anonymized content is returned, never original text. These go well beyond the readOnlyHint/destructiveHint annotations.
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?
Though the description is longer than typical, every sentence adds a distinct piece of information: trigger conditions, blocking behavior, retry instructions, optional parameter semantics, output guarantee, and cost implication. It is front-loaded with the core action and remains tightly structured.
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 the tool's wait-and-retry behavior and optional parameter, the description covers the full invocation loop, the output constraint, and the resource impact. Combined with the output schema, this is sufficiently complete for an agent to use the tool correctly without additional context.
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 schema already fully describes document_id as optional and says 'Omit for the most recent document.' The description repeats the same information in natural language ('without it the most recent document in the project is fetched') and adds a friendly paraphrase, but no new semantic meaning beyond the schema. With 100% schema coverage, the baseline of 3 is appropriate.
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 opens with the specific verb+resource: 'fetch the anonymized result of a Stript document,' clearly distinguishing it from siblings like stript_anonymize_file (anonymize) and stript_restore (restore). It adds context about pending_review and app restarts, making the purpose precise.
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?
It explicitly states when to use: 'after a pending_review status or after the app was restarted mid-review,' and gives a concrete retry loop: 'call it again immediately to keep waiting, and repeat while the result says pending_review.' It also explains the optional parameter use case, so an agent knows a bare call works.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use this when an AI answer that contains Stript placeholders like [PERSON_1] or [EMAIL_2] should get the original values back. The restored text never appears in the chat. It is written to the user clipboard by default or to a local file, always tell the user where it went. This tool returns replacement counts only. Restoring is free, it never consumes an evaluation document.
| Name | Required | Description | Default |
|---|---|---|---|
| text | Yes | The text containing Stript placeholders to restore | |
| project | No | Stript project id the placeholders belong to | |
| filename | No | Output file name when destination is file | |
| destination | No | Where the restored text is written, never into the chat | clipboard |
| Name | Required | Description |
|---|---|---|
| path | No | |
| destination | Yes | |
| exact_restore | Yes | |
| ambiguous_skipped | Yes | |
| replacements_made | Yes | |
| unmatched_placeholders | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description richly discloses behaviors beyond annotations: it writes to clipboard or file, never appears in chat, returns replacement counts only, and is free (never consumes an evaluation document). This adds significant context that annotations alone (readOnlyHint: false, destructiveHint: false) do not convey, and it does not contradict any annotations.
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 four concise sentences, each adding critical information: when to use, output destination, return type, and cost. It is front-loaded with the primary use case and contains no filler or repetition. Every sentence earns its place.
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 the tool's moderate complexity (4 params, output schema, sibling tools), the description covers the purpose, usage scenario, output behavior, destination, and cost. It even includes a user instruction ('always tell the user where it went'). The output schema exists, so the description need not explain return values, but it still does. This is complete for an agent to use effectively.
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 the schema already documents all parameters clearly. The description adds only a few contextual hints (e.g., examples of placeholders) but does not explain parameters in greater depth or add meaning beyond the schema. Baseline 3 is appropriate.
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 ('restore original values into placeholder text') with a clear target (an AI answer containing Stript placeholders like [PERSON_1] or [EMAIL_2]). It distinguishes this tool from siblings by focusing on inline text and noting that restored text never appears in chat, which is unique among the listed tools.
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 opens with 'Use this when...' and gives a concrete scenario, establishing when to use it. It also provides guidance on always telling the user where the output went. However, it does not explicitly mention alternatives like stript_restore_file or when not to use this tool, so it lacks explicit exclusions.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use this to restore original values into a file that contains Stript placeholders like [PERSON_1], keeping the file format where possible. Ask the user for the file path, do not ask them to paste file content into the chat. The restored file is written to the Stript output folder and its content never appears in the chat. This tool returns replacement counts and the output path only. Restoring is free, it never consumes an evaluation document.
| Name | Required | Description | Default |
|---|---|---|---|
| path | Yes | Path of the placeholder-bearing file to restore | |
| project | No | Stript project id the placeholders belong to | |
| output_filename | No | Name for the restored file, defaults to a name derived from the input |
| Name | Required | Description |
|---|---|---|
| path | Yes | |
| format | Yes | |
| warnings | Yes | |
| exact_restore | Yes | |
| ambiguous_skipped | Yes | |
| replacements_made | Yes | |
| unmatched_placeholders | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
The description discloses key behavioral details beyond annotations: 'The restored file is written to the Stript output folder and its content never appears in the chat', 'returns replacement counts and the output path only', and 'Restoring is free'. These specifics about output location, output format, and cost are valuable context not provided by the annotations.
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 four sentences, each earning its place: purpose, usage instruction, output behavior, and cost. It is front-loaded and concise, with no redundant or verbose language.
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 three parameters, an output schema, and annotations, the description fully covers the necessary context: what it does, how to use it (ask for path), what it returns (counts and path), where output goes, and that it is free. No significant gaps are apparent.
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 schema already describes all three parameters with 100% coverage, so the baseline is 3. The description adds minimal parameter-specific meaning, only reinforcing that the path is a file path. It does not elaborate on the 'project' or 'output_filename' parameters beyond what the schema provides.
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 tool's purpose: 'restore original values into a file that contains Stript placeholders'. It specifies the resource (file) and the action (restoring), and differentiates from siblings by focusing on file restoration, with the name stript_restore_file and description 'into a file' distinguishing it from stript_restore.
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 gives practical usage guidance: 'Ask the user for the file path, do not ask them to paste file content into the chat' and notes 'Restoring is free, it never consumes an evaluation document.' It does not explicitly mention when to use this instead of stript_restore or other siblings, but the context is clear enough for this file-specific tool.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use this to check whether the Stript desktop app is running with AI integrations enabled, which license tier is active, and how many Free Evaluation documents remain. Call it before anonymizing when the state is unclear. It consumes no evaluation document and changes nothing.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| tier | No | |
| guidance | No | |
| app_running | Yes | |
| app_version | No | |
| models_ready | No | |
| backend_version | No | |
| integration_enabled | Yes | |
| evaluation_remaining | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations already declare readOnlyHint=true and destructiveHint=false; the description adds that it 'consumes no evaluation document and changes nothing,' providing domain-specific reassurance and clarifying side effects beyond the annotations.
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 exactly two sentences: the first enumerates the specific checks performed, the second gives usage guidance and side-effect confirmation. Every sentence carries meaningful content with no redundancy.
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 zero parameters, the description fully covers the tool's purpose, when to use it, and its side-effect-free nature. An output schema exists, so return value details are already structured and do not need to be repeated in the description.
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 has zero parameters, so schema coverage is effectively 100%. The description adds no parameter details, but none are needed; the baseline score of 4 applies as there is nothing to clarify.
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 tool checks whether the Stript desktop app is running with AI integrations enabled, which license tier is active, and how many Free Evaluation documents remain. This specific enumeration of checks distinguishes it from sibling tools like stript_anonymize_file or stript_restore.
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 explicitly instructs to call it 'before anonymizing when the state is unclear,' providing a clear use case. It doesn't enumerate alternatives or exclusion cases, but the guidance is sufficient for a read-only status check.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v1.0.7stript_anonymize_filestript_fetch_resultstript_restorestript_restore_filestript_statusThe tools are largely distinct: anonymize_file initiates new processing, fetch_result retrieves existing results, restore and restore_file handle inverse operations for text and files, and status checks the app state. Some minor overlap exists between anonymize_file and fetch_result (both return anonymized content) and between the two restore tools, but the descriptions provide sufficient differentiation.
All tools share the 'stript_' prefix and use snake_case, but the pattern is inconsistent: most are verb_noun (stript_anonymize_file, stript_fetch_result, stript_restore_file), while stript_restore lacks an object and stript_status is a noun rather than a verb. This makes the naming somewhat predictable but not uniform.
With 5 tools, the server is well-scoped for its purpose: anonymize, fetch result, restore (both text and file), and check status. This is within the ideal 3-15 range and each tool serves a necessary step in the Stript workflow without unnecessary bloat.
The tool set covers the full lifecycle: anonymizing files, fetching results (including waiting for review), restoring placeholders in AI responses or files, and checking system status. There are no obvious dead ends or missing operations for the stated purpose of bridging Stript anonymization into MCP.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
Stateless PII redaction over MCP/REST. Free ≤1000 words or $0.01/call; file upload supported.
Check a document for hidden text before your agent reads it. PDF, Office, RTF, HTML.
Detects and redacts PII (emails, phones, SSNs, names, addresses) from text. $0.02/call via x402.
Convert and compress PDFs and images, redact personal data, and run text and data utilities.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/GlaserIngo/stript-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
