Skip to main content
Glama
Replication Radar

Replication Radar

Replication Radar

DOI PyPI

🔗 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

radar(topic)

Impact-ranked replication targets in a field — each OPEN (opportunity) or VERIFIED (done, with verdict) + independent tooling + funder context

find_independent_software(doi, topic)

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 stars + rank_score)

replication_status(doi)

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; open if not

verified_claims()

The whole verified-knowledge corpus — every claim the network holds a verdict for (author-agnostic)

replication_template(doi, topic, owner)

The FORRT replication template (the produce half) — the scaffold repo, the workflow, and a suggested <topic>-replication repo name (checks availability under owner)

find_dataset(topic)

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 server

Add 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 SDM

Configuration

Env var

Default

Purpose

RADAR_OPENAIRE_BASE

https://api.openaire.eu/graph/v1

Swap to the Alien AI-Gateway or a mirror — the Radar is endpoint-agnostic

RADAR_HTTP_TIMEOUT

30

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.json to grow coverage.

Available Tools

6 tools
find_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 title and abstract (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

    A3.9/5.0

    Scored across 6 tools

    Disambiguation4/5

    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.

    Naming Consistency3/5

    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.

    Tool Count4/5

    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.

    Completeness3/5

    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

    ActivityMaintained
    ResponsivenessOutdated data

    Related MCP Connectors

    Related MCP Servers