methods-mcp
Fetches paper metadata and full text from arXiv via the arXiv export API and ar5iv HTML rendering.
Resolves DOI identifiers to canonical paper metadata including title, authors, and abstract.
Assesses the reproducibility of GitHub repositories using repository metadata and file tree analysis via the GitHub REST API.
Discovers code repositories associated with academic papers by querying the Papers With Code API.
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., "@methods-mcp Extract methods and assess reproducibility for https://arxiv.org/abs/2509.06917"
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.
methods-mcp
Lightweight, on-demand MCP server for structured methods extraction + reproducibility heuristics on academic papers. Built for the Worldwide AI Science Fellowship build challenge.
⚠️ Status: alpha (0.1.x). The tool surface and output shapes may shift between minor versions. Pin to an exact version in production. Bug reports very welcome via GitHub Issues.
Quick demo
$ uvx --from methods-mcp methods-mcp --version
methods-mcp 0.1.6
# In a Claude Code session:
> /mcp add methods-mcp methods-mcp
> Run methods_repro_review on https://arxiv.org/abs/2509.06917
→ tool: methods_repro_review({"input_str":"https://arxiv.org/abs/2509.06917"})
# Returns a MethodsReproReview object. Read `narrative` first — it explains
# everything else in plain English, so no tool-learning is required:
{
"status": "ok",
"narrative":
"Resolved the paper: 'Paper2Agent' by Miao et al. (arxiv 2509.06917, "
"2025-09-08). Extracted 11 methods steps at moderate self-reported "
"confidence (0.72) — the procedure is clearly described but hyperparameters "
"and software versions are absent. Detected the associated code repository "
"https://github.com/jmiao24/Paper2Agent from an inline link in the paper "
"text (detection confidence 0.94). The repo scored 0.90/1.00 on the "
"reproducibility heuristic — verdict: likely reproducible. Present signals: "
"substantive README, dependencies file, notebooks, figure-plotting script, "
"recent activity, permissive license. Missing: data/fixtures directory. "
"Suggested entrypoint: `python make_figures.py`.",
"metadata": { ... }, # PaperMetadata
"methods": { ... }, # MethodsStructured (null if extraction failed)
"code_repo": { ... }, # CodeRepo (null only if input unresolvable)
"repro_assessment": { ... }, # ReproAssessment (null if no repo detected)
"errors": [] # [{step, error_type, message, hint}] on partial
}methods-mcp is a small, sharply-scoped Model Context Protocol server. It gives any AI agent (Claude Code, Claude Desktop, your Agent SDK script, etc.) eight tools that turn an academic paper URL into:
canonical metadata,
best-effort full text + section split,
a Pydantic-validated structured methods object (steps / reagents / equipment / analyses),
the paper's associated code repository (best-effort discovery),
a no-execution-required reproducibility verdict for that repo, and
a multi-mode summary.
The wedge: heavyweight pipelines like Paper2Agent (Stanford) take 30 minutes to hours to digest a paper into agent-ready tools. methods-mcp is the agent-callable, on-demand complement — every tool returns in seconds, no clone, no execution.
Related MCP server: trove-mcp
Install
uv add methods-mcp
# or, install globally:
uv tool install methods-mcp
# or, classic pip:
pip install methods-mcpAPI keys
For best performance, set both:
Variable | Required? | What you get without it |
| Required for | Those tools raise |
| Optional but recommended for | You're capped at the GitHub unauthenticated rate limit (60 req/hr per IP). Each repo assessment is ~3 calls, so you'll hit the ceiling after ~15–20 repos/hr. With a token: 5,000 req/hr (effectively unlimited). |
export ANTHROPIC_API_KEY=sk-ant-...
export GITHUB_TOKEN=ghp_... # optional but recommendedNeither key is logged or persisted — they're sent only to api.anthropic.com and api.github.com respectively. See SECURITY.md.
Use it from Claude Code
/mcp add methods-mcp methods-mcpThen in any Claude Code chat:
Take https://arxiv.org/abs/2509.06917 and run
methods_repro_review. Summarise what the paper does, the methods steps, and how reproducible the repo looks.
Use it from the Claude Agent SDK
from claude_agent_sdk import ClaudeAgentOptions, ClaudeSDKClient
options = ClaudeAgentOptions(
mcp_servers={
"methods-mcp": {
"type": "stdio",
"command": "methods-mcp",
"args": [],
}
},
allowed_tools=["mcp__methods-mcp__methods_repro_review"],
)
async with ClaudeSDKClient(options=options) as client:
await client.query(
"Run methods_repro_review on https://arxiv.org/abs/2509.06917 "
"and tell me whether the repo looks reproducible."
)
async for msg in client.receive_response():
print(msg)Tools
Tool | What it does |
| Server liveness + config check. |
| Resolve URL / arXiv ID / DOI to canonical metadata. arXiv inputs hit the arXiv export API for title/authors/abstract. |
| Full text + section split. Defaults to ar5iv HTML for arXiv papers (cheap, structured), PDF fallback otherwise. |
| LLM-driven, Pydantic-validated structured methods extraction. Returns |
| Discover the paper's code repo via paper text → abstract → Papers With Code. |
| Heuristic, no-clone reproducibility assessment via the GitHub REST API. Weighted signals (README, deps, fixtures, notebooks, figure scripts, recent maintenance, license) → |
| LLM summary in three depths. |
| Composite — metadata + methods + repo + repro in one call. |
All tools return Pydantic v2 models (validated, JSON-serialisable). See src/methods_mcp/schemas.py for the full type surface.
Design notes
extract_methodsuses Anthropic tool-use to coerce the model into emitting an instance of theMethodsStructuredPydantic schema. On validation failure we send one repair message with the validation error and try again before raising.assess_repo_reproducibilitydoes not clone or execute anything. It scores the repo from publicly-readable GitHub metadata + the recursive tree listing. This is the deliberate wedge against batch tools that try to actually rerun the paper.fetch_paper_textprefers ar5iv HTML over PDF parsing for arXiv papers. Falls back topypdffor non-arXiv inputs.The default model is
claude-sonnet-4-6. Override viaMETHODS_MCP_MODELenv var or per-callmodel=arg.methods_repro_reviewreturns a self-describing response. Every call sets a top-levelstatus("ok"/"partial"/"empty") and anarrativestring that summarises everything retrieved in plain English — including every numeric score in context. A reader who reads onlynarrative+statusgets the full picture without needing to learn the sub-object shapes. Sub-objects can benullwhen unavailable (e.g.repro_assessment: nullon a paper with no detected repo —statusstays"ok"because "no repo" isn't a failure). Failed sub-steps contribute a structured entry toerrorswith{step, error_type, message, hint}, wherehintis an actionable plain-English suggestion for recognised patterns (missing API keys, rate-limits, 404s, timeouts, etc.) andnullotherwise.
Scores & verdicts explained
Tool outputs contain three numeric fields that look similar but mean very different things. They are triage signals for an agent deciding whether a paper is worth digging into, not calibrated claims about correctness.
Field | Range | How it's computed | How to read it |
| 0–1 | LLM self-report. The extractor model sets it per instructions in the system prompt: | Soft signal for "is this a wet-lab paper with concrete procedure, or a sparse systems paper?" Useful as a flag; don't treat as a trust percentage. |
| 0–1 | Varies by | Tells you how the repo was found and how decisively. High score + |
| 0–1 | Weighted sum of 8 binary signals, all computed from the GitHub REST API (no clone, no execution): | The only fully-deterministic score of the three. Still a heuristic, not a proof — a high score means the repo looks well-structured for reproduction. For actual validation see Paper2Agent. |
Verdict buckets (repro_assessment.verdict) are thresholds on overall_score:
Verdict | Score | Meaning |
| ≥ 0.70 | Most repro-friendly signals present. Worth trying to run. |
| ≥ 0.45 | Some infrastructure, likely gaps. Expect to fill in missing pieces. |
| ≥ 0.20 | Minimal signal. Possible code dump without the scaffolding to rerun it. |
| < 0.20 or repo unreachable | Not enough to tell. Don't draw conclusions either way. |
Enum values you'll see in outputs:
code_repo.detection_method:paper-text|abstract-link|papers-with-code|metadata|nonemetadata.source:arxiv|biorxiv|doi|url|unknown
Security & limitations
What this server actually does when you install and run it:
Network calls only to:
export.arxiv.org,ar5iv.labs.arxiv.org,arxiv.org(PDFs),api.github.com,paperswithcode.com,api.anthropic.com. No telemetry, no analytics, no phone-home.Reads
ANTHROPIC_API_KEY(required for LLM tools) and optionallyGITHUB_TOKENfrom environment variables. These are sent only to Anthropic / GitHub respectively. Never logged, never persisted to disk.Writes nothing to your filesystem. No cache directories, no downloaded PDFs, no temp files.
Executes no user-supplied code. No
eval,exec,subprocess,pickle.loads, or shell-outs. The reproducibility tool deliberately does not clone or run repositories — it scores from the GitHub REST API only.
Limitations to be aware of:
Adversarial papers may produce misleading structured output. The
extract_methodstool sends paper text to Claude. A paper containing prompt-injection content could yield wrong (but schema-valid) structured methods. Treat the output as a research aid, not ground truth.The reproducibility verdict is a heuristic, not a proof. A high score means the repo looks well-structured for reproduction; it does not guarantee that running the code reproduces the paper. For full validation see Paper2Agent.
Intended for local stdio use. The HTTP/SSE transports are provided for development convenience but should only be exposed on trusted networks (no SSRF protection beyond what httpx provides).
Reporting issues:
Security issues: please email flynnlachendro@hotmail.co.uk (also see SECURITY.md). Functional bugs: open a GitHub issue.
Pair with paper-mcp
For broader paper search / citation graph tooling, run paper-mcp (Bhvaik) alongside in the same Claude Code session. paper-mcp does title-keyed search, full-text fetch, citations, and references; methods-mcp adds the structured-methods + reproducibility layer on top. The two were intentionally designed to compose.
Develop locally
git clone https://github.com/FlynnLachendro/methods-mcp
cd methods-mcp
uv sync --extra dev --extra agent
uv run pytest # 49 tests, offline (respx-mocked httpx + unittest.mock for Anthropic)
uv run ruff format .
uv run ruff check . --fix
uv run mypy src
uv run methods-mcp --helpLicense
MIT — see LICENSE.
Acknowledgements
Built for the Worldwide AI Science Fellowship inaugural cohort. Thanks to Michael Raspuzzi for the open-ended brief.
Built on:
FastMCP 3.x — the MCP server scaffold.
Claude Agent SDK — the agent loop in the demo.
ar5iv.labs.arxiv.org — clean HTML for arXiv papers.
Anthropic Claude — the LLM behind structured extraction.
Available Tools
8 toolsassess_repo_reproducibilityA
Heuristic, no-clone reproducibility assessment of a GitHub repo.
Returns a verdict (likely-reproducible / partial / unlikely / insufficient-info) plus weighted signals: README quality, dependency files, fixture data, notebooks, figure-generating scripts, recent maintenance, license. No code is downloaded or executed. Set GITHUB_TOKEN to raise the API rate limit.
Inputs: repo_url (required), paper_id. Returns: Heuristic, no-execution-required reproducibility assessment of a code repo.
extract_methodsA
Extract a structured methods object from a paper.
Pulls full text, isolates the methods-relevant section(s), then asks Claude (default: claude-sonnet-4-6) to fill out a Pydantic schema with steps, reagents, equipment, and analyses. Validation-enforced — invalid responses trigger one repair attempt before raising.
Requires ANTHROPIC_API_KEY in the server's environment.
Inputs: input_str (required), model. Returns: LLM-extracted, schema-validated methods section.
fetch_paper_textB
Return best-effort full text + section split for a paper.
prefer: one of "auto" (default), "html" (force ar5iv HTML — arXiv only), or "pdf". Sections are normalised to lowercase canonical names: abstract, introduction, methods, experiments, results, discussion, conclusion, limitations, related_work.
Inputs: input_str (required), prefer. Returns: Best-effort full text of a paper, optionally segmented by section.
find_code_repoA
Discover the code repo (if any) associated with a paper.
Strategy: scan the paper's full text and abstract for github.com URLs; fall back to Papers With Code lookup for arXiv papers.
Inputs: input_str (required). Returns: Detected code repository associated with a paper, if any.
get_paper_metadataA
Resolve an arXiv ID/URL, bioRxiv URL, DOI, or generic URL to canonical metadata.
For arXiv inputs this hits the arXiv export API to fetch title/authors/abstract. Other sources return the resolved URL with empty bibliographic fields (cheap by design).
Inputs: input_str (required). Returns: Canonical identifier + minimal bibliographic record for a paper.
healthA
Return a small health report — confirms the server is alive and configured.
Inputs: no named parameters. Returns: server, version, transports, anthropic_configured
methods_repro_reviewA
Resolve a paper + extract methods + find its code repo + assess reproducibility — in one call.
Returns a MethodsReproReview object. Read narrative first — it's a
plain-English summary of everything retrieved, with every numeric score
echoed in context (e.g. "moderate confidence (0.72)"). Then:
status:"ok"(all sub-steps succeeded),"partial"(some failed — seeerrors), or"empty"(couldn't even resolve the input paper).metadata,methods,code_repo,repro_assessment: the structured sub-results. Any step that failed contributesnullfor its key;nullmeans unavailable, not zero.errors: list of{step, error_type, message, hint}— one entry per failed sub-step, with an actionable hint where the failure pattern is recognised (e.g. missing ANTHROPIC_API_KEY, rate-limit, 404, timeout).
For the meaning of numeric scores and verdict buckets, see the "Scores & verdicts explained" section of the README.
Inputs: input_str (required), model. Returns: Structured response from the `methods_repro_review` composite tool. `narrative`…
summarize_paperA
Generate an LLM summary of a paper in one of three modes.
abstract = 2-3 sentences close to the authors' framing. tldr = one-line takeaway. exec = executive summary (what / found / why-it-matters).
Inputs: input_str (required), mode, model. Returns: mode, summary, paper_id, key_findings, +2 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Each tool has a clearly distinct purpose: health check, metadata resolution, text fetching, methods extraction, code repo discovery, reproducibility assessment, summarization, and a combined orchestration tool. The composite tool is explicitly described as a one-call pipeline, so no confusion with individual steps.
Most tools follow a verb_noun pattern (get, fetch, extract, find, assess, summarize), but 'health' is a bare noun and 'methods_repro_review' is a noun phrase without a verb. These deviations break the otherwise consistent snake_case convention.
8 tools is well within the ideal range, and each tool maps to a specific stage in the paper analysis pipeline. No redundancy or unnecessary duplication, and the count feels appropriately scoped for the server's reproducibility-focused purpose.
The tool surface covers the entire workflow from paper resolution to reproducibility assessment, including a composite endpoint. Minor gaps like search or fine-grained section access are absent but not essential to the stated domain, making the set largely complete.
Maintenance
Related MCP Connectors
Reliable PDF table extraction. Pass a URL, get structured JSON tables with citations.
Clean Markdown and AI-readability scoring for any URL. Built for AI agents.
Academic papers, reference verification and research data for AI agents.
Pages, crawls and URL batches as clean Markdown and JSON for AI agents, with an Evidence Record.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables discovery and analysis of research ecosystems by extracting metadata from paper URLs, GitHub repositories, and research names. Automatically finds related papers, code repositories, models, datasets, and authors across platforms like arXiv, HuggingFace, and GitHub.-
- AlicenseNot gradedqualityBmaintenanceEnables users to search and analyze academic papers from multiple sources, fetch metadata and full text, and build structured outputs like literature maps and paper comparisons.77 npmMIT
- FlicenseAqualityDmaintenanceEnables agents to search papers across Semantic Scholar and arXiv, read and extract text from arXiv PDFs, align records across sources, and produce structured literature-analysis digests.101-
- FlicenseNot gradedqualityCmaintenanceEnables AI agents to search and retrieve academic papers from arXiv and PubMed with citation-grade extraction, providing clean citations and summaries.-