Leichtgewichtiger, bedarfsorientierter MCP-Server für strukturierte Methodenextraktion + Reproduzierbarkeits-Heuristiken bei wissenschaftlichen Arbeiten. Gebaut für die Worldwide AI Science Fellowship Build Challenge.
⚠️ Status: Alpha (0.1.x). Die Tool-Oberfläche und die Ausgabeformen können sich zwischen Minor-Versionen ändern. In Produktion auf eine exakte Version pinnen. Bug-Meldungen sind über GitHub Issues sehr willkommen.
$ 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 ist ein kleiner, klar abgegrenzter Model Context Protocol-Server. Er gibt jedem KI-Agenten (Claude Code, Claude Desktop, dein Agent-SDK-Skript usw.) acht Tools, die eine URL einer wissenschaftlichen Arbeit in Folgendes verwandeln:
kanonische Metadaten,
Volltext mit bestmöglicher Qualität + Abschnittsaufteilung,
ein Pydantic-validiertes, strukturiertes Methodenobjekt (Schritte / Reagenzien / Ausrüstung / Analysen),
das zugehörige Code-Repository der Arbeit (bestmögliche Erkennung),
ein ohne Ausführung auskommendes Reproduzierbarkeits-Urteil für dieses Repository, und
eine Zusammenfassung in mehreren Modi.
Der Hebel: Schwergewichtige Pipelines wie Paper2Agent (Stanford) brauchen 30 Minuten bis Stunden, um eine Arbeit in agentenbereite Tools zu verdauen. methods-mcp ist die agentenaufrufbare, bedarfsorientierte Ergänzung — jedes Tool liefert in Sekunden Ergebnisse, ohne Klonen, ohne Ausführung.
Related MCP server: paperstack
uv add methods-mcp
# or, install globally:
uv tool install methods-mcp
# or, classic pip:
pip install methods-mcpFür beste Leistung beide setzen:
Variable | Erforderlich? | Was du ohne sie bekommst |
| Erforderlich für | Diese Tools werfen |
| Optional, aber empfohlen für | Du bist auf das GitHub-Ratenlimit ohne Authentifizierung begrenzt (60 Anfragen/Std. pro IP). Jede Repository-Bewertung benötigt ~3 Aufrufe, du erreichst die Grenze also nach ~15–20 Repos/Std. Mit Token: 5.000 Anfragen/Std. (praktisch unbegrenzt). |
export ANTHROPIC_API_KEY=sk-ant-...
export GITHUB_TOKEN=ghp_... # optional but recommendedKeiner der Schlüssel wird protokolliert oder gespeichert — sie werden nur an api.anthropic.com bzw. api.github.com gesendet. Siehe SECURITY.md.
/mcp add methods-mcp methods-mcpDann in einem beliebigen Claude-Code-Chat:
Nimm https://arxiv.org/abs/2509.06917 und führe
methods_repro_reviewaus. Fasse zusammen, was die Arbeit tut, die Methodenschritte und wie reproduzierbar das Repository aussieht.
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 | Was es tut |
| Server-Liveness + Konfigurationsprüfung. |
| URL / arXiv-ID / DOI zu kanonischen Metadaten auflösen. arXiv-Eingaben nutzen die arXiv-Export-API für Titel/Autoren/Abstract. |
| Volltext + Abschnittsaufteilung. Standardmäßig ar5iv-HTML für arXiv-Arbeiten (günstig, strukturiert), sonst PDF-Fallback. |
| LLM-gesteuerte, Pydantic-validierte strukturierte Methodenextraktion. Gibt |
| Das Code-Repository der Arbeit finden über Arbeitstext → Abstract → Papers With Code. |
| Heuristische, klonfreie Reproduzierbarkeitsbewertung über die GitHub-REST-API. Gewichtete Signale (README, Abhängigkeiten, Fixtures, Notebooks, Figuren-Skripte, aktuelle Wartung, Lizenz) → |
| LLM-Zusammenfassung in drei Tiefen. |
| Zusammengesetzt — Metadaten + Methoden + Repository + Reproduzierbarkeit in einem Aufruf. |
Alle Tools geben Pydantic-v2-Modelle zurück (validiert, JSON-serialisierbar). Siehe src/methods_mcp/schemas.py für die vollständige Typschnittstelle.
extract_methods verwendet Anthropic-Tool-Use, um das Modell dazu zu bringen, eine Instanz des MethodsStructured-Pydantic-Schemas auszugeben. Bei Validierungsfehlern senden wir eine Reparaturnachricht mit dem Validierungsfehler und versuchen es erneut, bevor wir eine Ausnahme auslösen.
assess_repo_reproducibility klont oder führt nichts aus. Es bewertet das Repository anhand öffentlich lesbarer GitHub-Metadaten + der rekursiven Baumauflistung. Das ist der bewusste Hebel gegen Batch-Tools, die versuchen, die Arbeit tatsächlich erneut auszuführen.
fetch_paper_text bevorzugt ar5iv-HTML gegenüber PDF-Parsing für arXiv-Arbeiten. Fällt für Nicht-arXiv-Eingaben auf pypdf zurück.
Das Standardmodell ist claude-sonnet-4-6. Überschreibbar über die Umgebungsvariable METHODS_MCP_MODEL oder das model=-Argument pro Aufruf.
methods_repro_review gibt eine selbstbeschreibende Antwort zurück. Jeder Aufruf setzt einen status auf oberster Ebene ("ok" / "partial" / "empty") und einen narrative-String, der alles Abgerufene in einfachem Englisch zusammenfasst — einschließlich jedes numerischen Scores im Kontext. Ein Leser, der nur narrative + status liest, erhält das vollständige Bild, ohne die Formen der Unterobjekte lernen zu müssen. Unterobjekte können null sein, wenn nicht verfügbar (z. B. repro_assessment: null bei einer Arbeit ohne erkanntes Repository — status bleibt "ok", weil „kein Repository“ kein Fehler ist). Fehlgeschlagene Teilschritte tragen einen strukturierten Eintrag zu errors bei mit {step, error_type, message, hint}, wobei hint ein umsetzbarer Vorschlag in einfachem Englisch für erkannte Muster ist (fehlende API-Schlüssel, Ratenlimits, 404s, Timeouts usw.) und sonst null.
Tool-Ausgaben enthalten drei numerische Felder, die ähnlich aussehen, aber sehr unterschiedliche Bedeutungen haben. Sie sind Triage-Signale für einen Agenten, der entscheidet, ob sich eine Arbeit lohnt, keine kalibrierten Aussagen über Korrektheit.
Feld | Bereich | Wie es berechnet wird | Wie man es liest |
| 0–1 | LLM-Selbstauskunft. Das Extraktionsmodell setzt es gemäß den Anweisungen im System-Prompt: | Weiches Signal für „Ist das eine Nasslabor-Arbeit mit konkretem Verfahren oder eine spärliche Systemarbeit?“ Als Flag nützlich; nicht als Vertrauensprozentsatz behandeln. |
| 0–1 | Variiert je nach | Sagt dir, wie das Repository gefunden wurde und wie eindeutig. Hoher Score + |
| 0–1 | Gewichtete Summe von 8 binären Signalen, alle aus der GitHub-REST-API berechnet (kein Klonen, keine Ausführung): | Der einzige vollständig deterministische Score der drei. Immer noch eine Heuristik, kein Beweis — ein hoher Score bedeutet, dass das Repository für die Reproduktion gut strukturiert aussieht. Für echte Validierung siehe Paper2Agent. |
Urteils-Kategorien (repro_assessment.verdict) sind Schwellenwerte auf overall_score:
| Urteil | Punktzahl | Bedeutung |
| likely-reproducible | ≥ 0.70 | Die meisten reproduktionsfreundlichen Signale sind vorhanden. Es lohnt sich, einen Versuch zu starten. |
| partial | ≥ 0.45 | Einige Infrastruktur vorhanden, wahrscheinlich Lücken. Erwarten Sie, fehlende Teile zu ergänzen. |
| unlikely | ≥ 0.20 | Minimale Signale. Möglicherweise ein Code-Dump ohne das Gerüst, um ihn erneut auszuführen. |
| insufficient-info | < 0.20 oder Repository nicht erreichbar | Nicht genug, um es zu beurteilen. Ziehen Sie keine Schlüsse in die eine oder andere Richtung. |
Enum-Werte, die Sie in den Ausgaben sehen werden:
code_repo.detection_method: paper-text | abstract-link | papers-with-code | metadata | none
metadata.source: arxiv | biorxiv | doi | url | unknown
Was dieser Server tatsächlich tut, wenn Sie ihn installieren und ausführen:
Netzwerkaufrufe nur an: export.arxiv.org, ar5iv.labs.arxiv.org, arxiv.org (PDFs), api.github.com, paperswithcode.com, api.anthropic.com. Keine Telemetrie, keine Analysen, kein Phone-Home.
Liest ANTHROPIC_API_KEY (erforderlich für LLM-Tools) und optional GITHUB_TOKEN aus Umgebungsvariablen. Diese werden nur an Anthropic bzw. GitHub gesendet. Nie protokolliert, nie auf der Festplatte gespeichert.
Schreibt nichts in Ihr Dateisystem. Keine Cache-Verzeichnisse, keine heruntergeladenen PDFs, keine temporären Dateien.
Führt keinen vom Benutzer bereitgestellten Code aus. Kein eval, exec, subprocess, pickle.loads oder Shell-Aufrufe. Das Reproduzierbarkeits-Tool klont oder führt bewusst keine Repositories aus – es bewertet nur über die GitHub-REST-API.
Einschränkungen, die Sie beachten sollten:
Adversariale Papiere können irreführende strukturierte Ausgaben erzeugen. Das extract_methods-Tool sendet den Papiertext an Claude. Ein Papier mit Prompt-Injection-Inhalten könnte falsche (aber schema-konforme) strukturierte Methoden liefern. Behandeln Sie die Ausgabe als Forschungshilfe, nicht als Grundwahrheit.
Das Reproduzierbarkeitsurteil ist eine Heuristik, kein Beweis. Ein hoher Wert bedeutet, dass das Repository gut strukturiert für die Reproduktion aussieht; es garantiert nicht, dass die Ausführung des Codes das Papier reproduziert. Für eine vollständige Validierung siehe Paper2Agent.
Für die lokale stdio-Nutzung gedacht. Die HTTP/SSE-Transports werden für die Entwicklung bereitgestellt, sollten aber nur in vertrauenswürdigen Netzwerken exponiert werden (kein SSRF-Schutz über das hinaus, was httpx bietet).
Probleme melden:
Sicherheitsprobleme: Bitte senden Sie eine E-Mail an flynnlachendro@hotmail.co.uk (siehe auch SECURITY.md). Funktionale Fehler: Eröffnen Sie ein GitHub-Issue.
paper-mcpFür eine breitere Papiersuche / Zitationsgraph-Tooling führen Sie paper-mcp (Bhvaik) in derselben Claude Code-Sitzung aus. paper-mcp bietet titelbasierte Suche, Volltextabruf, Zitationen und Referenzen; methods-mcp fügt die strukturierte Methoden- und Reproduzierbarkeitsebene hinzu. Die beiden wurden absichtlich so konzipiert, dass sie sich ergänzen.
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 — siehe LICENSE.
Entwickelt für die erste Kohorte des Worldwide AI Science Fellowship. Dank an Michael Raspuzzi für das offene Briefing.
Basierend auf:
FastMCP 3.x — das MCP-Server-Gerüst.
Claude Agent SDK — die Agentenschleife in der Demo.
ar5iv.labs.arxiv.org — sauberes HTML für arXiv-Papiere.
Anthropic Claude — das LLM hinter der strukturierten Extraktion.
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.
v0.1.7assess_repo_reproducibilityextract_methodsfetch_paper_textfind_code_repoget_paper_metadatahealthmethods_repro_reviewsummarize_paperScored 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.
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.
Extract structured data points from research papers and other documents with an LLM.
