Solar Human Proofreader

An MCP server that returns your manuscript as if a human editor had gone over it with a red pen. It proofreads Korean text to make it easier to read. Upstage Solar Pro 4 does the sentence work, and code verifies that facts, quotations, and style are preserved. Nothing is added, nothing is removed.

A server-side MCP deployed on Vercel. Up to 100 calls per day for free; beyond that, you use your own key (BYOK).

What's different

It is not a tool that scrubs out the "AI smell." It is a tool that removes the places where a reader ends up reading something twice. That is why the workflow follows a human editor's process, not detect-and-replace.

We don't ask the model “Tell me how much you changed.” A model grading something it just wrote is always generous. Change rate, number preservation, quote comparison, and register detection are all done in code. The same input always produces the same verdict.

Editing principles

• Red-pen principle — If you can't say the reason for a change in one sentence, don't make it.

• Lean toward cutting — Good proofreading does not add. If the length grows, a warning appears.

• The style belongs to the author — Raising it from plain to formal speech is rewriting, and if the tone gets turned around the revision is rejected.

• Facts stay unchanged — If even one sentence or figure appears that wasn't in the original, that revision is rejected.

Tools

proofread arguments

Connecting

Clients that speak Streamable HTTP (Claude Code, Cursor, etc.) just need the URL.

{
  "mcpServers": {
    "human-proofreader": {
      "url": "https://<your-deployment>.vercel.app/api/mcp"
    }
  }
}

Claude Code can also do it in one command line.

claude mcp add --transport http human-proofreader https://<your-deployment>.vercel.app/api/mcp

For stdio-only clients, use npx -y mcp-remote <url>.

Handing it straight to the AI

So that a deployment URL alone is enough to finish the setup, a machine-readable guide is provided alongside the main text. Both routes read the actual deployed URL from the request header and use that, so placeholders never leave in the copy.

Free 100 calls, then your own key

The free tier is measured per single Solar call. If one proofread performs one read-through and one correction, it deducts two calls. Counting by tool invocation instead, the same limit would look ten times different per person, so neither the caller nor the provider could predict it. readability and compare don't call Solar, so no deduction is made. The counter resets at KST midnight.

To go past the limit, put your own key in a header. We use headers rather than tool arguments because a key in the argument would appear in plaintext in the client's conversation log.

{
  "mcpServers": {
    "human-proofreader": {
      "url": "https://<your-deployment>.vercel.app/api/mcp",
      "headers": {
        "X-Upstage-Api-Key": "up_..."
      }
    }
  }
}

With your own key there is no daily limit, and the usage is billed to your provider.

Deploying it yourself

git clone https://github.com/SolarLLM/human-proofreader-mcp
cd human-proofreader-mcp && npm install
cp .env.example .env.local   # OPENROUTER_API_KEY 또는 UPSTAGE_API_KEY 를 채운다
npm run dev                  # http://localhost:3000/api/mcp

vercel deploy --prod

Environment variables

It works without Redis as well, but serverless runs many instances, so the limit becomes loose. To actually enforce 100 calls, attach Upstash Redis.

Vercel plan vs depth: the Hobby plan cuts a function at 60 seconds. deep (3 calls) can pass that on a long manuscript, so on Hobby use standard or lower, or upgrade to Pro (max 300s).

Development

npm test        # 결정적 계층(가독성·대조·변경률) 회귀 테스트
npm run typecheck

We don't test the part that calls the LLM. Instead we test all the code that decides — because a gate that quietly passes is the most dangerous failure of this server.

How the change rate is measured

The amount of revision is the baseline for over-edit detection. Counting by phrases (어절), one modified 조사 turns a whole phrase into "changed" and doubles the real number — measured: 22.8% counted by character, 46.9% counted by phrase. So we count characters.

We dropped all approaches that first align sentences or paragraphs. Good editing splits long sentences, connects short ones, and cuts paragraphs. Whatever the unit, a 1:1 alignment reads the splits and joins as "a mismatch" and misclassifies normal editing as rewriting—measured: a public notice split into four paragraphs scored 75%, but it's actually 27%.

Running LCS over the whole text is both exact and affordable — 20k vs 20k chars takes about 1.1 seconds. That is nothing next to a Solar call that goes over 20 seconds. The result matches Python's character-based difflib exactly (measured 0.228 = 0.228, 0.680 = 0.68).

The thresholds are **warning at 30% · stop at 50%**.

Korean has so many overlapping particles and verb endings that even a completely different text sits at a floor of 0.65–0.70. The stop line at 0.50 is below that floor, and above normal strong editing (0.25–0.45).

What the cross-check gate catches

Whole-sentence injection is clearly caught. When several words inside a sentence have changed, we don't block it; it's shown in the new_terms list — because proofreading naturally changes words, and blocking those would flood the output with false positives. In practice this list caught quiet qualifier adds such as “한국 existing" → “한국 same-context baseline”.

Thanks line:

The inspiration for recognizing an "AI tell" in Korean text and the style-classification system come from epoko77-ai/im-not-ai. We didn't reuse their code; we wrote everything new. This server is a separate design focused on "readable prose," not "AI tell removal."

License

MIT