学術論文向けの構造化メソッド抽出と再現性ヒューリスティクスを提供する、軽量でオンデマンドなMCPサーバーです。Worldwide AI Science Fellowship ビルドチャレンジのために構築されました。
⚠️ ステータス: alpha (0.1.x)。 ツールの表面と出力形式はマイナーバージョン間で変更される可能性があります。本番環境では正確なバージョンに固定してください。バグ報告は 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 は、小さく明確にスコープされた Model Context Protocol サーバーです。任意のAIエージェント（Claude Code、Claude Desktop、Agent SDK スクリプトなど）に、学術論文のURLを次のものに変換する8つのツールを提供します：
正規メタデータ、
ベストエフォートの全文＋セクション分割、
Pydantic検証済みの構造化メソッドオブジェクト（手順 / 試薬 / 機器 / 解析）、
論文に関連するコードリポジトリ（ベストエフォートでの発見）、
そのリポジトリに対する実行不要の再現性判定、
マルチモードの要約。
切り口： Paper2Agent（Stanford）のような重量級パイプラインは、論文をエージェント対応ツールに変換するのに30分から数時間かかります。methods-mcp はエージェントから呼び出し可能なオンデマンドの補完です — すべてのツールが数秒で返り、クローンも実行も不要です。
Related MCP server: paperstack
uv add methods-mcp
# or, install globally:
uv tool install methods-mcp
# or, classic pip:
pip install methods-mcp最良のパフォーマンスを得るには、両方を設定してください：
変数 | 必須か？ | それが無い場合の影響 |
|
| これらのツールは |
|
| GitHubの未認証レート制限（IPあたり60リクエスト/時）に制限されます。各リポジトリ評価は約3回の呼び出しなので、1時間あたり約15〜20リポジトリで上限に達します。トークンを使用すると：5,000リクエスト/時（実質無制限）。 |
export ANTHROPIC_API_KEY=sk-ant-...
export GITHUB_TOKEN=ghp_... # optional but recommendedどちらのキーもログ記録や永続化はされません — それぞれ api.anthropic.com と api.github.com にのみ送信されます。SECURITY.md を参照してください。
/mcp add methods-mcp methods-mcpその後、任意の Claude Code チャットで：
https://arxiv.org/abs/2509.06917 を取得して
methods_repro_reviewを実行してください。論文の内容、メソッドの手順、リポジトリの再現性の見え方を要約してください。
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)ツール | 機能 |
| サーバーの死活監視と設定チェック。 |
| URL / arXiv ID / DOI を正規メタデータに解決します。arXiv 入力は arXiv エクスポート API にアクセスしてタイトル/著者/要旨を取得します。 |
| 全文とセクション分割。arXiv 論文ではデフォルトで ar5iv HTML（安価で構造化）を使用し、それ以外では PDF にフォールバックします。 |
| LLM駆動、Pydantic検証済みの構造化メソッド抽出。 |
| 論文テキスト → 要旨 → Papers With Code を経由して論文のコードリポジトリを発見します。 |
| GitHub REST API によるヒューリスティックでクローン不要の再現性評価。重み付けされたシグナル（README、依存関係、フィクスチャ、ノートブック、図スクリプト、最近のメンテナンス、ライセンス）→ |
| 3段階の深さのLLM要約。 |
| 複合 — メタデータ + メソッド + リポジトリ + 再現性を1回の呼び出しで。 |
すべてのツールは Pydantic v2 モデル（検証済み、JSONシリアライズ可能）を返します。完全な型の表面については src/methods_mcp/schemas.py を参照してください。
extract_methods は Anthropic のツール使用を利用して、モデルに MethodsStructured Pydantic スキーマのインスタンスを出力させます。 検証失敗時には、検証エラーを含む修復メッセージを1回送信し、再試行してから例外を発生させます。
assess_repo_reproducibility はクローンも実行も行いません。 公開されている GitHub メタデータと再帰的なツリー一覧からリポジトリをスコアリングします。これは、実際に論文を再実行しようとするバッチツールに対する意図的な切り口です。
fetch_paper_text は arXiv 論文では PDF 解析よりも ar5iv HTML を優先します。 arXiv 以外の入力では pypdf にフォールバックします。
デフォルトモデルは claude-sonnet-4-6 です。 METHODS_MCP_MODEL 環境変数または呼び出しごとの model= 引数で上書きできます。
methods_repro_review は自己記述的なレスポンスを返します。 すべての呼び出しで、トップレベルの status（"ok" / "partial" / "empty"）と、取得したすべての情報を平易な英語で要約した narrative 文字列が設定されます — すべての数値スコアを文脈付きで含みます。narrative と status だけを読む読者は、サブオブジェクトの形状を学ぶことなく全体像を把握できます。サブオブジェクトは利用できない場合 null になります（例：リポジトリが検出されない論文では repro_assessment: null — 「リポジトリなし」は失敗ではないため status は "ok" のまま）。失敗したサブステップは errors に {step, error_type, message, hint} の構造化エントリとして追加されます。hint は、認識されたパターン（APIキー不足、レート制限、404、タイムアウトなど）に対する実行可能な平易な英語の提案であり、それ以外の場合は null です。
ツールの出力には、似ているが意味が大きく異なる3つの数値フィールドが含まれています。これらは、論文を掘り下げる価値があるかどうかを判断するエージェントのためのトリアージシグナルであり、正確性に関する校正された主張ではありません。
フィールド | 範囲 | 計算方法 | 読み方 |
| 0–1 | LLM自己申告。 抽出モデルはシステムプロンプトの指示に従って設定します：論文が明示的な試薬/容量/機器を提供する場合のみ | 「具体的な手順を持つウェットラボ論文か、疎らなシステム論文か？」 のソフトシグナル。フラグとして有用ですが、信頼度のパーセンテージとして扱わないでください。 |
| 0–1 |
| リポジトリがどのように見つかったか、そしてどれだけ決定的かを示します。高スコア＋ |
| 0–1 | 8つのバイナリシグナルの重み付き合計。すべて GitHub REST API から計算されます（クローンも実行もなし）： | 3つのうち唯一完全に決定的なスコア。それでもヒューリスティックであり、証明ではありません — 高スコアはリポジトリが再現用によく構造化されているように見えることを意味します。実際の検証については Paper2Agent を参照してください。 |
判定バケット（repro_assessment.verdict）は overall_score のしきい値です：
判定 | スコア | 意味 |
| ≥ 0.70 | 再現に有利なシグナルがほとんど揃っている。実行を試みる価値あり。 |
| ≥ 0.45 | インフラは一部あるが、ギャップがある可能性。不足部分の補完を想定すること。 |
| ≥ 0.20 | シグナルは最小限。再実行のための足場がないコードの置き場の可能性。 |
| < 0.20 または リポジトリに到達不可 | 判断するには不十分。どちらの結論も下さないこと。 |
出力で見られる列挙値:
code_repo.detection_method: paper-text | abstract-link | papers-with-code | metadata | none
metadata.source: arxiv | biorxiv | doi | url | unknown
このサーバーがインストールして実行したときに実際に行うこと:
ネットワーク呼び出し先は以下のみ: export.arxiv.org、ar5iv.labs.arxiv.org、arxiv.org（PDF）、api.github.com、paperswithcode.com、api.anthropic.com。テレメトリなし、アナリティクスなし、ホームへの通信なし。
読み取り: 環境変数から ANTHROPIC_API_KEY（LLMツールに必須）と、オプションで GITHUB_TOKEN。これらはそれぞれ Anthropic / GitHub にのみ送信される。ログに記録されることも、ディスクに永続化されることもない。
書き込み: ファイルシステムへの書き込みは一切なし。キャッシュディレクトリも、ダウンロードしたPDFも、一時ファイルもなし。
実行: ユーザーが提供したコードは一切実行しない。eval、exec、subprocess、pickle.loads、シェルアウトはなし。再現性ツールは意図的にリポジトリのクローンや実行を行わず、GitHub REST API からのみスコアリングする。
注意すべき制限事項:
敵対的な論文は誤解を招く構造化出力を生む可能性がある。 extract_methods ツールは論文テキストを Claude に送信する。プロンプトインジェクションを含む論文は、誤った（しかしスキーマ的には有効な）構造化メソッドを生む可能性がある。出力は研究支援として扱い、絶対的な真実とはみなさないこと。
再現性の判定はヒューリスティックであり、証明ではない。 スコアが高いということは、リポジトリが再現用によく構造化されているように見えるという意味であり、コードを実行すれば論文が再現されることを保証するものではない。完全な検証については Paper2Agent を参照。
ローカルの stdio 利用を想定。 HTTP/SSE トランスポートは開発の便宜のために提供されているが、信頼できるネットワーク上でのみ公開すべきである（httpx が提供する以上の SSRF 保護はない）。
問題の報告:
セキュリティ問題: flynnlachendro@hotmail.co.uk までメールで連絡のこと（SECURITY.md も参照）。機能バグ: GitHub issue を開くこと。
paper-mcp との併用より広範な論文検索・引用グラフツールについては、同じ Claude Code セッション内で paper-mcp (Bhvaik) を併用して実行する。paper-mcp はタイトルキー検索、全文取得、引用、参考文献を扱い、methods-mcp はその上に構造化メソッド＋再現性レイヤーを追加する。この2つは意図的に組み合わせて使えるように設計されている。
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 — LICENSE を参照。
Worldwide AI Science Fellowship の初回コホートのために構築。Michael Raspuzzi 氏の自由なブリーフィングに感謝。
以下を基に構築:
FastMCP 3.x — MCP サーバーのスキャフォールド。
Claude Agent SDK — デモ内のエージェントループ。
ar5iv.labs.arxiv.org — arXiv 論文のクリーンな HTML。
Anthropic Claude — 構造化抽出の背後にある LLM。
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.
