Reviews drafts by fact-checking claims against web sources, building counter-arguments, and providing copy edits and originality notes.
Also known as sbanthia92/second-read, second-read
- Stars
- 0
- Tools
- 1
- Downloads, 30 days
- 515
- Latest version
- 0.1.4
- Last commit
- Nov 12, 2026
- License
- MIT
What is Second Read MCP?
Second Read reviews drafts by fact-checking claims against web sources, building counter-arguments, and providing copy edits and originality notes. It exposes 1 tool, such as review_document.
Summary generated from the project's README
About Second Read MCP server
Reviewing articles, blog posts, or design documents for accuracy and clarity is what Second Read enables for writers and engineers. By using the review_document tool, users can submit text or a public URL to receive a comprehensive markdown report. This report identifies factual errors with cited web sources, builds a strong counter-argument to challenge the author's thesis, provides copy edits for grammar, and flags sentences that closely match existing online content.
This server runs locally on your machine using your own Anthropic and Tavily API keys, ensuring that your documents are not sent to the project author. It is compatible with Claude Desktop, Claude Code, and any MCP client that supports local stdio servers, such as Cursor or VS Code. For technical documents, you can specify a design_doc profile, or use the opinion profile for general writing. The system handles documents up to 20,000 words and uses a multi-agent orchestration process to extract claims and verify them through web searches.
What you can do with it
- 1Fact-checking recent claimsVerify that specific dates, scores, or figures in an article are accurate by checking them against live web sources.
- 2Strengthening an argumentIdentify potential weaknesses in your writing by generating a devil's advocate perspective based on retrieved evidence.
- 3Checking for plagiarismDetect if your sentences closely resemble existing text found on the internet to ensure originality.
- 4Polishing technical documentationImprove the structure and clarity of a technical design document using specialized review profiles.
Written from the project's README. Every use case is checked against a quote from it.
How to install Second Read MCP
Formats verified 10 Nov 2026Add to CursorAdd to GooseInstall Second Read MCP in Claude Code
$ claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' second-read -- uvx second-readInstall Second Read MCP in Cursor
~/.cursor/mcp.json
{
"mcpServers": {
"second-read": {
"command": "uvx",
"args": [
"second-read"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>"
}
}
}
}Install Second Read MCP in VS Code
.vscode/mcp.json
{
"servers": {
"second-read": {
"type": "stdio",
"command": "uvx",
"args": [
"second-read"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>"
}
}
}
}Install Second Read MCP in VS Code CLI
$ code --add-mcp '{"name":"second-read","type":"stdio","command":"uvx","args":["second-read"],"env":{"ANTHROPIC_API_KEY":"<YOUR_ANTHROPIC_API_KEY>","TAVILY_API_KEY":"<YOUR_TAVILY_API_KEY>"}}'Install Second Read MCP in Claude Desktop
claude_desktop_config.json
{
"mcpServers": {
"second-read": {
"command": "uvx",
"args": [
"second-read"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>"
}
}
}
}Install Second Read MCP in Codex
$ codex mcp add second-read --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' -- uvx second-readInstall Second Read MCP in Codex config.toml
~/.codex/config.toml
[mcp_servers.second-read] command = "uvx" args = ["second-read"] [mcp_servers.second-read.env] ANTHROPIC_API_KEY = "<YOUR_ANTHROPIC_API_KEY>" TAVILY_API_KEY = "<YOUR_TAVILY_API_KEY>"
Install Second Read MCP in Gemini CLI
$ gemini mcp add -s user -e 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' -e 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' second-read uvx -- second-readInstall Second Read MCP in Gemini settings.json
~/.gemini/settings.json
{
"mcpServers": {
"second-read": {
"command": "uvx",
"args": [
"second-read"
],
"env": {
"ANTHROPIC_API_KEY": "<YOUR_ANTHROPIC_API_KEY>",
"TAVILY_API_KEY": "<YOUR_TAVILY_API_KEY>"
}
}
}
}Started by HostedMCP on 16 Nov 2026
We ran this command for second-read 0.1.4 in an isolated container with no network and no keys. It answered and listed 1 tool.
Second Read MCP tools 1
Read from the server with tools/listreview_documentReview a document draft with a desk of specialist agents: a fact-checker that cites sources, a devil's advocate that builds the strongest counter-case, a structure reviewer, a copy editor and an originality check. Returns a markdown report (must fix, counter-case, should fix, polish, originality notes, claim ledger). Pass exactly one of `content` (the text or markdown) or `url` (a public page). Reviews take a few minutes.
Configuration
ANTHROPIC_API_KEYRequiredSecretAnthropic API key, used for the review's model calls
TAVILY_API_KEYRequiredSecretTavily API key, used for web search
MCP_TOOL_TIMEOUTSECONDREAD_FAKE
Automated checks
Ran Nov 13, 2026Full report →Passed our automated checks. That is not a security audit: read the code and give the server the narrowest access it needs. How checks work
- Source repository linked and reachablesbanthia92/second-read is public and reachablegithub.com/sbanthia92/second-read ↗Pass
- Package names this repository as its sourcesecond-read names sbanthia92/second-read as sourcepypi.org/project/second-read/ ↗Pass
- Build provenance (Sigstore attestation)Sigstore attestation for second-readpypi.org/project/second-read/ ↗Pass
- Open source license (OSI)MITspdx.org/licenses/MIT.html ↗Pass
- Commit or release in the last yearLast commit or release 2026-11-12github.com/sbanthia92/second-read ↗Pass
- OpenSSF ScorecardNot checked
- Package name not close to a popular packageNo popular package one edit away from second-readPass
- No critical advisory in the package or its dependencies41 resolved dependencies checked; no critical advisoryosv.dev ↗Pass
- No hidden instructions to the model4 tool descriptions and the README read; no override phrases, credential paths or hidden charactersPass
- Destructive tools are labelledNo tool named like delete, drop or execPass
- Remote endpoint answers the MCP handshakeNot checked
README
View on GitHubSecond Read
Second Read reviews a draft the way a careful editor would, and shows its sources. You give it an article, a blog post or a design doc. It returns one report:
- Facts checked against the web. Each claim is looked up, and every "this is wrong" comes with the page that says so.
- The strongest counter-case. A devil's advocate builds the best argument against your piece from sources it retrieves.
- Copy edits. Grammar and clarity fixes that keep your voice.
- Originality notes. Sentences that closely match text found online.
It runs as an MCP server with one tool,
review_document, so you can ask for a review from Claude Code or Claude
Desktop. It also has a command-line tool. It runs on your machine with your
own API keys; nothing is sent to the author of this project.
A finding looks like this:
Factual error — "Mjällby clinched the title on 20 October 2025 by winning 2-0 at IFK Göteborg, with two games to spare"
The date, the 2-0 score and the opponent are confirmed. ESPN and Flashscore both say three rounds were left (27 of 30 played), so "two games to spare" is wrong.
What you need
- uv (it installs Python 3.12 for you).
- An Anthropic API key:
ANTHROPIC_API_KEY. - A Tavily search key:
TAVILY_API_KEY.
Getting your keys
You need two keys. Each takes a couple of minutes: sign up, create a key, copy it.
| Key | Where to get it |
|---|---|
ANTHROPIC_API_KEY |
Sign in at https://platform.claude.com, add credit under Billing, then create a key under API keys (https://platform.claude.com/settings/keys) |
TAVILY_API_KEY |
Sign up at https://app.tavily.com; the key is shown on the dashboard |
The Anthropic key is pay-as-you-go: reviews fail with a clear message if the
account has no credit. Keep keys out of chats and out of version control; put
them in the MCP client's env block or in a .env file as shown below.
A review of a 700-word article takes about two minutes and uses roughly 150,000–180,000 tokens on your model key (about $0.60–$1.20 at Anthropic's list prices in October 2026) plus about 30 searches.
Install: Claude Code
claude mcp add second-read \
-e ANTHROPIC_API_KEY=your-key \
-e TAVILY_API_KEY=your-key \
-- uvx second-read
Start Claude Code with a longer tool timeout, because a review takes minutes:
MCP_TOOL_TIMEOUT=600000 claude
Then ask: "Use second-read to review this draft", and paste the text or give a public URL.
Install: Claude Desktop
Add this to claude_desktop_config.json (on macOS:
~/Library/Application Support/Claude/claude_desktop_config.json), then restart
the app. If Claude Desktop cannot find uvx, use its full path (which uvx).
{
"mcpServers": {
"second-read": {
"command": "uvx",
"args": ["second-read"],
"env": {
"ANTHROPIC_API_KEY": "your-key",
"TAVILY_API_KEY": "your-key"
}
}
}
}
To try it without keys, replace the env block with
{"SECONDREAD_FAKE": "1"}. Demo mode returns placeholder findings and makes
no model calls.
Install: other MCP clients
Any client that runs local (stdio) MCP servers can use the same command. For
Cursor, VS Code and similar, add a server named second-read that runs
uvx second-read with ANTHROPIC_API_KEY and TAVILY_API_KEY in its
environment, as in the Claude Desktop example above.
Second Read is listed in the official MCP Registry
as io.github.sbanthia92/second-read, so clients and directories that read the
registry can find it.
ChatGPT and claude.ai on the web connect only to remote (hosted) MCP servers, so they cannot run Second Read yet. A hosted version is on the roadmap.
Command line
export ANTHROPIC_API_KEY=your-key TAVILY_API_KEY=your-key
uvx --from second-read secondread review path/to/draft.md --profile opinion > report.md
Or keep the keys in a .env file and pass it with --env-file path/to/.env.
Progress prints to the terminal; the report goes to report.md. Use
--profile design_doc for technical design docs, or leave the profile out to
let the tool decide. A URL works in place of a file path.
The tool
review_document takes:
| Argument | Required | Notes |
|---|---|---|
content |
one of content / url |
The draft as text or markdown (up to 20,000 words) |
url |
one of content / url |
A public web page to fetch and review |
profile |
no | auto (default), opinion or design_doc |
focus |
no | A steer, e.g. "check the financial figures" |
It returns the report as markdown and sends progress updates while it works.
The report has these sections: a verdict line; Must fix (factual errors and claims the sources do not back); Could not verify (claims it found no adequate source for, which is not the same as wrong); Strongest counter-case; Should fix (structure); Polish (copy edits); Originality notes; and an appendix listing every claim with its verdict and sources.
Settings
Set these in the MCP client's env block, in the environment, or in a .env
file (the server reads .env from its working directory, or the file named by
SECONDREAD_ENV_FILE).
| Variable | Purpose |
|---|---|
ANTHROPIC_API_KEY |
Anthropic model key |
TAVILY_API_KEY |
Web search key |
SECONDREAD_MODEL_CHEAP, _MID, _STRONG |
Override the model used for each tier |
SECONDREAD_MAX_WORDS |
Document size cap (default 20000) |
SECONDREAD_FAKE=1 |
Demo mode: no keys, no model calls |
Privacy
Second Read runs on your machine. The project's author runs no server and receives no data.
- What it collects. Nothing is collected by the project. To do a review the tool handles the document you give it and the web pages it retrieves.
- What leaves your machine, and where.
- Your document goes to Anthropic, under your key and their terms.
- Search queries built from your document's claims, and up to eight sentences quoted exactly for the originality check, go to Tavily, under your key and their terms.
- Web pages named in search results are fetched directly from your machine. The fetcher refuses private and local network addresses.
- Storage and retention. Nothing is stored after the review finishes. The report is returned to your client and is not kept by Second Read. Logs go to your terminal and never contain keys or document text.
- Sharing. Nothing is shared with anyone else. The only third parties are the model and search providers above, which you choose by supplying their keys.
- Keys. Read from your environment or a
.envfile you control, and never logged. - Contact. Questions or concerns: open an issue at
https://github.com/sbanthia92/second-read/issues. For security problems see
SECURITY.md.
How well it works
What was tested. Four articles written for the test, each with errors planted in it that cannot be settled from memory (recent results, exact figures): 19 planted wrong facts in all. Every planted error has an answer key recording the exact sentence and the true value. Each article was reviewed once by two setups:
- Single prompt: one request to the model Second Read uses for its strongest tier, "review this and argue the other side". No web search, so it cannot look anything up or cite a page.
- Second Read: the full review described below, with web search.
What "caught" means. The report has a factual-error finding on the sentence that holds the planted error. A "could not verify" note does not count, so a careful miss scores as a miss. "Rebutted" means a counter-argument was written against a deliberately weak argument; "caught" for borrowed sentences means an originality note on the copied sentence.
| Single prompt | Second Read | |
|---|---|---|
| Planted wrong facts caught (of 19) | 7 | 13 |
| ...of those, with a cited source | 0 | 13 |
| Weak arguments rebutted (of 4) | 2 | 4 |
| Borrowed sentences caught (of 3) | 3 | 1 |
| Tokens per article | about 5,000 | about 136,000 |
Reading the result. Second Read earns its cost on claims that need looking up: recent events, exact figures, and details a model cannot know from memory. The gain appears to come mainly from searching and reading sources, though this test did not separate that from the other design choices. Every finding names its source so you can check it in one click. It is slower, uses about 27 times the tokens, and did worse on borrowed sentences.
Limits of this test. It is small: 19 errors, one run each, so each error is worth about five points and the exact percentages are rough. It does not measure false alarms (true facts wrongly called wrong) for either setup. It does not say which of the six misses were careful "could not verify" results and which were missed outright. A larger run (all 40 documents, three runs each) is on the roadmap.
Getting the most from it:
- Open the cited source before acting on a "factual error". The report links the page and quotes the passage it relied on.
- Search results change, so two runs on the same draft can differ slightly.
- The originality check is a heuristic: it flags close matches found online.
- Sources are web pages; PDFs are not read.
How it works
An orchestrator runs specialist agents and settles their disagreements:
- A claim extractor splits the document into its thesis, supporting claims and checkable facts.
- In parallel: a fact-checker researches each fact in a bounded loop (search, fetch, read, assess; at most three rounds per claim); a devil's advocate gathers counter-evidence; a copy editor; for articles, an originality checker; and, for design docs, a structure reviewer.
- A reaction round: a verified fact the devil's advocate disputes is re-checked, and the two argue once over the most important disagreements.
- Fixed rules settle what is left (for example, a grammar fix on a sentence flagged as wrong is dropped), findings are ranked, and the report is written.
ARCHITECTURE.md describes how the system is built, the decisions behind it and their trade-offs, the planned hosted service, and the shared types.
Development
uv sync
uv run ruff check . && uv run ruff format --check . && uv run mypy && uv run pytest
Tests run offline with fakes. Tests that call real providers are marked live
and skipped by default (uv run pytest -m live). The evaluation harness and
its 40 seeded documents are in eval/ (see eval/README.md); running it
against real providers spends money on your keys.
Status
The local MCP server and command-line tool work. A hosted version (sign in,
add a key once, get the report by email) is designed in ARCHITECTURE.md but not
built. ROADMAP.md lists what comes next.
License
MIT. See LICENSE.
Second Read MCP questions
How do I add Second Read MCP to Claude Code?
Run claude mcp add --env 'ANTHROPIC_API_KEY=<YOUR_ANTHROPIC_API_KEY>' --env 'TAVILY_API_KEY=<YOUR_TAVILY_API_KEY>' second-read -- uvx second-read in your terminal. Add --scope user to make it available in every project.
How do I add Second Read MCP to Cursor?
Open ~/.cursor/mcp.json and add the server under mcpServers, using the Cursor config shown in the install section above.
What tools does Second Read MCP provide?
It exposes 1 tool, including review_document.