Replication Radar
This MCP server turns the OpenAIRE Graph into a replication-aware discovery and verification tool for research claims.
radar(topic) — returns impact-ranked, high-impact papers in a field as replication targets, each flagged OPEN (opportunity) or VERIFIED (already replicated), with abstracts and independent reusable tooling.
find_independent_software(doi, topic) — finds reusable method software not authored by the original paper's team, ranked by repo/Software Heritage/downloads/GitHub stars (not citations).
replication_status(doi) — checks whether a DOI has been replicated and the verdict(s), pulled live from the nanopub network, including validation status, CiTO relation, repo, signed nanopub links, agreement pattern, and replicated claims.
verified_claims() — lists the entire verified-knowledge corpus: every claim the nanopub network holds a replication verdict for, with DOI, verdicts, and replication counts.
replication_template(doi, topic, owner, ...) — scaffolds a new replication using the FORRT template, suggests/checks GitHub repo names, and provides a quickstart command and handoff notes for the new repo.
find_dataset(topic) — hands off dataset discovery to the OpenAIRE MCP, giving instructions for finding and citing a citable dataset DOI.
Allows finding reusable method software hosted on GitHub for replicating research claims, filtered by author independence from the original paper, and ranked by reuse signals.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Replication Radar find replication targets in ecology"
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.
Replication Radar
🔗 Live demo → https://openaire-hackathon.netlify.app
▶ Watch the 3-min demo → https://youtu.be/hVyLafY3Y3E · reproduce it step by step → https://openaire-hackathon.netlify.app/demo.html
A tool that makes the OpenAIRE Graph more useful for replication. Search a research field and it answers the question the Graph structurally cannot: what high-impact work is worth replicating, has it already been independently checked — with what verdict — and is the software reusable?
Ships as a live web app (the link above — pure static, queries OpenAIRE + the nanopub network + GitHub/Software Heritage from the browser) and an MCP server (this package) that exposes the same engine to any agent. Built for the OpenAIRE AI Hackathon (Theme B), CC-BY.
OpenAIRE's only value signal is citation-popularity (BIP! influence / popularity / impulse, classes C1–C5) — paper-bound, and orthogonal to whether a claim is true. The Radar joins three sources to add a replication layer on top:
OpenAIRE Graph — impact-ranks candidate papers (
api.openaire.eu/graph/v1).Software Heritage + repo signals — surfaces reusable method software.
Science Live nanopub verdicts — the "already checked → did it hold" overlay.
OpenAIRE AI Hackathon · Theme B (Build) · CC-BY. Built to be reused through the forrt-replication-template: discovery at the start of a replication, where the template's existing skills handle the nanopub chain at the end.
Tools
Tool | What it answers |
| Impact-ranked replication targets in a field — each OPEN (opportunity) or VERIFIED (done, with verdict) + independent tooling + funder context |
| Reusable engines not authored by the original team (author-disjoint = replication, not reproduction), ranked by reuse signal — repo · Software Heritage · downloads · GitHub stars — not citations (returns |
| Has this DOI been replicated, did it hold? Verdict(s) — live from the nanopub network, any signer — with status, CiTO relation, repo, and signed Outcome/CiTO nanopub links; |
| The whole verified-knowledge corpus — every claim the network holds a verdict for (author-agnostic) |
| The FORRT replication template (the produce half) — the scaffold repo, the workflow, and a suggested |
| Hand-off to the OpenAIRE MCP for datasets — replication-radar doesn't search datasets; this says how to find a citable dataset DOI there |
The verdict tools pull live from the nanopub network (the FORRT Outcome/CiTO templates on
query.knowledgepixels.com); the bundled verdicts.json is an offline fallback. So the MCP is the
verified-knowledge layer — pair it with the OpenAIRE MCP and an agent has both the structural
Graph and "has this been checked, and did it hold".
The reproduction-vs-replication distinction, made computable
A reproduction re-runs the original code; a replication tests the same claim by a
different route. So the Radar filters tooling by author-disjointness from the
original paper — e.g. for Phillips et al. 2009, the dismo package (co-authored by
Phillips & Elith) is flagged rooted / non-independent, while biomod2 and jSDM
are independent. That filter is the difference between the two, and it's the thing
that makes this replication-aware rather than just "find the code".
Related MCP server: mcp-openalex
Run
pip install -e . # installs the `mcp` runtime
python -m replication_radar.server # stdio MCP serverAdd to an MCP client (.mcp.json):
{ "mcpServers": {
"replication-radar": { "command": "python", "args": ["-m", "replication_radar.server"] }
} }The core (OpenAIRE client + radar logic) is stdlib-only — try it without the MCP runtime:
PYTHONPATH=src python3 demo_sdm.py # live vertical-slice demo on SDMConfiguration
Env var | Default | Purpose |
|
| Swap to the Alien AI-Gateway or a mirror — the Radar is endpoint-agnostic |
|
| Per-request timeout (s) |
Known limits (v1, honest)
Keyword-bound discovery. OpenAIRE free-text terms are AND-ed; long queries return nothing. Use short topics. The VERIFIED overlay is guaranteed (resolved from the verdict index directly), but OPEN-target recall depends on the query.
No graph-relation traversal on the public API (paper→its software/data/grant edges aren't exposed): tooling/data are matched heuristically by topic + author independence, not by a hard relation. Upgrades cleanly if a gateway exposes relations.
Funder context is field-level, not per-paper (per-paper funder attribution is not reachable); budgets are frequently reported as 0 in records.
The verdict index ships 6 source works / 12 chains (Science Live). Extend
data/verdicts.jsonto grow coverage.
Available Tools
6 toolsfind_datasetA
Where to find a DATASET (with a citable DOI) to replicate with. The replication-radar MCP does NOT search datasets itself — that is the OpenAIRE MCP's job. Call this when the user asks the Radar to find data/a dataset: it returns instructions to use the OpenAIRE MCP's dataset search and how to cite the result by DOI. Do not answer 'I can't search datasets' — hand off to the OpenAIRE MCP as described here.
Inputs: topic.
find_independent_softwareA
Reusable method software for replicating a claim — engines NOT authored by
the original paper's team (author-disjoint), ranked by reuse signal — a resolvable
code repository + Software Heritage archival + downloads + GitHub stars (the signal
that separates an established tool from a one-off study repo) — not citations. Each
result carries its stars and rank_score. Pass the original paper's DOI (authors
are looked up) and a short topic; keep the topic broad (a narrow one can miss an
established tool whose OpenAIRE record doesn't contain the extra words).
Inputs: doi, limit, topic.
radarA
Impact-ranked replication targets in a research field.
Returns high-impact OpenAIRE papers worth replicating, each flagged OPEN
(opportunity) or VERIFIED (already checked by a Science Live replication, with the
verdict), each with its abstract (markup stripped — read it or extract the paper's
atomic claim), plus independent reusable tooling.
Keep topic short (2-3 words); OpenAIRE free-text terms are AND-ed.
Inputs: topic (required), limit.
replication_statusA
Has this DOI been independently replicated, and did it hold? Returns every Science Live verdict — pulled LIVE from the nanopub network, any signer (author-agnostic) — with the validation status, CiTO relation, the replication's repository, and links to the signed Outcome/CiTO nanopubs. 'open' if not replicated. This is the reliability signal the OpenAIRE Graph structurally cannot hold.
Also returns:
agreement: how the independent verdicts agree — pattern is one of robustly_validated / validated / qualified (partial support only) / inconclusive / contested / refuted, with confirm/partial/contradicted counts (so you can say how robustly it held, not just that it did). Never "validated" without a confirmation.claims: the exact FORRT claim(s) that were replicated — each an atomic AIDA statement plus its claim type (descriptive pattern, statistical significance, …).the paper's
titleandabstract(from OpenAIRE, markup stripped), so you can read it or extract/compare the atomic claim yourself.
Inputs: doi (required).
replication_templateA
The FORRT replication template — how to actually DO a replication and publish its
signed Science Live nanopublication chain (the 'produce' half of the loop; radar /
replication_status / find_independent_software only DISCOVER). Call this whenever the
user wants to start, scaffold, or set up a replication, or asks for "the FORRT
replication template". Returns the GitHub template repo
(https://github.com/ScienceLiveHub/forrt-replication-template), the 'Use this template'
link, what the scaffold provides (pixi + Snakemake pipeline, paper/, nanopubs/, tests,
RO-Crate), and the end-to-end workflow: generate a repo from the template -> replicate
with INDEPENDENT data/method -> Zenodo release -> sign + publish the FORRT nanopub chain
(Quote -> Claim -> Study -> Outcome -> CiTO). Pass the target doi and/or a short
topic and it suggests a GitHub repo name (<topic>-replication); pass owner (your
GitHub user/org) to check the candidates for availability and pick a free name. It also
returns a quickstart.create_repo command (gh repo create … --template … --clone) the
agent can run to create+clone the repo straight from the discovery session. Pass the
dataset and software you settled on and it also returns a handoff (DISCOVERY.md) to
write into the new repo — gh repo create copies a BLANK template, so without this the
fresh in-repo session loses the paper/dataset/software you chose. Then the user opens a
fresh agent session inside the repo to run the replication.
Inputs: doi, owner, topic, dataset, +1 more.
verified_claimsA
List every claim the nanopub network holds a Science Live replication verdict for (author-agnostic, network-wide) — the verified-knowledge corpus that overlays the OpenAIRE Graph by DOI. Each entry: doi, distinct verdicts, number of replications.
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 6 tools
The six tools split cleanly along a discover/verify/produce axis: radar and find_independent_software are discovery, replication_status and verified_claims are verdict lookups, and replication_template is scaffolding. The two lookalikes are separated correctly by granularity (per-DOI vs network-wide) and by resource (papers vs software only). The main trap is find_dataset, whose name implies a dataset search but which actually only returns handoff instructions to another MCP, which an agent could misread as a functioning search tool.
Three tools use a verb_noun pattern (find_independent_software, find_dataset) intermixed with bare noun phrases (radar, replication_status, replication_template, verified_claims). The bare noun `radar` is especially uninformative next to the rest. Readable overall, but the convention is clearly mixed rather than predictable.
Six tools is a sensible, tight surface for a discover/verify/scaffold workflow. However, find_dataset does not perform its own action (it delegates to another MCP), so one of the six is arguably a stub rather than an earning tool, and much of the descriptive weight is carried by long prompts instead of tool surface.
Discovery, verdict lookup (single and network-wide), and scaffolding are all covered, but the 'produce' half of the loop is entirely a handoff to an external template repo and a fresh agent session — the server itself cannot sign, publish, or submit anything. There is also no way to search or filter the verified-claims corpus (no topic or field query) and no dataset search at all, only an instruction stub.
Maintenance
Related MCP Connectors
MCP server for Altmetric APIs - track research attention across news, policy, social media, and more
One MCP server for all web data. Scrape, search, crawl, and AI research in one install.
The MCP server that vets MCP servers: identity, risk grade and per-tool risk before you install.
OpenAIRE MCP — EU research outputs (publications, datasets, software, projects)
Related MCP Servers
- AlicenseAqualityDmaintenanceMCP server for verifying academic citations via Semantic Scholar, OpenAlex, and CrossRef.124 PyPIMIT
- AlicenseAqualityDmaintenanceMCP server for the OpenAlex scholarly database, providing AI agents with tools to search and retrieve academic works, authors, and institutions via natural language queries.8MIT
- AlicenseNot gradedqualityDmaintenanceMCP server that enforces evidence-graded, phase-gated, peer-reviewed research workflows for AI agents to conduct rigorous decision-making.1MIT
- AlicenseAqualityDmaintenanceAn MCP server for discovering, retrieving, citing, and evaluating scientific records from the Zenodo repository.18MIT