Étincel MCP Server
The Étincel MCP Server helps shape AI-assisted non-fiction prose into more human-sounding text by managing writing styles, auditing for AI tells, and maintaining custom rules. Key capabilities:
Style Management: List, create, train, fork, update, delete, and set default styles (presets, trained voices, or team styles). Train a voice from writing samples (rhythm, contractions, em-dash habits, etc.) or build one manually via 11 explicit dials.
Voice & Rhythm Checking: Compare a draft’s rhythm to a trained voice baseline and detect self-repetition patterns across the author’s past work.
Text Auditing: Deterministically scan for AI-writing tells (banned words, structural patterns) with severity tiers and strengths signal, optionally per register.
Custom Vocabulary: Add or remove banned and allowed words globally or per style; view effective merged lists.
Custom Drafting Instructions: Set, clear, and retrieve free-text drafting rules scoped globally or per style.
Integration: Operates as an MCP server for Claude Code/Desktop, with a CLI and CI/CD integrations.
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., "@Étincel MCP Server Audit my draft for AI tells and show me the findings."
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.
Étincel: Non-Fiction Writing Connector
___ ___ ___ ___ ___ ___
/\ \ /\ \ ___ /\__\ /\ \ /\ \ /\__\
/::\ \ \:\ \ /\ \ /::| | /::\ \ /::\ \ /:/ /
/:/\:\ \ \:\ \ \:\ \ /:|:| | /:/\:\ \ /:/\:\ \ /:/ /
/::\~\:\ \ /::\ \ /::\__\ /:/|:| |__ /:/ \:\ \ /::\~\:\ \ /:/ /
/:/\:\ \:\__\ /:/\:\__\ __/:/\/__/ /:/ |:| /\__\ /:/__/ \:\__\ /:/\:\ \:\__\ /:/__/
\:\~\:\ \/__/ /:/ \/__/ /\/:/ / \/__|:|/:/ / \:\ \ \/__/ \:\~\:\ \/__/ \:\ \
\:\ \:\__\ /:/ / \::/__/ |:/:/ / \:\ \ \:\ \:\__\ \:\ \
\:\ \/__/ \/__/ \:\__\ |::/ / \:\ \ \:\ \/__/ \:\ \
\:\__\ \/__/ /:/ / \:\__\ \:\__\ \:\__\
\/__/ \/__/ \/__/ \/__/ \/__/Find the AI tells in your prose. Deterministically, locally, in CI.
npx etincel lint README.mdNo install, no account, no model call, no network.
$ npx etincel lint drafts/announcement.md --register blog
✗ drafts/announcement.md RED 100/100 (8 findings, 169 words, register: blog)
Heavy AI styling. Multiple strong tells stacking up, worth a structural
rewrite, not a word-swap pass.
Whole-piece rhythm
medium uniform-paragraph-length
6 paragraphs, most running about the same length with little
variation between them. Vary paragraph length more.
medium low-burstiness
13 sentences averaging 13 words, with little variation in length
from one sentence to the next. Mix short sentences with long;
allow fragments.
medium mechanical-register-drift
Fragment rate and structural variety (sentence openers,
punctuation mix) sit off where blog prose typically lands. Allow
more sentence fragments and vary openers/punctuation more.
Vocabulary and phrasing
high comprehensive L3:C30 → thorough, complete
high cutting-edge L3:C109 → newest, latest
high leverage L3:C99 → use
high seamless L3:C150 → smooth, easy
high streamline L3:C70 → simplify, speed up
strengths specificity 11.4/1k · concrete:abstract 0.40 · burstiness 0.32
1 file audited, 1 at or above orange.Étincel is two things. A deterministic audit that finds the patterns making prose read as machine-written, as a CLI, a GitHub Action, and an MCP tool. And a voice layer that trains Claude, Cursor, or any MCP client to draft in a style measured from your own writing, so the problem is smaller before you ever read the draft.
AI-drafted prose has a recognizable shape: uniform paragraphs, hedged authority, em dashes where a comma would do, closings that resolve too neatly. Étincel encodes the rules against that shape and, just as important, shows you what it found and why instead of quietly overwriting your voice. There is no model call anywhere in the audit path, and you decide what changes. You stay the author.
Does it work?
We measure it rather than assert it. Pooled AUC per register, measured by assay against labeled corpora with a fixed bootstrap seed, so any PR that drops these numbers fails CI:
Register | AUC |
memo | 0.909 |
essay | 0.900 |
blog | 0.820 |
general | 0.748 |
docs | 0.735 |
0.540 |
Email is close to a coin flip. It's deliberately uncalibrated, and we track it anyway so an accidental regression doesn't go unnoticed. general is uncalibrated too. The calibrated registers are docs, blog, memo, and essay; use those if the number matters to you. See efficacy-baselines.json and src/data/SOURCES.md for method and provenance.
Related MCP server: Writing Assistant Ai MCP
How this compares
vs. Vale + vale-ai-tells Vale is an excellent markup-aware linter and vale-ai-tells is a serious 78-rule package. They match tokens against patterns. Étincel measures shape: sentence-rhythm variance, paragraph-length uniformity, and repetition against your own previous drafts, the kind of statistical layer vale-ai-tells' own README says needs analysis beyond what token matching can do. Étincel also feeds a trained voice to the model before you draft, which no linter does. Running both is reasonable; they overlap less than you'd expect.
vs. skill files (stop-slop, avoid-ai-writing, no-slop) Those are instructions to a model, and they help. But a prompt can't verify it worked, can't produce an exit code, and can't gate a merge. Use one and run this in CI.
vs. humanizers (Undetectable.ai, QuillBot, StealthWriter) Those rewrite your text to evade detectors. Turnitin now has a dedicated AI-paraphrasing detection feature, expanded in 2025 to target humanizer output specifically. Étincel does the opposite job: it never modifies your text, and it would be a poor tool for fooling anyone.
vs. detectors (GPTZero, Pangram, Originality.ai, Copyleaks) Those answer "was a machine involved?" with a probability, over a whole document, as a verdict on authorship, in the cloud. Étincel answers "which specific patterns make this read as machine-written?" with locations and severities, locally, and never renders a verdict on who wrote something.
Install
Also listed on the official MCP registry as ai.etincel/etincel-nonfiction, so MCP-aware clients that auto-discover servers from there (VS Code's @mcp gallery, for one) find it without any of the config below.
Claude Code
/plugin marketplace add AIStoryHub/etincel
/plugin install etincel-nonfictionOr from a local clone: /plugin marketplace add /path/to/etincel.
Claude Desktop / other MCP hosts
{
"mcpServers": {
"etincel-nonfiction": {
"command": "npx",
"args": ["etincel", "serve"]
}
}
}From a local clone instead: npm install && npm run build, then point args at ["/path/to/etincel/dist/server.js"] with "command": "node".
Remote (hosted, multi-tenant)
A hosted version is also available at etincel.ai, exposing
the same tools over Streamable HTTP (https://etincel.ai/api/mcp) with
per-account auth instead of stdio. Point any MCP client at it directly:
{
"mcpServers": {
"etincel-nonfiction": {
"url": "https://etincel.ai/api/mcp"
}
}
}The hosted server isn't part of this repo; this repo is the local/stdio engine, CLI, and skill that the hosted version is built on top of.
Using it
Once installed, just ask for what you'd normally ask for, like "draft an email to the team about the delay," "write a blog post about X," or "clean up this memo," inside Claude Code or Claude Desktop. The skill picks up automatically for non-fiction prose of meaningful length. To train your own voice:
Train a style called "me" from these three emails I wrote: [paste samples]
Then either name it per-request ("write this in my voice") or set it as default:
Set my default style to "me"
Style presets
Twelve premade presets ship out of the box: six emotional tones (Direct & Warm, Executive Brief, Reflective Essayist, Founder Memo, Plainspoken Analyst, Wry & Candid) plus six use-case presets (PR Review, Code Comment, Slack Message, LinkedIn Post, Website Copy, Blog Post). Each carries formality/warmth/directness dials plus a sentence-rhythm and voice description that gets fed to the model as drafting context, not a template that fills in blanks. The server reads these from src/data/presets.json. Fork any preset into a trained voice with fork_style to make it your own.
Command-line lint
audit_text is a pure function under the hood, so it also ships as a CLI, for linting prose outside a chat client (READMEs, docs, PR descriptions in CI):
npx etincel lint 'docs/**/*.md'
npx etincel lint README.md --register docs --threshold yellowExits non-zero if any matched file's tier is at or above --threshold (default orange). .md/.mdx files default to the docs register automatically (suppresses the Markdown-structure false positives, since a real heading isn't a chatbot tell); pass --register to override. Add --json for a machine-readable report. Run npx etincel lint --help for the full option list.
A GitHub Action wraps the same CLI (see action.yml, and .github/workflows/lint.yml in this repo for a working example):
- uses: AIStoryHub/etincel@main
with:
patterns: "docs/**/*.md README.md"
threshold: orangeRepo-local config: dictionary, instructions, and a shared team style
A team's rules don't have to live only in each person's local ~/.etincel/. Drop a .etincelrc (or .etincelrc.json / etincel.config.json) at the repo root and it's picked up automatically by the CLI and by the local (stdio) server, reviewable in code review and versioned instead of invisible and gone when someone leaves:
{
"bannedWords": ["Acme Cloud Platform"],
"allowedWords": ["leverage"],
"register": "docs",
"threshold": "orange",
"instructions": "Always include a one-line CTA at the end.",
"style": {
"name": "House Voice",
"dials": {
"formality": 6,
"warmth": 4,
"directness": 7,
"sentenceLength": 40,
"sentenceRhythmVariance": 50,
"paragraphVariance": 30,
"contractionUse": 20,
"emDashUse": 0,
"fragmentTolerance": 10,
"questionUse": 5,
"entropy": 60
}
}
}bannedWords/allowedWordsmerge alongside whatever's in your account/style dictionary;register/thresholdact as repo-wide defaults that an explicit--register/--thresholdflag still overrides.instructionsis free text, folded intoget_style_guide'sinstructionsfor every style, not just the team one, ahead of your own account-level global instructions: the team-wide equivalent ofset_style_instructionswith nostyleId, but committed to the repo instead of living in one person's account.styledefines a shared "house voice" from dials, addressable everywhere asstyleId: "team"(get_style_guide, and once forked into a real trained voice withfork_style, everywhere else too) so a team has one already-tuned starting voice from day one instead of everyone hand-training or hand-tuning their own from scratch.list_stylesincludes it automatically when a.etincelrcin the current repo defines one.
The hosted server doesn't use any of this (it has no local repo to look in).
Sharing config across a team without committing it
.etincelrc is the versioned, code-reviewable layer above; the layer beneath it is ETINCEL_HOME, an environment variable that points the local (stdio) server and CLI at a directory to use instead of the default ~/.etincel/. Point every teammate's ETINCEL_HOME at the same shared, synced, or mounted directory (a repo-external path everyone's machine can read, e.g. something synced by your usual file-sharing setup) and trained voices, the default style, and account-level instructions/dictionaries are shared too, not just the .etincelrc-committed subset:
{
"mcpServers": {
"etincel-nonfiction": {
"command": "node",
"args": ["/path/to/etincel/dist/server.js"],
"env": { "ETINCEL_HOME": "/path/to/shared/etincel-home" }
}
}
}Nothing else to export or import: pointing ETINCEL_HOME at the same directory is the sync, the same way it already is for a single person's ~/.etincel/.
What's in here
An MCP server (
src/server.ts) exposing twenty tools:list_styles: premade tone presets, any voices you've trained, and (if a repo-local.etincelrcdefines one) a shared team styleget_style_guide: the drafting instructions for one styletrain_style: learn a voice from your own writing samples (sentence rhythm, contraction rate, em-dash habits, paragraph variance, recurring phrasing: measured, not guessed)create_style_from_dials: build a style from explicit formality/warmth/directness and mechanical dials instead of samplesupdate_style: rename a trained voice or adjust its dials in placefork_style: copy a preset's dials and guide into a new trained voice you can retrain or hand-tune, or fork another installer's style once they've published it publicly on the hosted gallery (addressed ashandle/slug, e.g.jpleblanc/blunt-memo, the same address shown on its public page atetincel.ai/v/handle/slug); a public-style fork also carries over its mechanical dials and any dictionary/instructions the source installer set specifically for that style (never their private, account-wide ones), and makes one network call toetincel.aito fetch it, while a preset fork never leaves this installdelete_style: permanently remove a trained voiceset_default_style: remember which style to use without repeating yourselfcheck_voice_match: compare a draft's measured rhythm against a trained voice's baseline. A rhythm/mechanics check, not an authorship or AI-detection check, and low-confidence on short inputcheck_self_repetition: compare a draft against a voice's own recent training samples for habits, not AI tells: the same opener, or a phrase, recurring across several past pieces ("you've opened this way in 4 of your last 6 pieces"). Local install only for nowaudit_text: a deterministic, rules-based scan for AI tells, returning a tier, specific findings with severity, and a strengths signal (specificity, concrete-vs-abstract ratio, sentence-rhythm variation) so fixes don't flatten the prose. Takes an optionalregister(email/blog/memo/essay/social/docs/general/personal, defaultgeneral) to calibrate strictness against the kind of text it is:docssuppresses Markdown-structure false positives (headings, bolded terms) and recalibrates rhythm/vocabulary detection against long-form reference prose instead of punchier short-form copy.personalis scaffolded (accepted, suppresses nothing extra yet) but not yet calibrated: no term suppressions, rhythm weight, or labeled corpus of its own until one is measured. Also takes an optionalsourceFacts(details elicited from the user, never generated): checks how many actually made it into the draft, flaggingelicited-material-unusedbelow a quota of two used and at least one in a sentence that isn't proving a qualificationsecond_read: a single model call that reads a draft and reports what a careful human editor would notice, unscored and untiered, never a rewrite. Hosted only: this install always fails with a clear explanation, since a model call needs an account, a pinned model, and a billing surface this install doesn't have.audit_textremains fully available, no account neededadd_banned_word/remove_banned_word: maintain your own banned-vocabulary list, checked byaudit_textalongside the built-in corpusadd_custom_word/remove_custom_word: maintain a "never flag this" list: an org's own acronyms or house terms, the corporate-dictionary caselist_dictionary: see a scope's banned/custom words, and (for a style) what actually applies once merged with the global listset_style_instructions/clear_style_instructions/get_style_instructions: save, remove, or read free-text drafting rules for a scope (required elements, forbidden topics, format constraints), merged intoget_style_guidethe same way dictionaries merge intoaudit_text
A Claude Code / Claude Desktop skill (
skills/etincel-nonfiction/) that uses those tools when you're drafting or revising non-fiction prose of any meaningful length.
Trained voices, dictionaries, and your default style live locally in ~/.etincel/: nothing is sent anywhere. audit_text is plain deterministic code (string analysis + a curated corpus of AI-writing tells), not a model call. The one exception is forking a public style via fork_style, which fetches (never sends) that style's guide from etincel.ai's public gallery; forking a preset, or anything else in this list, still touches the network not at all.
Custom dictionaries
Beyond the built-in AI-tell corpus, you can maintain your own banned and "always allowed" word lists: just tell Claude (or any MCP client) things like "add [word] to my banned words list" or "add [word] to my custom words list, it's one of ours." Each list lives at a scope: global (applies everywhere, the default when no style is named) or a specific style id, whose list is merged on top of global when you audit against that style. list_dictionary shows what's saved for a scope, plus the effective merged list for a style. Editing the global list is already the way to keep a word in sync across every style: it's merged in automatically, live, every time audit_text or list_dictionary runs.
Development
npm install
npm test # run the engine/tools test suite (node:test via tsx)
npm run dev # run the MCP server over stdio via tsx, for local testing
npm run build # compile to dist/
The mcpscore badge audits the hosted remote server (etincel.ai/api/mcp), not the local/stdio engine in this repo; the two expose the same tools but run as separate deployments.
Status and limitations
Early, and honestly so.
The audit corpus in
src/data/is a curated subset, not exhaustive. Seesrc/data/SOURCES.mdfor provenance and what isn't ported yet. The full corpus is at aistoryhub.co/corpus.email(AUC 0.540) andgeneral(0.748) are uncalibrated.socialhas no labeled corpus at all and isn't tracked.check_voice_matchis a rhythm-and-mechanics check, not authorship detection, and it's low-confidence on short input.check_self_repetitionis local-install only for now.AI tells are a moving target: OpenAI patched ChatGPT's em-dash habit in November 2025. That's why efficacy is measured rather than claimed: when a tell stops being a tell, the AUC moves and the regression check catches it.
Available Tools
19 toolsadd_banned_wordAdd a word to a banned-words listAIdempotentInspect
Add a term to this installer's own banned-words list, checked by audit_text alongside the built-in AI-tell corpus. Without styleId, this adds to the global list, which applies to every style. With styleId, it only applies when auditing against that specific style, merged on top of the global list. Use this when the user says something like 'add [word] to my banned words list' or 'never let me use [word] again'.
Inputs: word (required), styleId.
add_custom_wordAdd a word to a custom (allowed) words listAIdempotentInspect
Add a term to this installer's own allowed-words list, so audit_text never flags it even if it matches the built-in corpus or a banned word: the 'corporate dictionary' case, e.g. an org's own acronyms or house terms. Without styleId, this adds to the global list. With styleId, it only applies to that specific style, merged on top of the global list. Use this when the user says something like 'add [word] to my custom words list' or 'stop flagging [word], it's one of ours'.
Inputs: word (required), styleId.
audit_textAudit text for AI writing tellsARead-onlyIdempotentInspect
Deterministically scan a piece of non-fiction text for common AI-writing tells: banned hype vocabulary, chatbot fingerprints, and structural patterns (uniform paragraph length, stacked transitions, em-dash overuse, rule-of-three compulsion, and more), plus this installer's own banned/custom word lists from add_banned_word/add_custom_word (the 'global' list, merged with a style's own list if styleId is given), plus a repo-local .etincelrc/.etincelrc.json/etincel.config.json if one exists at or above the current directory (dictionary as code, reviewable and versioned). Returns a tier (green/yellow/orange/red), a numeric score, specific findings with severity and location, and a strengths signal (specificity density, concrete-vs-abstract ratio, sentence-rhythm variation). Read strengths too, not just findings: it's the counter-signal against fixing every flagged word into flat, sterile prose. Never a silent rewrite. Use this to show the user what's flagged and why, so they stay in control of any change; only rewrite what they ask you to rewrite.
Inputs: text (required), styleId, register.
check_self_repetitionCheck a draft for habits repeated across a voice's past piecesARead-onlyIdempotentInspect
Compare a piece of drafted text against a trained voice's own recent training samples for two kinds of self-repetition: opening the same way ("you've opened this way in 4 of your last 6 pieces"), and reusing a characteristic phrase across several of them. This is about the writer's own recurring habits, not AI-writing tells; use audit_text for those. Only meaningful for a voice trained from real samples (train_style) with at least 3 recorded samples; dial-tuned or preset-forked voices, or ones with too little history yet, come back with an empty findings list rather than an error. Only the local install tracks sample history today, so a hosted/remote connection may always report zero history. A signal to weigh, same trust-mode spirit as audit_text: never rewrite the draft on the strength of this alone.
Inputs: text (required), id, styleId.
check_voice_matchCheck a draft's rhythm against a trained voiceARead-onlyIdempotentInspect
Compare a piece of drafted text's measured sentence/paragraph rhythm and mechanics against a trained or custom voice's baseline (sentence length, rhythm variance, paragraph variance, contraction rate, em-dash use, fragment use, question use, structural entropy). Use this after drafting in a voice to check whether the draft's rhythm actually landed close to it, instead of just eyeballing it. Returns a verdict ('on rhythm' / 'some drift' / 'off rhythm'), a match score, specific dials that drifted with a plain-language note for each, and a caveat you should relay alongside the verdict: this is a rhythm/mechanics measurement, not an authorship or AI-detection check, so text merely shaped like the voice (by anyone, or any tool) can come back 'on rhythm', and a genuine off-voice draft by the target writer can still come back drifted. Confidence comes back "low" on short input, since a handful of sentences isn't enough to read rhythm reliably; treat a low-confidence verdict as provisional. Only works against trained or custom voices (from train_style, create_style_from_dials, or fork_style), not bare presets, which have no measured baseline; fork_style a preset first if you want to check a draft against one.
Inputs: text (required), id, styleId.
clear_style_instructionsClear custom instructions for a styleAIdempotentInspect
Remove the saved instructions for a scope (global, or a specific style), leaving it empty.
Inputs: styleId.
create_style_from_dialsCreate a style from dialsAIdempotentInspect
Build a style profile from explicit dial values instead of writing samples: for when the user wants to hand-tune a voice (or doesn't have samples handy). 3 persona dials (formality, warmth, directness, 0-10) plus 8 mechanical dials (0-100, including entropy: how much AI-typical structural regularity to break) that map onto the same measurements train_style extracts from real text, so a dial-built style and a trained voice are the same shape. Call again with the same name to overwrite.
Inputs: name (required), dials (required).
delete_styleDelete a trained voiceADestructiveIdempotentInspect
Permanently delete a trained voice profile by id. Does not affect premade presets.
Inputs: id, styleId.
fork_styleFork a preset or published community style into a trained voiceAInspect
Copy a style into a new trained voice under the given name, seeded with its persona dials and drafting guide. Two kinds of source: a premade preset (e.g. 'pr-review', 'linkedin-post'), or another installer's style published publicly on the hosted gallery, addressed as "handle/slug" (e.g. "jpleblanc/blunt-memo", the same address shown on its public page at etincel.ai/v/handle/slug). A public-style fork makes one network call to etincel.ai to fetch it; a preset fork never leaves this install. The fork is then a normal trained voice: retrain it with train_style from real samples, or hand-tune it with update_style, without touching the original.
Inputs: name (required), styleId, presetId.
get_style_guideGet a style guideARead-onlyIdempotentInspect
Fetch the full drafting guide for one style (a preset id like 'direct-warm', the id of a trained voice, or 'team' for the shared style a .etincelrc in the current repo defines, if any). Returns prose instructions to follow while drafting or revising: sentence rhythm, tone dials, and (for trained voices) the writer's own measured habits. If a .etincelrc in the current repo sets team-wide instructions, those are folded into every style's instructions, not just 'team''s. Read this before drafting; it is context for you, the drafting model, not a tool that writes prose itself.
Inputs: styleId (required).
get_style_instructionsGet custom instructions for a styleARead-onlyIdempotentInspect
Show the saved instructions for a scope: the global instructions (default), or a specific style's own. For a style, also returns the effective merged text (global plus that style's own) that get_style_guide already folds in automatically.
Inputs: styleId.
list_dictionaryList a dictionary's banned and custom wordsARead-onlyIdempotentInspect
Show the banned-words and custom (allowed) words lists for a scope: the global list (default), or a specific style's list. For a style, also returns the effective merged list (that style's words plus the global ones): what audit_text actually applies when that style is selected.
Inputs: styleId.
list_stylesList writing stylesARead-onlyIdempotentInspect
List every available style: premade emotional-tone presets, any voices the user has trained from their own samples, and (if a .etincelrc in the current repo defines one) the shared team style, id 'team'. Call this before drafting or revising non-fiction prose if the caller hasn't been told which style to use, or if the user asks what styles exist.
Inputs: no named parameters.
remove_banned_wordRemove a word from a banned-words listAIdempotentInspect
Remove a term from this installer's banned-words list (global, or a specific style's list).
Inputs: word (required), styleId.
remove_custom_wordRemove a word from a custom (allowed) words listAIdempotentInspect
Remove a term from this installer's allowed-words list (global, or a specific style's list).
Inputs: word (required), styleId.
set_default_styleSet the default styleAIdempotentInspect
Set which style (preset or trained voice) should be used by default for this user going forward, so it doesn't need to be re-specified every time.
Inputs: id, styleId.
set_style_instructionsSet custom instructions for a styleAIdempotentInspect
Save free-text drafting rules layered on top of a style's voice: required elements ('always include a CTA'), audience notes, forbidden topics, format constraints, anything that isn't about sentence rhythm or tone. Overwrites whatever was saved for this scope. Without styleId, this sets the global instructions, which apply to every style. With styleId, it only applies to that specific style, merged after the global instructions (get_style_guide returns the merged result automatically). Use this when the user says something like 'for this style, always end with a CTA' or 'remember: never mention pricing in emails'.
Inputs: instructions (required), styleId.
train_styleTrain a voice from writing samplesAInspect
Analyze one or more of the user's own writing samples (emails, posts, essays, memos: real finished text they wrote or approved) and persist a trained voice profile under that name. Measures sentence length and variance, paragraph rhythm, contraction rate, em-dash and semicolon habits, fragment use, structural entropy (sentence-opener variety and punctuation-mark variety), and recurring phrasing. Call again with the same name and new samples to add more training data to that voice; the new samples blend into its existing measurements rather than replacing them. If the voice may have been renamed since it was created, pass its id (from list_styles) instead so the right voice is targeted regardless of its current name. This never fabricates a voice from a description; it only learns from real text the user supplies.
Inputs: name (required), samples (required), id, styleId.
update_styleEdit an existing custom styleAIdempotentInspect
Rename a trained voice or adjust its dials in place, keeping its id (and default-style pointer) stable. Persona dials (formality, warmth, directness) always apply; the mechanical dials only take effect if the voice has no writing samples (was built from dials, not trained). A sample-trained voice keeps its measured mechanical stats regardless of what's passed here.
Inputs: name (required), dials (required), id, styleId.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 19 tools
Each tool targets a distinct resource and action: style lifecycle (list, get, create, update, delete, fork), voice checking (match, self-repetition), text auditing, dictionary management, and instructions. Even similar-sounding pairs like get_style_guide vs get_style_instructions are clearly differentiated by their descriptions.
All 19 tools follow a consistent verb_noun snake_case pattern (list_styles, train_style, create_style_from_dials, check_voice_match, add_banned_word, etc.). There is no mixing of camelCase or inconsistent verb styles.
With 19 tools, the set is on the heavier side but each tool serves a clear purpose within the server's broad scope of style management, auditing, and dictionary maintenance. The count is slightly over the ideal 3-15 range but still well-organized and justified.
The surface provides full lifecycle coverage for styles (create via samples or dials, read, update, delete, fork, list, set default), plus text quality checks (AI tells, voice match, self-repetition), word-list management, and instructions. There are no significant dead ends or missing core operations; the server intentionally does not generate prose directly.
Maintenance
Related MCP Connectors
A personal RAG database you build from chat, so AI creates work that sounds like you.
Build a voice from your own texts, measure whether a text still sounds like you, then write in it.
Write, rewrite, and refine in your own style. Build and manage your Writing Profile.
An editor to finish what you write with your AI: checks, reviews, and your own edits on one draft.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceMCP server offering text analysis tools for writing improvement, including spellcheck, readability, keyword analysis, passive voice detection, and AI-generated content detection.11MIT
- AlicenseAqualityCmaintenanceContent writing toolkit for headline generation, readability scoring, tone analysis, outline building, and plagiarism similarity checking.540 PyPIMIT
- AlicenseAqualityDmaintenanceA private, open-source AI-text checker. Get a read on whether text looks AI-written, the exact AI-tell spans to fix, a reuse check, and a grammar pass.4MIT
- AlicenseAqualityBmaintenanceFlag AI tells, weasel words, passive voice, duplicate words, long sentences, nominalizations, hedging, and filler adverbs49MIT