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 "Install 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.
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.
$ 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: paperstack
uv add methods-mcp
# or, install globally:
uv tool install methods-mcp
# or, classic pip:
pip install methods-mcpFor 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.
/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.
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)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.
extract_methods uses Anthropic tool-use to coerce the model into emitting an instance of the MethodsStructured Pydantic schema. On validation failure we send one repair message with the validation error and try again before raising.
assess_repo_reproducibility does 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_text prefers ar5iv HTML over PDF parsing for arXiv papers. Falls back to pypdf for non-arXiv inputs.
The default model is claude-sonnet-4-6. Override via METHODS_MCP_MODEL env var or per-call model= arg.
methods_repro_review returns a self-describing response. Every call sets a top-level status ("ok" / "partial" / "empty") and a narrative string that summarises everything retrieved in plain English — including every numeric score in context. A reader who reads only narrative + status gets the full picture without needing to learn the sub-object shapes. Sub-objects can be null when unavailable (e.g. repro_assessment: null on a paper with no detected repo — status stays "ok" because "no repo" isn't a failure). Failed sub-steps contribute a structured entry to errors with {step, error_type, message, hint}, where hint is an actionable plain-English suggestion for recognised patterns (missing API keys, rate-limits, 404s, timeouts, etc.) and null otherwise.
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 | none
metadata.source: arxiv | biorxiv | doi | url | unknown
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 optionally GITHUB_TOKEN from 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_methods tool 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.
paper-mcpFor 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.
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 --helpMIT — see LICENSE.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| paper_id | No | ||
| repo_url | Yes |
| Name | Required | Description |
|---|---|---|
| notes | Yes | |
| signals | No | |
| verdict | Yes | |
| paper_id | No | |
| repo_url | Yes | |
| overall_score | Yes | |
| recommended_entrypoint | No | E.g. 'python make_figures.py' if a likely figure-generating script was found. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Annotations are entirely absent, so the description carries the full disclosure burden — and it meets it. It explicitly states the operation is non-destructive ('No code is downloaded or executed'), that this is a heuristic scoring exercise, that weighted signals feed the verdict, and even discloses the GitHub API rate-limit dependency plus the GITHUB_TOKEN mitigation. This is comprehensive behavior disclosure with no annotation support needed.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is tight and dense with zero filler: first sentence states purpose and mode, second summarizes the verdict taxonomy, third enumerates the signals, fourth discloses side-effect-free behavior, fifth gives the auth hint. Every sentence earns its place and the most decision-relevant facts (heuristic, no-clone) are front-loaded.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The overall assessment logic, safety profile, and auth requirement are well covered, and an output schema exists so the return structure doesn't need full restatement. However, completeness is undermined by the unexplained paper_id parameter and the lack of any guidance on when this tool applies versus methods_repro_review. For a moderately complex heuristic tool this is adequate but leaves discernible gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate — and largely fails to. repo_url's purpose is inferable from context but is never actually explained. paper_id (an accepted parameter, optional with null default) is completely unexplained: an agent cannot tell whether it links the assessment to a paper in the system, serves as a label, or affects scoring. No parameter receive explicit definitional help.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The opening line is specific: 'Heuristic, no-clone reproducibility assessment of a GitHub repo' — a clear verb (assess) plus a concrete resource (GitHub repo reproducibility), with the heuristic/no-clone qualifiers delimiting its scope. It states the return verdicts and the signal dimensions, so an agent understands what this produces. It doesn't explicitly distinguish itself from the closest sibling, methods_repro_review, but the 'no-clone' and 'heuristic vs deep review' framing sufficiently separates it.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description never states when to choose this tool over alternatives. It enumerates what it does — heuristic signals, no code execution — but gives no explicit 'use when you need a quick pass' or 'for a full methods review use methods_repro_review instead.' Given rich sibling context (methods_repro_review, find_code_repo, extract_methods), the absence of routing or exclusion guidance is a real gap.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | ||
| input_str | Yes |
| Name | Required | Description |
|---|---|---|
| notes | No | Free-form caveats from the extractor (e.g. 'methods section is sparse'). |
| steps | No | |
| summary | Yes | 2-3 sentence overview of the methods. |
| analyses | No | |
| paper_id | Yes | |
| reagents | No | |
| equipment | No | |
| confidence | Yes | LLM self-reported confidence in the structured extraction. |
| extraction_model | Yes | Model identifier used for extraction. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
Since annotations are absent, the description carries the full burden and does substantial work: it discloses that the tool fetches full text, isolates methods sections, calls an external Claude model, validates against a Pydantic schema, performs one repair attempt, and requires ANTHROPIC_API_KEY. These are behavioral traits an agent needs to anticipate dependencies and side effects.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description front-loads the core purpose, then moves through process and prerequisites in three compact paragraphs. No filler or repetition of the tool name.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The description covers the pipeline, validation/repair behavior, and auth prerequisite, and an output schema exists so return semantics needn't be restated. However, it leaves the required input parameter semantically ambiguous, which is a meaningful gap for invoking the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0% and the description only partially compensates: it mentions the default model (claude-sonnet-4-6) but never defines the required input_str (e.g., paper ID vs plain text) or the effect of passing a custom model. An agent cannot confidently populate parameters from this definition alone.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
States a specific verb ('Extract') and resource ('structured methods object') plus source ('a paper'), and names output components (steps, reagents, equipment, analyses). It is clearly distinguishable from sibling tools like summarize_paper and fetch_paper_text.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description makes the general use case clear (extracting structured methods), but it never explicitly says when to prefer this over siblings such as fetch_paper_text or methods_repro_review, and it gives no exclusion criteria. Usage is implied from the purpose rather than explicitly guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| prefer | No | auto | |
| input_str | Yes |
| Name | Required | Description |
|---|---|---|
| text | Yes | |
| paper_id | Yes | |
| sections | No | Section name (lowercased) -> text. Empty if extraction couldn't segment. |
| char_count | Yes | |
| source_url | Yes | |
| extraction_method | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full behavioral burden. It discloses 'best-effort' semantics (implying possible partial/failed text retrieval), the arXiv-only constraint for the html preference, and the section normalization behavior. However, it does not disclose what happens when html is requested for non-arXiv papers (fallback behavior) or how failures surface to the caller.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
Roughly 60 words with the core purpose front-loaded in the first sentence. Each subsequent sentence explains the prefer values and the canonical section names without waste. It is appropriately tight, though slightly terse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
An output schema exists, so return values are partially covered there. The description discloses section-normalization output behavior. But the undefined 'input_str' format is a critical gap: an agent cannot reliably invoke the tool without knowing what identifier to pass. The failure/fallback semantics of 'best-effort' and non-arXiv html requests are also unspecified. For a 2-param tool at 0% schema coverage, the description needed to compensate and did not.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must define both parameters. 'prefer' is explained thoroughly (auto/html/pdf values, default, and the html constraint), but 'input_str' — the single required parameter — is never explained. An agent has no idea whether it expects an arXiv ID, DOI, or URL. This is the most critical parameter for calling the tool and is left undefined.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description opens with a specific verb+resource: 'Return best-effort full text + section split for a paper.' This clearly distinguishes it from siblings like get_paper_metadata (metadata only) and summarize_paper (summary), making it easy for an agent to know this tool retrieves the raw full text with section boundaries.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The purpose implicitly signals when to use this tool (need full text + sections, not metadata or analysis), but there is no explicit when-to-use or when-not-to-use guidance, and no alternative tools are named. The agent must infer the selection logic from the name and description alone.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| input_str | Yes |
| Name | Required | Description |
|---|---|---|
| notes | No | |
| paper_id | No | |
| repo_url | No | |
| confidence | Yes | |
| detection_method | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden. It discloses the algorithm: scanning for GitHub URLs and using a Papers With Code fallback. This is meaningful behavioral transparency beyond just 'finds a repo.' It also hints at a potential outcome ('if any'), implying it might not always find a repo. However, it does not mention limitations like other repo hosts or what happens when a paper is not on arXiv. Still, the strategy is a strong disclosure of internal behavior.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with zero fluff. The first sentence states the purpose clearly and the second provides the strategy. It is front-loaded with the core action, and every word contributes value. The structure is efficient and easy to parse.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool is relatively simple with one parameter and an output schema, so the return format is presumably covered by the output schema. However, the input parameter is not described, which is a critical gap. The description explains the method but leaves the agent unsure what to pass as input_str. Given the lack of annotations, the description must carry more weight, and this omission makes it incomplete.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The input schema has one required parameter, 'input_str', with no description and 0% schema description coverage. The description refers to 'a paper' but does not explain what input_str should contain (e.g., a paper ID, URL, or title). It does not clarify the expected format or how the tool will use it. The description fails to compensate for the lack of schema detail, leaving the agent uncertain about the parameter's meaning. This is a significant gap.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose: 'Discover the code repo (if any) associated with a paper.' It uses a specific verb ('discover') and resource ('code repo'), and the scope is clear. This distinguishes it from siblings like get_paper_metadata or assess_repo_reproducibility, which handle metadata or reproducibility assessment. The strategy also clarifies the exact function.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies when to use it: whenever you need to locate a paper's code repository. It provides a concrete strategy (scanning full text/abstract for GitHub URLs, falling back to Papers With Code for arXiv papers), which gives context on its operation. It does not explicitly exclude scenarios or name alternative tools, but the purpose is clear enough that an agent would know it is the right tool for finding code repos. Lacks explicit 'when not to use' guidance, so a 4 is appropriate.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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).
| Name | Required | Description | Default |
|---|---|---|---|
| input_str | Yes |
| Name | Required | Description |
|---|---|---|
| title | Yes | |
| venue | No | |
| source | Yes | |
| authors | No | |
| pdf_url | No | |
| abstract | No | |
| html_url | No | ar5iv HTML URL for arXiv papers. |
| paper_id | Yes | Canonical identifier (e.g. arXiv ID, DOI). |
| raw_input | Yes | The original URL/ID the caller supplied. |
| primary_url | Yes | |
| publication_date | No | ISO 8601 date when known. |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of behavioral disclosure. It reveals that arXiv inputs trigger an API call to fetch metadata, while others return a resolved URL with empty bibliographic fields (termed 'cheap by design'). However, it does not mention side effects, error conditions, or rate limits, and does not explicitly declare it as read-only. It adds useful context but is not fully transparent.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is two sentences with no fluff. The core purpose is front-loaded, followed by the key behavioral distinction for arXiv versus other sources. Every sentence earns its place, and it is appropriately concise for a tool with one parameter.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Given the tool's simplicity (one parameter, no annotations) and the existence of an output schema, the description covers essential behavior: resolving inputs and returning specific metadata for arXiv, while handling other sources efficiently. It could be more complete by mentioning error handling or URL format requirements, but these are minor gaps. Overall, it provides enough context for an agent to call the tool correctly.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does by explaining that input_str accepts arXiv IDs/URLs, bioRxiv URLs, DOIs, or generic URLs, adding meaning beyond the schema's simple 'string' type. It does not specify exact formats or validation rules, but the accepted types are clearly stated, which is sufficient for a single simple parameter.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description states a specific verb ('Resolve') and a clear resource ('arXiv ID/URL, bioRxiv URL, DOI, or generic URL') with a defined output ('canonical metadata'). It also differentiates behavior by input type, which helps distinguish it from sibling tools like fetch_paper_text that likely handle full text.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The intended use is implied by the purpose ('resolve... to canonical metadata'), but there is no explicit mention of when to use this tool versus alternatives or when not to use it. It does not compare with siblings or provide selection criteria, such as 'use fetch_paper_text for full text'. Guidance is only implicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Return a small health report — confirms the server is alive and configured.
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
| Name | Required | Description |
|---|---|---|
| server | No | |
| version | Yes | |
| transports | Yes | |
| anthropic_configured | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden. It discloses that the tool returns a report and indicates a read-only behavior ('confirms' and 'report'). It does not mention side effects or permissions, but for a health check, these are arguably non-issues. The description goes beyond trivial naming by explaining the report's content.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is one concise, front-loaded sentence that states the action and its purpose without any fluff. Every word contributes value. It is appropriately sized for a tool this trivial.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
For a zero-parameter tool with an output schema present, the description is fully sufficient. It tells the agent what the tool returns and what it confirms. No additional details (e.g., exact format) are needed because the output schema handles that. The description is complete for its purpose.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
The tool has zero parameters, so the schema fully covers parameter semantics (coverage is 100%). The baseline for 0-parameter tools is 4, and the description adds no unnecessary parameter information. It correctly focuses on the output and purpose.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description uses a specific verb ('Return') and resource ('health report') and specifies the purpose: 'confirms the server is alive and configured.' This clearly distinguishes it from the sibling tools, all of which are paper-related and involve data retrieval or analysis.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is for checking server status but does not explicitly state when to use it versus alternatives or provide exclusions. There is no mention of 'use this when...' or 'instead of...'. Given the simplicity and obvious distinctiveness from paper-processing siblings, the implicit context is acceptable but not explicitly stated.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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 — see
errors), or "empty" (couldn't even resolve the input paper).
metadata, methods, code_repo, repro_assessment: the structured
sub-results. Any step that failed contributes null for its key;
null means 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.
| Name | Required | Description | Default |
|---|---|---|---|
| model | No | ||
| input_str | Yes |
| Name | Required | Description |
|---|---|---|
| errors | No | |
| status | Yes | Top-level status of a composite-tool call. `ok` — every sub-step succeeded. `partial` — at least one sub-step failed (see `errors`) but we have usable results. `empty` — we couldn't even resolve the paper input; no sub-steps ran. |
| methods | No | |
| metadata | No | |
| code_repo | No | |
| narrative | Yes | |
| repro_assessment | No |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations provided, the description carries the full burden of disclosing behavior, and it does so well. It explains the possible status values (ok/partial/empty), the semantics of null keys (unavailable, not zero), and the structure of errors including hints. It also tells the agent to read 'narrative' first and mentions failure patterns like missing ANTHROPIC_API_KEY, rate-limit, and timeouts. It does not explicitly state read-only semantics or potential side effects, but the error hints imply network calls; overall it is transparent for a composite read tool.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is reasonably concise for the complexity, with the core purpose front-loaded in the first sentence and the return structure laid out in a clear bullet list. It avoids redundancy and uses formatting to separate fields. It references the README for score meanings, which is a minor downside but acceptable given the length. Overall, it is well-structured and not bloated.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
Despite the complexity (composite of four steps), the description omits critical details needed to call the tool: the input format for input_str and the meaning of model. It also defers score/verdict details to the README, which is a gap because the agent receives no inline explanation. With no annotations and no parameter descriptions, the description is not self-sufficient for correct invocation, leaving the agent with unanswered questions about required inputs.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must explain both parameters. It only hints that input_str is a paper identifier ('Resolve a paper') but never specifies the format (DOI, arXiv ID, URL, or free text). The model parameter is completely unmentioned, leaving the agent clueless about its purpose or allowed values. This is a significant gap that forces the agent to guess or consult external docs.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states a specific verb and resource: it resolves a paper, extracts methods, finds a code repo, and assesses reproducibility in one call. It enumerates the sub-steps explicitly, which distinguishes it from the single-purpose sibling tools (e.g., extract_methods, find_code_repo) and makes its combined scope immediately obvious. The phrase 'in one call' reinforces its composite nature.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description implies the tool is a convenience for getting all four results at once, but it does not explicitly state when to use it versus calling individual siblings, nor does it mention any exclusions or prerequisites. It says 'in one call' but does not say 'use this when you need all steps' or 'if you only need X, use Y'. This leaves the agent to infer the use case without explicit routing guidance.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
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).
| Name | Required | Description | Default |
|---|---|---|---|
| mode | No | tldr | |
| model | No | ||
| input_str | Yes |
| Name | Required | Description |
|---|---|---|
| mode | Yes | |
| summary | Yes | |
| paper_id | Yes | |
| key_findings | No | |
| extraction_model | Yes | |
| methodology_oneliner | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
With no annotations, the description carries the full burden of behavioral disclosure. It reveals that summaries are LLM-generated and specifies the output format for each mode, which is useful. However, it does not mention read-only status, side effects, required permissions, or any potential costs or delays. This is a moderate level of transparency.
Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.
Is the description appropriately sized, front-loaded, and free of redundancy?
The description is exceptionally concise and well-structured. It opens with a clear purpose sentence, then lists each mode with its output specification using a bullet-like format. Every sentence contributes value with no redundancy.
Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.
Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?
The tool appears simple (3 params, 1 required), and the description explains the output for each mode. However, the required parameter 'input_str' is not defined, and the 'model' parameter is left unexplained. No mention of error handling or typical usage scenarios. The description is adequate for a simple tool but has noticeable gaps.
Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.
Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?
Schema description coverage is 0%, so the description must compensate. It does explain the 'mode' enum values thoroughly, adding meaning beyond the schema. However, it does not clarify 'input_str' (presumably the paper text) or 'model' (which model to use). This partial compensation earns a middle score.
Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.
Does the description clearly state what the tool does and how it differs from similar tools?
The description clearly states the tool's purpose with a specific verb ('Generate') and resource ('a paper'), and defines three distinct modes of output. This distinguishes it from sibling tools like extract_methods or fetch_paper_text, which have different functions. The mode definitions add precision.
Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.
Does the description explain when to use this tool, when not to, or what alternatives exist?
The description explains the three mode options in detail, which helps an agent decide which mode to use. However, it does not explicitly state when to use this tool versus alternatives such as extract_methods or methods_repro_review. The usage context is implied by the name and purpose, but not explicitly guided.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.
v0.1.7assess_repo_reproducibilityextract_methodsfetch_paper_textfind_code_repoget_paper_metadatahealthmethods_repro_reviewsummarize_paperEach 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.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
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.
Extract structured data points from research papers and other documents with an LLM.
Research intelligence for AI coding agents. 2M+ CS papers with evidence and tradeoffs.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/FlynnLachendro/methods-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
