Skip to main content
Glama

docstats

Docstats calculates readability scores and provides deterministic house-style linting for plain text, web pages, and PDFs. Designed as a post-hoc acceptance gate for CI/CD pipelines, PR reviews, and pre-publish editorial QA, docstats runs as an MCP server for AI coding assistants or as a FastAPI web service.

Table of Contents

Related MCP server: mcp-pdf-tools

Features

  • Readability scoring (Axis A): Computes consensus grade level plus 9 standard formulas (Flesch Reading Ease, Flesch-Kincaid, Gunning Fog, SMOG, Coleman-Liau, and more).

  • House-style linting (Axis B): Deterministic pattern checking for throat-clearing openers, binary contrast frames, non-technical filler adverbs, rhetorical em dashes, and rhythm indicators.

  • Multiple inputs: Reads direct text, public web pages, and PDFs from web URLs or Google Cloud Storage (gs://).

  • Agent Plugin v1.0.0: Native MCP STDIO tool (readability-docstats) and prompt skill (readability-analysis).

  • Flexible runtime: Runs as a local REST API, an MCP STDIO server, or a streamable HTTP server.

Recommended Workflow: Post-Hoc Acceptance Gate

Docstats is optimized as an asynchronous acceptance gate and editorial linter rather than an in-prompt generative dial. Empirical research indicates that injecting live numeric metrics during text generation does not improve prose quality over clear textual guidance and risks artificial metric gaming. Use docstats to audit drafts, run pre-commit checks, or gate documentation CI workflows.

Quickstart

Run docstats right away with uv:

# Start the MCP server over STDIO (for Claude Code, Gemini CLI, Cursor, etc.)
uv run python main.py --server-type mcp

# Or start the local REST API server
uv run uvicorn fastapi_app:fastapi_app --reload

Send a test request to the REST API:

curl -X POST "http://127.0.0.1:8000/scores/" \
  -H "Content-Type: application/json" \
  -d '{"text": "Docstats makes readability analysis fast, delightful, and robust."}'

Example response:

{
  "flesch_reading_ease": 45.1,
  "flesch_kincaid_grade": 8.8,
  "text_standard": "8.0",
  "word_count": 8,
  "sentence_count": 1
}

Installation

Prerequisites

  • Python 3.10+

  • uv package manager

Setup

Clone the repository and install dependencies:

git clone https://github.com/ghchinoy/docstats.git
cd docstats
uv sync

(Optional) If you read PDFs from Google Cloud Storage (gs://), log in with Application Default Credentials:

gcloud auth application-default login

Agent Plugin & MCP Usage

Docstats implements the Agent Plugins v1.0.0 spec. Agent runtimes find the plugin manifest, MCP tool, and skill guidance automatically.

File

Purpose

plugin.json

Plugin metadata and version information

mcp.json

MCP STDIO server declaration

skills/readability-analysis/SKILL.md

Skill guidance for AI assistants

Manual MCP Client Setup

To configure an MCP client manually (such as in ~/.claude/settings.json or Gemini CLI):

{
  "mcpServers": {
    "readability_docstats": {
      "command": "uv",
      "args": ["run", "python", "/ABSOLUTE/PATH/TO/docstats/main.py", "--server-type", "mcp"],
      "cwd": "/ABSOLUTE/PATH/TO/docstats"
    }
  }
}

Server Modes

Docstats supports three execution modes:

  1. MCP STDIO Server:

    uv run python main.py --server-type mcp
  2. FastAPI REST API:

    uv run uvicorn fastapi_app:fastapi_app --host 127.0.0.1 --port 8000 --reload

    Interactive Swagger docs open at http://127.0.0.1:8000/docs.

  3. MCP Streamable HTTP Server:

    uv run python main.py --server-type mcp-http --host 127.0.0.1 --port 8001

Development & Testing

Run Tests

Run the test suite with pytest:

# Run all tests
uv run pytest

# Run fast unit tests only (no network needed)
uv run pytest test_unit.py

# Run tests without slow integration tests
uv run pytest -m "not slow"

Golden Set Benchmarks

Check score consistency against baseline sample files:

uv run python baseline_analysis.py

Code Quality

Run formatting and lint checks:

uv run ruff check .
uv run ruff format --check .

Readability Scores

Docstats provides the following metrics:

Metric

Target / Range

Description

Text Standard

Consensus grade

Best overall summary grade

Flesch Reading Ease

0 to 100 (higher is easier)

90–100: Grade 5; 60–70: Plain English; <30: Difficult

Flesch-Kincaid Grade

Grade level

Years of education needed

Gunning Fog Index

Grade level

Counts complex words with 3 or more syllables

SMOG Index

Grade level

Standard for consumer and health copy

Coleman-Liau Index

Grade level

Based on character count per word

Automated Readability (ARI)

Grade level

Based on letter and sentence counts

Linsear Write

Grade level

Common technical writing formula

Dale-Chall Score

0.0 to 10.0+

Measures hard words outside common word lists

Spache Score

Primary grade level

For primary school level texts

Documentation

The full documentation site is published at ghchinoy.github.io/docstats (built with Astro Starlight; source in site/). It covers a user-first explainer, MCP and skills integration, and technical deep dives on the linguistics and statistics.

Source-of-truth references:

Contributing

We welcome contributions!

  1. Fork and clone the repository.

  2. Create a feature branch (git checkout -b feature/my-feature).

  3. Run tests (uv run pytest) and linters (uv run ruff check .).

  4. Check baseline scores (uv run python baseline_analysis.py).

  5. Open a Pull Request.

License & Disclaimer

  • License: Apache License 2.0. See LICENSE for details.

  • Disclaimer: This is not an officially supported Google product.

Available Tools

1 tool
get_readability_scoresA

Calculates readability scores for text from direct input, a web URL, or a GCS PDF URI.

ParametersJSON Schema
NameRequiredDescriptionDefault
textNo
web_urlNo
gcs_pdf_uriNo

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description must convey all behavioral traits. It mentions calculation and input sources but does not disclose whether it fetches remote content, any safety profile, or output format—leaving significant behavioral aspects unspecified.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single sentence that is front-loaded with the core action and source options. No redundant words.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

The tool has no annotations and no output schema, yet the description does not specify which readability formulas are used, the return structure, or input validation rules. This is a notable gap, though the basic functionality is clear.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The schema provides no descriptions; the description adds context by naming the three source types, which maps to the text, web_url, and gcs_pdf_uri parameters. However, it does not clarify mutual exclusivity or format requirements, so the added value is limited.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description uses a specific verb 'Calculates' and identifies the resource as 'readability scores', with clear input sources (text, web URL, GCS PDF URI). This clearly differentiates the tool's function.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies the tool is for calculating readability when given one of the three source types, but it does not explicitly state when to prefer this tool over alternatives, nor does it mention any exclusions or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

TDQS

A3.5/5.0
Disambiguation5/5

With only one tool, there is no possibility of confusing it with another. The tool's purpose is singular and well-defined, eliminating any disambiguation concerns.

Naming Consistency5/5

The single tool follows a clear verb_noun naming pattern ('get_readability_scores'), which is consistent and predictable. Since there's only one tool, naming consistency is trivially maintained.

Tool Count2/5

A server with only one tool is too few for the apparent scope of 'docstats', which implies a broader set of document statistics. The tool is not trivial, but the server feels underpopulated for its purpose.

Completeness2/5

The server only provides readability scores, which is a narrow slice of document statistics. Given the server name 'docstats', one would expect additional metrics like word count, sentence length, or writing level, leaving notable gaps.

Maintenance

ActivityMaintained
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/ghchinoy/docstats'

If you have feedback or need assistance with the MCP directory API, please join our Discord server