replication-radar 0.1.0__tar.gz

replication_radar-0.1.0/.github/workflows/publish-pypi.yml

@@ -0,0 +1,51 @@
+name: Publish to PyPI
+
+# Publishes replication-radar to PyPI on each GitHub Release, using PyPI
+# Trusted Publishing (OIDC) — no API token stored in the repo.
+#
+# One-time setup on PyPI (pypi.org -> your account -> Publishing -> Add a pending
+# publisher), BEFORE the first release:
+#   PyPI project name : replication-radar
+#   Owner             : ScienceLiveHub
+#   Repository name   : replication-radar
+#   Workflow name     : publish-pypi.yml
+#   Environment name  : pypi
+
+on:
+  release:
+    types: [published]
+  workflow_dispatch:
+
+jobs:
+  build:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-python@v5
+        with:
+          python-version: "3.12"
+      - name: Build sdist + wheel
+        run: |
+          python -m pip install --upgrade build
+          python -m build
+      - name: Smoke-check the wheel imports + bundled data resolves
+        run: |
+          python -m pip install dist/*.whl
+          python -c "import replication_radar as r; assert r.replication_status('10.1126/science.aax8591')['replicated']; print('ok', r.__version__)"
+      - uses: actions/upload-artifact@v4
+        with:
+          name: dist
+          path: dist/
+
+  publish:
+    needs: build
+    runs-on: ubuntu-latest
+    environment: pypi
+    permissions:
+      id-token: write   # required for trusted publishing
+    steps:
+      - uses: actions/download-artifact@v4
+        with:
+          name: dist
+          path: dist/
+      - uses: pypa/gh-action-pypi-publish@release/v1

replication_radar-0.1.0/.gitignore

@@ -0,0 +1,6 @@
+.venv/
+dist/
+build/
+*.egg-info/
+__pycache__/
+*.pyc

replication_radar-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Anne Fouilloux / Science Live
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

replication_radar-0.1.0/PKG-INFO

@@ -0,0 +1,100 @@
+Metadata-Version: 2.4
+Name: replication-radar
+Version: 0.1.0
+Summary: MCP server that turns the OpenAIRE Graph into a ranked replication queue — impact-ranked targets, independent reusable tooling, and the Science Live verification overlay.
+Project-URL: Homepage, https://github.com/ScienceLiveHub/replication-radar
+Project-URL: Repository, https://github.com/ScienceLiveHub/replication-radar
+Project-URL: Science Live, https://sciencelive4all.org
+Author: Anne Fouilloux
+License: MIT
+License-File: LICENSE
+Keywords: FORRT,mcp,nanopublication,open-science,openaire,replication
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Scientific/Engineering
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Requires-Dist: mcp>=1.2.0
+Provides-Extra: dev
+Requires-Dist: pytest>=8; extra == 'dev'
+Description-Content-Type: text/markdown
+
+# Replication Radar
+
+An **MCP server that makes the OpenAIRE Graph more useful for replication.** Point it
+at a research field or a paper and it answers the question the Graph structurally
+cannot: *what high-impact work is worth replicating, is there **independent** reusable
+tooling to do it, and has it already been checked — with what verdict?*
+
+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](https://github.com/ScienceLiveHub/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 not citations |
+| `replication_status(doi)` | Has this DOI been replicated, did it hold? Verdict(s) + CiTO nanopub links, or `open` |
+
+### 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".
+
+## Run
+
+```bash
+pip install -e .                       # installs the `mcp` runtime
+python -m replication_radar.server     # stdio MCP server
+```
+
+Add to an MCP client (`.mcp.json`):
+
+```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:
+
+```bash
+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.
+```

replication_radar-0.1.0/README.md

@@ -0,0 +1,77 @@
+# Replication Radar
+
+An **MCP server that makes the OpenAIRE Graph more useful for replication.** Point it
+at a research field or a paper and it answers the question the Graph structurally
+cannot: *what high-impact work is worth replicating, is there **independent** reusable
+tooling to do it, and has it already been checked — with what verdict?*
+
+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](https://github.com/ScienceLiveHub/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 not citations |
+| `replication_status(doi)` | Has this DOI been replicated, did it hold? Verdict(s) + CiTO nanopub links, or `open` |
+
+### 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".
+
+## Run
+
+```bash
+pip install -e .                       # installs the `mcp` runtime
+python -m replication_radar.server     # stdio MCP server
+```
+
+Add to an MCP client (`.mcp.json`):
+
+```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:
+
+```bash
+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.
+```

replication_radar-0.1.0/STORY.md

@@ -0,0 +1,99 @@
+# Replication Radar — making the OpenAIRE Graph tell you what to replicate
+
+*OpenAIRE AI Hackathon · Theme B (Build) · a Science Live contribution*
+
+## The question
+
+The OpenAIRE Graph knows how *visible* a paper is — citation influence, popularity,
+impulse, the BIP! classes C1–C5. It does not, and structurally cannot, know whether a
+paper's claim is *true*. Citation-popularity is a measure of attention, and attention
+is orthogonal to reliability: a heavily-cited result looks identical, in the Graph, to
+one nobody ever checked.
+
+So we asked a build question, not a metrics question: **can we add the one signal the
+Graph can't hold — has this claim been independently replicated, and did it hold — and
+in doing so turn the Graph from a record of what *was* done into a tool that tells you
+what's worth replicating *next*?**
+
+## The journey
+
+We started narrow: Science Live already has 30+ FORRT replication chains, each ending
+in a cryptographically-signed nanopub that records a verdict (Validated, Partially
+Supported, …). The first idea was a lookup — "is this DOI verified?" — joined to the
+Graph by DOI. It worked, but it was **sparse**: it lights up only on the dozen papers
+we happen to have replicated, and answers "no data" everywhere else. A tool that's
+empty 99.99% of the time isn't a tool.
+
+The turn came from a distinction that matters in replication science but is usually
+left implicit. A **reproduction** re-runs the original code; a **replication** tests
+the same claim by a *different* route. The right question for a research engineer isn't
+"where's the paper's code" — it's "is there *independent* tooling I could use to check
+this?" That reframing pointed at the whole Graph, not our twelve chains: the Graph
+already records which results are high-impact, which have **reusable open software**,
+and which have **open data** — it just never joins them into a "this is worth, and
+feasible, to replicate" signal.
+
+We spiked feasibility against the live OpenAIRE Graph API before building, and reported
+honestly what works and what doesn't:
+
+- **Impact ranking** — works (`citationImpact`, C1–C5, on papers and software).
+- **Independent tooling** — works, and the reproduction-vs-replication line turns out
+  to be *computable*: for Phillips et al. 2009 (2,441 citations, C1), the `dismo`
+  package is flagged *non-independent* because Phillips and Elith co-author it, while
+  `biomod2` (Software-Heritage-archived) and `jSDM` are independent. Author-disjointness
+  is the filter that makes the tool replication-aware.
+- **Reuse ranking** — research software is almost uniformly C5/0 citations, so we rank
+  *software* by reuse signal (code repo + Software Heritage archival + usage), not by
+  citations.
+- **Reference data** — abundant (1,228 occurrence datasets for one query).
+- **Funder context** — only *field-level* (per-paper funder attribution and graph-edge
+  traversal aren't exposed on the public API). We kept what works and dropped what
+  doesn't, rather than fake it.
+
+Then we built it, proved it live on Species Distribution Models, and wired it into the
+public `forrt-replication-template` so every new replication repo gets discovery built in.
+
+## The insight
+
+Three things we didn't expect going in:
+
+1. **Reliability is a different *category* of signal, not a better metric.** The Graph's
+   citation axis can't be repaired into a truth axis; verification has to be *added*,
+   and it applies to any claim — including paperless ones the Graph never indexes.
+2. **The reproduction/replication distinction is operational.** "Independent of the
+   original authors" is a concrete, computable filter — and it's the thing that turns
+   "find the code" into "find a way to *check* this."
+3. **The Graph already holds the ingredients of a replication-readiness signal** (impact
+   + reusable software + data) and simply doesn't join them. Joining them is most of the
+   value.
+
+## What others can reuse
+
+- **`replication-radar`** — an MCP server (`pip install` / `uvx`, MIT) exposing three
+  tools any agent can add next to the OpenAIRE MCP: `radar(topic)` (impact-ranked
+  replication targets, each OPEN or already-VERIFIED, with independent tooling + funder
+  context), `find_independent_software(doi)` (author-disjoint reusable engines), and
+  `replication_status(doi)` (the verdict overlay). It hits the public OpenAIRE Graph API
+  anonymously and is endpoint-agnostic (`RADAR_OPENAIRE_BASE`) so it points at the Alien
+  gateway or any mirror. Repo: https://github.com/ScienceLiveHub/replication-radar
+- **The verdict-index format** (`data/verdicts.json`) — a portable DOI→verdict crosswalk
+  others can extend with their own replications.
+- **The template integration** — a `/radar` discovery skill that drops into any
+  fork of `forrt-replication-template`.
+- **The connector feasibility map** — a documented account of what the OpenAIRE MCP /
+  Graph API can and can't do for replication tooling, so the next builder doesn't
+  re-discover it.
+
+## Honest limits
+
+Discovery recall is keyword-bound (OpenAIRE free-text terms are AND-ed); the verified
+overlay is authoritative but reflects a known index, not every replication that exists;
+tooling is matched by topic + author-independence, not a proven ability to test a
+specific claim — the tool surfaces and ranks, the researcher judges. None of these are
+hidden in the output.
+
+---
+
+*Materials in this repository are dual-licensed: **source code under MIT**, and this
+write-up together with the verdict index (`STORY.md`, `data/verdicts.json`) under
+**[CC-BY 4.0](https://creativecommons.org/licenses/by/4.0/)**.*

replication_radar-0.1.0/demo_sdm.py

@@ -0,0 +1,49 @@
+"""Live vertical-slice demo: the Replication Radar on Species Distribution Models.
+
+Runs against the real OpenAIRE Graph API (anonymous). Proves the full pipeline:
+impact-ranked targets + independent tooling + reference data + verified-overlay.
+
+    PYTHONPATH=src python3 demo_sdm.py
+"""
+import sys, os
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), "src"))
+
+from replication_radar import radar, find_independent_software, replication_status  # noqa: E402
+
+
+def hr(t):
+    print("\n" + "=" * 72 + f"\n {t}\n" + "=" * 72)
+
+
+hr("radar('species distribution') — replication targets in the field")
+r = radar("species distribution", limit=8)
+print(f"topic: {r['topic']}   OPEN: {r['open_count']}   VERIFIED: {r['verified_count']}\n")
+for i, t in enumerate(r["targets"], 1):
+    imp = t["impact"]
+    print(f"{i:>2}. [{t['status']:8}] {(t['title'] or '')[:58]:58}  {t['citations']:>5} cites  "
+          f"cit:{imp['citationClass']} inf:{imp['influenceClass']}")
+    print(f"      doi: {t['doi']}")
+    if t["status"] == "VERIFIED":
+        print(f"      -> {t['verification']}")
+    elif t["independent_tooling"]:
+        tl = t["independent_tooling"][0]
+        print(f"      independent tooling avail: {(tl['title'] or '')[:46]}  swh={tl['swh']}")
+
+print("\nfunder context (field-level):")
+fc = r["funder_context"]
+print(f"  projects in field: {fc['projects_in_field']}")
+for f in fc["top_funders"]:
+    print(f"   - {f['name'][:42]:42} {f['jurisdiction'] or '--':4} EUR {f['funded_eur']:,}")
+
+hr("find_independent_software(Phillips 2009 = 10.1890/07-2153.1)")
+fs = find_independent_software(doi="10.1890/07-2153.1", topic="species distribution")
+print(f"original authors: {fs['original_authors']}")
+print(f"independent tools found: {fs['independent_count']} / {len(fs['software'])}\n")
+for s in fs["software"][:6]:
+    flag = "INDEP" if s["independent"] else "rooted"
+    print(f"  [{flag}] reuse={s['reuse_score']}  {(s['title'] or '')[:50]:50}  authors={s['authors'][:2]}")
+
+hr("replication_status() — the verified-overlay the Graph cannot hold")
+for doi in ["10.1890/07-2153.1", "10.1073/pnas.0704469104", "10.1126/science.aax8591", "10.9999/not.replicated"]:
+    st = replication_status(doi)
+    print(f"  {doi:28} -> {st['summary']}")

replication_radar-0.1.0/pyproject.toml

@@ -0,0 +1,41 @@
+[project]
+name = "replication-radar"
+version = "0.1.0"
+description = "MCP server that turns the OpenAIRE Graph into a ranked replication queue — impact-ranked targets, independent reusable tooling, and the Science Live verification overlay."
+readme = "README.md"
+requires-python = ">=3.10"
+license = { text = "MIT" }
+authors = [{ name = "Anne Fouilloux" }]
+keywords = ["openaire", "mcp", "replication", "open-science", "nanopublication", "FORRT"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+]
+dependencies = [
+    "mcp>=1.2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/ScienceLiveHub/replication-radar"
+Repository = "https://github.com/ScienceLiveHub/replication-radar"
+"Science Live" = "https://sciencelive4all.org"
+
+[project.scripts]
+replication-radar = "replication_radar.server:main"
+
+[project.optional-dependencies]
+# the core (openaire client + radar logic) is stdlib-only and needs nothing extra;
+# `mcp` is only required to run the server wrapper.
+dev = ["pytest>=8"]
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/replication_radar"]
+# data/verdicts.json ships automatically as package data under the package dir.

replication_radar-0.1.0/src/replication_radar/__init__.py

@@ -0,0 +1,10 @@
+"""Replication Radar — turn the OpenAIRE Graph into a ranked replication queue.
+
+Adds a capability the Graph lacks: 'what high-impact work is worth replicating,
+with INDEPENDENT reusable tooling, and has it already been checked?' — joining
+OpenAIRE impact + Software Heritage reuse signals + Science Live nanopub verdicts.
+"""
+from .radar import radar, find_independent_software, replication_status
+
+__all__ = ["radar", "find_independent_software", "replication_status"]
+__version__ = "0.1.0"

replication_radar-0.1.0/src/replication_radar/data/verdicts.json

@@ -0,0 +1,32 @@
+{
+  "_meta": {
+    "source": "Science Live FORRT replication chains (nanopub verdicts), built 2026-06-13",
+    "schema": "doi (lowercased) -> list of verifications {repo, verdict, cito[], outcome_np, cito_np}",
+    "note": "This is the 'already-checked' memory layer of the Replication Radar. Verdicts are carried in CiTO nanopubs; the OpenAIRE Graph cannot hold them. Extend by adding chains."
+  },
+  "verifications": {
+    "10.1126/science.aax8591": [
+      {"repo": "weatherxbiodiversity-projection", "verdict": "Validated", "cito": ["confirms"], "outcome_np": "https://w3id.org/sciencelive/np/RAPZMgcYbScSAXnrnSySQwZzgSA_rn-xodlMxNlwwQYY8", "cito_np": "https://w3id.org/sciencelive/np/RALbHA-r6wIFOFPFlfIpwYqJEpzCFqeJ082iChgdfvhNM"},
+      {"repo": "weatherxbiodiversity-projection-nside128", "verdict": "Validated", "cito": ["confirms"], "outcome_np": "https://w3id.org/sciencelive/np/RAa4QR41Hot9zxujcrCyTo82Ij7oaw_6z8zk8NxDqoJFM", "cito_np": "https://w3id.org/sciencelive/np/RAhw9m0BEj0-9hXrTtJ2NHG5rMr-ZBf_mdBQTQRk6u3n4"},
+      {"repo": "weatherxbiodiversity-substrate-sensitivity", "verdict": "Validated+PartiallySupported", "cito": ["confirms", "extends", "qualifies"], "outcome_np": null, "cito_np": null}
+    ],
+    "10.1890/07-2153.1": [
+      {"repo": "sdm-phillips-reproduction", "verdict": "Validated", "cito": ["confirms"], "outcome_np": "https://w3id.org/sciencelive/np/RA_uV84IchQAkkmCP_6amQir_flgCmvvt97DWIDmbu_V0", "cito_np": "https://w3id.org/sciencelive/np/RAWsmCzWMKYQQK_ovRvE1o2wqjYkoxjfZRncHEcWAvv2g"},
+      {"repo": "sdm-hotspot-spatial-effort", "verdict": "methodological-extension", "cito": ["extends", "usesMethodIn"], "outcome_np": "https://w3id.org/sciencelive/np/RA4q2J-h_UpFpeLTeL_DS8p7j7EOBCes4L1G1eOBfJiDo", "cito_np": "https://w3id.org/sciencelive/np/RA7151bPt5TSSTxi-sWGmZhUOHcqaSzevzhhD4QxmfURI"}
+    ],
+    "10.1890/11-1952.1": [
+      {"repo": "sdm-hotspot-effort-correction", "verdict": "Validated", "cito": ["extends", "usesMethodIn"], "outcome_np": "https://w3id.org/sciencelive/np/RAsPjEImfZaXsIri0ny4j_s_k_6wyOlC6tkocl6w2y7f4", "cito_np": "https://w3id.org/sciencelive/np/RACYbb_IxZNnBcxI7uPqc-df2oRaMr4bqHJTOJe-BNmkc"}
+    ],
+    "10.1073/pnas.0704469104": [
+      {"repo": "sdm-scale-replication", "verdict": "PartiallySupported", "cito": ["qualifies"], "outcome_np": "https://w3id.org/sciencelive/np/RAzeZKbUCEMXZXDc-WzgHZ4K5mOMwotYhS2uCKDDmdcHI", "cito_np": "https://w3id.org/sciencelive/np/RALjFcvPtncy74ZL8QgSiEyRZv_-mOiZj4wvWuq8JK-2s"}
+    ],
+    "10.1016/j.ocemod.2024.102387": [
+      {"repo": "coastal-rom-replication", "verdict": "Validated", "cito": ["confirms"], "outcome_np": "https://w3id.org/sciencelive/np/RAG8PjhjvPQFZo54BTaV_b7TryMonH--aDGzEXLhzvQ4w", "cito_np": "https://w3id.org/sciencelive/np/RAuvGPQk_nxEcBWzADcLnyfqgjJ9Hr2aSWxwof2sDAung"},
+      {"repo": "european-coastal-biodiversity-replication", "verdict": "Validated", "cito": ["extends", "qualifies"], "outcome_np": "https://w3id.org/sciencelive/np/RAwrIP5nKIk8Qh7WeMs8z6HHVGssLVAkHDeI8nSB4LUK8", "cito_np": "https://w3id.org/sciencelive/np/RAEXzZcCXiwsNf19NbXvilwwxnFU5IvkplzWTNiNmT70A"}
+    ],
+    "10.1038/s41597-022-01235-3": [
+      {"repo": "white-shark-geolocation-replication", "verdict": "PartiallySupported", "cito": ["qualifies"], "outcome_np": "https://w3id.org/sciencelive/np/RAv0cF0rwxb1CFmUAJlk5B7PLVc9pls5OvlfOHHHhtgm8", "cito_np": "https://w3id.org/sciencelive/np/RAnqtFUZHfmW7Dtmf3bcTQtjDAfrq5IGV4xQ8guW8L3vY"},
+      {"repo": "white-shark-geolocation-light", "verdict": "PartiallySupported", "cito": ["qualifies"], "outcome_np": "https://w3id.org/sciencelive/np/RAlwDA35wFcmV-ZYzOUB_E3SrqPMIlIxWftoiPFbzN-7I", "cito_np": "https://w3id.org/sciencelive/np/RA6JMK2CNN8MZITLdd3si08TwyR_-3fvbt6l6g3lf-YOg"}
+    ]
+  }
+}

replication_radar-0.1.0/src/replication_radar/openaire.py

@@ -0,0 +1,201 @@
+"""Thin client over the OpenAIRE Graph API (graph/v1).
+
+Hits api.openaire.eu directly (anonymous, no token needed for these queries).
+Endpoint-agnostic: set RADAR_OPENAIRE_BASE to point at the Alien gateway or any
+mirror later. Stdlib-only (urllib) so the core runs with zero install.
+
+Operational rules learned from the connector spike (2026-06-13):
+  - Free-text terms are AND-ed: keep queries SHORT (2-3 words), OR-expand if needed.
+  - Rank SOFTWARE by reuse signal (repo + Software Heritage + usage), NOT citations
+    (research software is almost uniformly citationClass C5 / 0 citations).
+  - Rank PAPERS by citation impact (BIP! classes C1..C5 + count).
+"""
+from __future__ import annotations
+
+import json
+import os
+import urllib.parse
+import urllib.request
+from dataclasses import dataclass, field
+from typing import Any
+
+BASE = os.environ.get("RADAR_OPENAIRE_BASE", "https://api.openaire.eu/graph/v1")
+_TIMEOUT = float(os.environ.get("RADAR_HTTP_TIMEOUT", "30"))
+
+_CLASS_RANK = {"C1": 1, "C2": 2, "C3": 3, "C4": 4, "C5": 5, None: 9}
+
+
+def _get(path: str, params: dict[str, Any]) -> dict:
+    qs = urllib.parse.urlencode({k: v for k, v in params.items() if v is not None})
+    url = f"{BASE}/{path}?{qs}"
+    req = urllib.request.Request(url, headers={"Accept": "application/json"})
+    with urllib.request.urlopen(req, timeout=_TIMEOUT) as resp:
+        return json.load(resp)
+
+
+def _doi_of(rec: dict) -> str | None:
+    for p in (rec.get("pids") or []):
+        if (p.get("scheme") or "").lower() == "doi":
+            return (p.get("value") or "").lower() or None
+    for inst in (rec.get("instances") or []):
+        for p in (inst.get("pids") or []):
+            if (p.get("scheme") or "").lower() == "doi":
+                return (p.get("value") or "").lower() or None
+    return None
+
+
+def _surnames(rec: dict) -> list[str]:
+    out: list[str] = []
+    for a in (rec.get("authors") or []):
+        s = a.get("surname") or ""
+        if not s and a.get("fullName"):
+            # "Surname, Given" or "Given Surname" -> take the comma-lead or last token
+            fn = a["fullName"]
+            s = fn.split(",")[0].strip() if "," in fn else fn.split()[-1]
+        s = s.strip().lower()
+        if s:
+            out.append(s)
+    return out
+
+
+def _year(rec: dict) -> int | None:
+    d = rec.get("publicationDate") or ""
+    return int(d[:4]) if d[:4].isdigit() else None
+
+
+def _impact(rec: dict) -> dict:
+    return ((rec.get("indicators") or {}).get("citationImpact")) or {}
+
+
+def _urls(rec: dict) -> list[str]:
+    out: list[str] = []
+    for inst in (rec.get("instances") or []):
+        out.extend(inst.get("urls") or [])
+    if rec.get("codeRepositoryUrl"):
+        out.append(rec["codeRepositoryUrl"])
+    return out
+
+
+@dataclass
+class Product:
+    doi: str | None
+    title: str
+    authors: list[str]          # lowercased surnames
+    year: int | None
+    type: str
+    citation_count: int
+    citation_class: str | None
+    influence_class: str | None
+    popularity_class: str | None
+    impulse_class: str | None
+    code_repo: str | None
+    swh_archived: bool
+    downloads: int
+    raw_id: str | None = None
+
+    @property
+    def impact_rank(self) -> tuple[int, int, int]:
+        # primary: best influence class, then citation class, then -count
+        return (
+            _CLASS_RANK.get(self.influence_class, 9),
+            _CLASS_RANK.get(self.citation_class, 9),
+            -self.citation_count,
+        )
+
+    @property
+    def reuse_score(self) -> int:
+        # for SOFTWARE: how reusable does this look?
+        s = 0
+        if self.code_repo:
+            s += 2
+        if self.swh_archived:
+            s += 2
+        if self.downloads > 0:
+            s += 1
+        if self.citation_count > 0:
+            s += 1
+        return s
+
+
+def _to_product(rec: dict) -> Product:
+    imp = _impact(rec)
+    usage = ((rec.get("indicators") or {}).get("usageCounts")) or {}
+    urls = _urls(rec)
+    return Product(
+        doi=_doi_of(rec),
+        title=(rec.get("mainTitle") or "").strip(),
+        authors=_surnames(rec),
+        year=_year(rec),
+        type=(rec.get("type") or "").lower(),
+        citation_count=int(imp.get("citationCount") or 0),
+        citation_class=imp.get("citationClass"),
+        influence_class=imp.get("influenceClass"),
+        popularity_class=imp.get("popularityClass"),
+        impulse_class=imp.get("impulseClass"),
+        code_repo=rec.get("codeRepositoryUrl"),
+        swh_archived=any("softwareheritage.org" in (u or "") for u in urls),
+        downloads=int(usage.get("downloads") or 0),
+        raw_id=rec.get("id"),
+    )
+
+
+def search_products(topic: str, type_: str, size: int = 25, page: int = 1) -> list[Product]:
+    """type_ in {publication, software, dataset, other}. Keep `topic` short."""
+    data = _get(
+        "researchProducts",
+        {"search": topic, "type": type_, "pageSize": size, "page": page},
+    )
+    return [_to_product(r) for r in (data.get("results") or [])]
+
+
+def get_by_doi(doi: str) -> Product | None:
+    """Resolve a single product by DOI via the dedup id (md5 of the lowercased DOI)."""
+    import hashlib
+
+    h = hashlib.md5(doi.lower().encode()).hexdigest()
+    try:
+        data = _get("researchProducts", {"id": f"doi_dedup___::{h}", "pageSize": 1})
+    except Exception:
+        data = {}
+    results = data.get("results") or []
+    if results:
+        return _to_product(results[0])
+    # fallback: the DOI may be deduped with a preprint -> search by DOI string
+    try:
+        data = _get("researchProducts", {"search": doi, "pageSize": 5})
+    except Exception:
+        return None
+    for r in data.get("results") or []:
+        if _doi_of(r) == doi.lower():
+            return _to_product(r)
+    return None
+
+
+@dataclass
+class Funder:
+    name: str
+    jurisdiction: str | None
+    funded_amount: float = 0.0
+
+
+@dataclass
+class ProjectLandscape:
+    total: int
+    funders: list[Funder] = field(default_factory=list)
+
+
+def funder_landscape(topic: str, size: int = 20) -> ProjectLandscape:
+    """Aggregate funder context for a field via /projects (per-paper funding is NOT
+    reachable on this connector; this is topic-level CoARA context only)."""
+    data = _get("projects", {"search": topic, "pageSize": size})
+    total = (data.get("header") or {}).get("numFound") or len(data.get("results") or [])
+    agg: dict[str, Funder] = {}
+    for proj in data.get("results") or []:
+        for f in proj.get("fundings") or []:
+            name = f.get("name") or f.get("shortName") or "?"
+            amt = float(((proj.get("granted") or {}).get("fundedAmount")) or 0)
+            if name not in agg:
+                agg[name] = Funder(name=name, jurisdiction=f.get("jurisdiction"))
+            agg[name].funded_amount += amt
+    funders = sorted(agg.values(), key=lambda x: -x.funded_amount)
+    return ProjectLandscape(total=int(total), funders=funders)

replication_radar-0.1.0/src/replication_radar/radar.py

@@ -0,0 +1,157 @@
+"""Core Replication Radar logic — pure functions over the OpenAIRE client + verdicts.
+
+Three capabilities (exposed as MCP tools in server.py):
+  - radar(topic)                  : impact-ranked replication targets in a field,
+                                    each flagged open vs already-verified, with a
+                                    field-level funder-context panel.
+  - find_independent_software(doi): reusable engines NOT authored by the original team
+                                    (the reproduction-vs-replication distinction, made
+                                    computable as author-disjointness).
+  - replication_status(doi)       : Science Live verdict overlay for one DOI.
+"""
+from __future__ import annotations
+
+from . import openaire, verdicts
+
+
+def _independence(target_authors: list[str], cand_authors: list[str]) -> bool:
+    """A candidate tool is INDEPENDENT of the target paper if no author surname is
+    shared. This is what makes a *replication* (different toolchain) rather than a
+    *reproduction* (the original team's code)."""
+    if not cand_authors:
+        return True  # unattributed engine (e.g. a package repo) — treat as independent
+    return not (set(target_authors) & set(cand_authors))
+
+
+def replication_status(doi: str) -> dict:
+    st = verdicts.status_for(doi)
+    return {"doi": doi.lower(), **st}
+
+
+def find_independent_software(
+    doi: str | None = None,
+    topic: str | None = None,
+    original_authors: list[str] | None = None,
+    limit: int = 8,
+) -> dict:
+    """Find reusable, INDEPENDENT method software for replicating a claim.
+
+    Provide a DOI (authors are looked up) or pass original_authors directly, plus a
+    short `topic` to search the software pool. Ranks by reuse signal, not citations.
+    """
+    paper = None
+    if original_authors is None and doi:
+        paper = openaire.get_by_doi(doi)
+        original_authors = paper.authors if paper else []
+    original_authors = original_authors or []
+    if not topic:
+        # derive a short topic from the title's leading words
+        topic = " ".join((paper.title if paper else "").split()[:3]) or "software"
+
+    pool = openaire.search_products(topic, "software", size=25)
+    rows = []
+    for p in pool:
+        rows.append(
+            {
+                "title": p.title,
+                "doi": p.doi,
+                "authors": p.authors,
+                "independent": _independence(original_authors, p.authors),
+                "reuse_score": p.reuse_score,
+                "code_repo": p.code_repo,
+                "swh_archived": p.swh_archived,
+                "downloads": p.downloads,
+            }
+        )
+    # independent first, then most-reusable
+    rows.sort(key=lambda r: (not r["independent"], -r["reuse_score"]))
+    return {
+        "query_topic": topic,
+        "original_authors": original_authors,
+        "independent_count": sum(1 for r in rows if r["independent"]),
+        "software": rows[:limit],
+    }
+
+
+def radar(topic: str, limit: int = 8, pool: int = 30) -> dict:
+    """Impact-ranked replication targets in a field.
+
+    Each target is flagged open vs already-verified (Science Live overlay) and, for
+    open high-impact targets, whether independent tooling exists in the field.
+    """
+    papers = openaire.search_products(topic, "publication", size=pool)
+    papers.sort(key=lambda p: p.impact_rank)
+
+    # one software pull for the field; independence is computed per target
+    sw_pool = openaire.search_products(topic, "software", size=25)
+
+    targets = []
+    for p in papers[:limit]:
+        st = verdicts.status_for(p.doi)
+        indep_tools = [
+            s for s in sw_pool if _independence(p.authors, s.authors) and s.reuse_score >= 2
+        ]
+        indep_tools.sort(key=lambda s: -s.reuse_score)
+        targets.append(
+            {
+                "title": p.title,
+                "doi": p.doi,
+                "year": p.year,
+                "citations": p.citation_count,
+                "impact": {
+                    "citationClass": p.citation_class,
+                    "influenceClass": p.influence_class,
+                    "popularityClass": p.popularity_class,
+                },
+                "status": "VERIFIED" if st["replicated"] else "OPEN",
+                "verification": st["summary"],
+                "verifications": st["verifications"],
+                "independent_tooling": [
+                    {"title": s.title, "code_repo": s.code_repo, "swh": s.swh_archived}
+                    for s in indep_tools[:3]
+                ],
+            }
+        )
+
+    # Guarantee the verified-overlay shows: don't rely on keyword retrieval to
+    # surface already-checked papers. Pull the verdict index directly and include
+    # any whose title is topically relevant (shares a significant token).
+    shown = {t["doi"] for t in targets}
+    topic_terms = {w.lower() for w in topic.split() if len(w) > 3}
+    verified_in_field = []
+    for vdoi in sorted(verdicts.all_dois()):
+        if vdoi in shown:
+            continue
+        p = openaire.get_by_doi(vdoi)
+        if not p:
+            continue
+        title_terms = {w.lower().strip(",.:") for w in p.title.split()}
+        if topic_terms & title_terms:
+            st = verdicts.status_for(vdoi)
+            verified_in_field.append(
+                {
+                    "title": p.title,
+                    "doi": vdoi,
+                    "citations": p.citation_count,
+                    "impact": {"citationClass": p.citation_class, "influenceClass": p.influence_class},
+                    "status": "VERIFIED",
+                    "verification": st["summary"],
+                    "verifications": st["verifications"],
+                }
+            )
+
+    land = openaire.funder_landscape(topic, size=20)
+    return {
+        "topic": topic,
+        "targets": targets,
+        "verified_in_field": verified_in_field,
+        "open_count": sum(1 for t in targets if t["status"] == "OPEN"),
+        "verified_count": sum(1 for t in targets if t["status"] == "VERIFIED") + len(verified_in_field),
+        "funder_context": {
+            "projects_in_field": land.total,
+            "top_funders": [
+                {"name": f.name, "jurisdiction": f.jurisdiction, "funded_eur": round(f.funded_amount)}
+                for f in land.funders[:5]
+            ],
+        },
+    }

replication_radar-0.1.0/src/replication_radar/server.py

@@ -0,0 +1,60 @@
+"""MCP server exposing the Replication Radar over the OpenAIRE Graph.
+
+Run:  python -m replication_radar.server      (stdio transport)
+Add to an MCP client (.mcp.json):
+    { "mcpServers": { "replication-radar": {
+        "command": "python", "args": ["-m", "replication_radar.server"] } } }
+
+Hits api.openaire.eu/graph/v1 directly (anonymous). Point elsewhere with
+RADAR_OPENAIRE_BASE (e.g. the Alien AI-Gateway endpoint).
+"""
+from __future__ import annotations
+
+from mcp.server.fastmcp import FastMCP
+
+# import from the submodule directly (the package exports `radar` as a *function*,
+# which would shadow the module on `from . import radar`).
+from .radar import (
+    radar as _radar,
+    find_independent_software as _find_software,
+    replication_status as _replication_status,
+)
+
+mcp = FastMCP("replication-radar")
+
+
+@mcp.tool()
+def radar(topic: str, limit: int = 8) -> dict:
+    """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), plus independent reusable tooling and a field funder-context panel.
+    Keep `topic` short (2-3 words); OpenAIRE free-text terms are AND-ed.
+    """
+    return _radar(topic, limit=limit)
+
+
+@mcp.tool()
+def find_independent_software(doi: str = "", topic: str = "", limit: int = 8) -> dict:
+    """Reusable method software for *replicating* a claim — engines NOT authored by
+    the original paper's team (author-disjoint), ranked by reuse signal (code repo +
+    Software Heritage archival + usage), not citations. Pass the original paper's DOI
+    (authors are looked up) and a short topic."""
+    return _find_software(doi=doi or None, topic=topic or None, limit=limit)
+
+
+@mcp.tool()
+def replication_status(doi: str) -> dict:
+    """Has this DOI been independently replicated, and did it hold? Returns the
+    Science Live verdict(s) (the reliability signal the OpenAIRE Graph cannot hold)
+    with links to the CiTO nanopubs, or 'open' if not yet replicated."""
+    return _replication_status(doi)
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

replication_radar-0.1.0/src/replication_radar/verdicts.py

@@ -0,0 +1,39 @@
+"""The 'already-checked' memory layer: DOI -> Science Live replication verdicts.
+
+This is the signal the OpenAIRE Graph structurally cannot hold (citation-popularity
+is orthogonal to whether a claim held). Verdicts live in CiTO nanopubs; this index
+is the bundled crosswalk. Extend data/verdicts.json as new chains are published.
+"""
+from __future__ import annotations
+
+import json
+from functools import lru_cache
+from importlib import resources
+
+
+@lru_cache(maxsize=1)
+def _index() -> dict[str, list[dict]]:
+    with resources.files(__package__).joinpath("data/verdicts.json").open() as fh:
+        return (json.load(fh).get("verifications")) or {}
+
+
+def status_for(doi: str | None) -> dict:
+    """Return the replication status for a DOI.
+
+    {"replicated": bool, "verifications": [...], "summary": str}
+    """
+    if not doi:
+        return {"replicated": False, "verifications": [], "summary": "open"}
+    hits = _index().get(doi.lower(), [])
+    if not hits:
+        return {"replicated": False, "verifications": [], "summary": "open"}
+    verdicts = sorted({v["verdict"] for v in hits})
+    return {
+        "replicated": True,
+        "verifications": hits,
+        "summary": f"{len(hits)} verification(s): {', '.join(verdicts)}",
+    }
+
+
+def all_dois() -> set[str]:
+    return set(_index().keys())