readability-mcp-server
This server gives AI agents local, privacy-preserving plain-language tools to score and simplify English text before sending it to humans.
Score text readability: computes Flesch Reading Ease, Flesch-Kincaid Grade Level, sentence/word/syllable counts, and readability labels for English text.
Simplify text: rewrites text into plainer language by splitting long sentences and substituting complex words (e.g., "utilize" → "use", "prior to" → "before").
Compare before/after readability: reports Flesch Reading Ease before and after simplification so you can confirm improvement.
Return Markdown or JSON: both tools support human-readable summaries or structured data output.
Works entirely locally: no API key, network calls, or external services — text never leaves the machine.
Integrates with MCP clients: callable from Claude Code, Claude Desktop, or any MCP-compatible client.
Handles unsupported text safely: non-Latin script is detected and returned unchanged with
supported: falseinstead of producing unreliable results.
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., "@readability-mcp-server Simplify this text: 'Please utilize the enclosed form prior to the deadline.'"
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.
readability-mcp-server
An MCP server that lets any AI agent check and improve the plain-language quality of its own text — before that text ever reaches a human. Fully local: no API key, no network call, no external service. It's a pure computation tool, so nothing you pass through it ever leaves the machine it's running on.
Unlike the other tools in this series (scamlens, clearread, clauselens), this one isn't a website a person opens — it's infrastructure for the AI agent ecosystem itself. Any MCP-compatible client (Claude Code, Claude Desktop, or any other) can call it directly.
Why
Agents generate a lot of text — replies, documentation, notices, error messages — and mostly have no way to check whether that text is actually easy for the recipient to read before sending it. This server gives any agent that self-check as a first-class tool call, using the same plain-language engine (sentence splitting + a vetted complex-to-plain word dictionary) already shipped and tested in clearread, the standalone web app in this series — here exposed for programmatic use instead of pasted by hand into a browser.
Related MCP server: slop-guard
Tools
readability_score_text
Computes Flesch Reading Ease and Flesch-Kincaid Grade Level for a block of
English text. Returns supported: false with structural counts only for
non-Latin script, since the Flesch formulas assume English syllable
patterns.
readability_simplify_text
Rewrites text in plainer language — splits overly long sentences at natural
clause boundaries and substitutes common bureaucratic vocabulary for plainer
equivalents — and reports the Flesch Reading Ease score before and after, so
you can confirm the rewrite actually helped. English only, by design: word
substitution is unreliable across languages with richer morphology, so
non-Latin-script text is detected and passed through unchanged rather than
risk broken grammar (see the note in src/services/simplify.ts about why a
few tempting dictionary entries, like "accompanied" → "went with", were left
out after they broke common fixed phrases like "must be accompanied by").
Install and configure
Clone and build:
git clone https://github.com/wedo911/readability-mcp-server.git
cd readability-mcp-server
npm install
npm run buildAdd it to your MCP client's config (e.g. claude_desktop_config.json, or a
project's .mcp.json for Claude Code):
{
"mcpServers": {
"readability": {
"command": "node",
"args": ["/absolute/path/to/readability-mcp-server/dist/index.js"]
}
}
}Run the tests
npm run build
node --test tests/textStats.test.mjs tests/simplify.test.mjsTry it without a client
The MCP Inspector can call tools directly from the command line:
npx @modelcontextprotocol/inspector --cli node dist/index.js \
--method tools/call --tool-name readability_simplify_text \
--tool-arg text="Please utilize the enclosed form prior to the deadline."License
MIT — see LICENSE.
Available Tools
2 toolsreadability_score_textScore Text ReadabilityARead-onlyIdempotent
Compute Flesch Reading Ease and Flesch-Kincaid Grade Level for a block of English text.
Use this to check how easy your own draft output (a reply, a document, documentation) will be for a reader to understand before sending it -- useful for agents that want to self-check plain-language quality, or for comparing readability across different drafts.
Args:
text (string, 1-20000 chars): The text to score.
response_format ('markdown' | 'json'): Output format (default: 'markdown').
Returns: For JSON format: { "supported": boolean, // false if the text contains non-Latin script (Flesch formulas assume English) "fleschReadingEase": number|null, // 0-100, higher = easier; null if unsupported or no words found "fleschKincaidGradeLevel": number|null, // approximate US school grade level "gradeLevelLabel": string|null, // human description, e.g. "standard (around 8th-9th grade)" "sentenceCount": number, "wordCount": number, "syllableCount": number, "avgWordsPerSentence": number, "avgSyllablesPerWord": number }
Examples:
Use when: "Is this support-ticket reply easy enough to understand?" -> score the reply text
Use when: "Which of these two drafts reads more simply?" -> score both, compare fleschReadingEase
Don't use when: the text is not primarily English -- scoring is skipped for non-Latin script and only structural counts are returned
Error Handling:
Returns an error if text is empty or exceeds 20000 characters (split long documents into sections first).
Inputs: text (required), response_format.
readability_simplify_textSimplify TextARead-onlyIdempotent
Rewrite English text in plainer language: breaks overly long sentences at natural clause boundaries and swaps common bureaucratic vocabulary ("utilize" -> "use", "prior to" -> "before") for plainer equivalents. Also reports the Flesch Reading Ease score before and after, so you can confirm the rewrite actually helped.
Use this before sending a reply, document, or notice to a user who may benefit from plainer language -- including as a self-check step for an agent's own drafted output.
Args:
text (string, 1-20000 chars): The English text to simplify.
response_format ('markdown' | 'json'): Output format (default: 'markdown').
Returns: For JSON format: { "supported": boolean, // false if text contains non-Latin script (English-only feature); simplifiedText equals the input unchanged in that case "simplifiedText": string, "changeCount": number, // total words/phrases substituted "changes": [ { "start": number, "end": number, "original": string, "simplified": string } ], // offsets index into simplifiedText "truncated": boolean, // true if changeCount exceeds 50 (only the first 50 are listed) "fleschReadingEaseBefore": number|null, "fleschReadingEaseAfter": number|null }
Examples:
Use when: "Make this notice easier to read" -> pass the notice text
Use when: checking whether your own drafted reply is needlessly complex before sending it
Don't use when: the text is not primarily English -- word substitution is skipped for non-Latin script (Arabic morphology in particular makes naive word-swapping unreliable) and the text is returned unchanged, with supported=false
Error Handling:
Returns an error if text is empty or exceeds 20000 characters.
Inputs: text (required), response_format.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 2 tools
The two tools have clearly distinct purposes: one measures readability metrics, the other rewrites text to simplify it. There is no overlap or ambiguity in choosing between them.
Both tool names follow a consistent pattern: domain prefix 'readability_' plus verb_noun pairs ('score_text', 'simplify_text'). The naming is uniform and predictable.
Two tools is on the thin side for a server, but it is a tightly focused scope: measuring and simplifying readability. It feels slightly minimal but each tool earns its place.
For the stated purpose of assessing and improving plain-language readability, the server covers both key operations: evaluating a text's readability and rewriting it into plainer language. No obvious critical gap exists.
Related MCP Connectors
Clean Markdown and AI-readability scoring for any URL. Built for AI agents.
The open, measured register where AI agents evolve written English together.
Check text before your agent reads it: hidden instructions, invisible text and links that leak data.
Toxicity scores (0-1) for text before an agent posts it. Perspective API compatible. No LLM.
Related MCP Servers
- AlicenseNot gradedqualityCmaintenanceEnables Claude to analyze and improve readability of text using local deterministic metrics like Flesch Reading Ease and lexical diversity, without sending data to external services.1MIT
- FlicenseNot gradedqualityAmaintenanceEnables agents to analyze text strings or files for formulaic AI writing patterns, returning a 0–100 score, band label, specific violations with context, and concrete advice. It performs this rule-based linting locally without LLM judges or API calls.-
- FlicenseNot gradedqualityAmaintenanceEnables agents to score prose from 0-100 for formulaic AI writing tells using pure rule-based heuristics, exposing tools to analyze inline text or files on disk and return violation details, band labels, and concrete advice without any LLM judge or network calls.-
- FlicenseNot gradedqualityAmaintenanceScores prose from 0 to 100 for formulaic AI writing patterns using purely programmatic rules, with no LLM judge or API calls. Enables agents to lint text or files and receive a score, band label, specific violations with surrounding context, and concrete advice for each hit.-