replication-radar 0.1.0__py3-none-any.whl

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/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/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/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/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/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())

replication_radar-0.1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,11 @@
+replication_radar/__init__.py,sha256=7Ys8zOWMBapBHzgnNzT_bd7aX4zDB_wk0lzfAFQmfZc,497
+replication_radar/openaire.py,sha256=pp87dgW0XZjxxPOy0xvL5xLhGw8Udr2v5IPy7GVYxXY,6886
+replication_radar/radar.py,sha256=GCOF6HUquiO6exLQGt_x0gvkPnJ4dtXNm5Avlejrp-U,6361
+replication_radar/server.py,sha256=2wLX--f1LS4yo1pt32En86FYz5MsJxcls9VXtRLTF3o,2201
+replication_radar/verdicts.py,sha256=OjT4ESIGYCA3nVWSYp-IObK4cZTo_bOXbFqH6y29zpU,1309
+replication_radar/data/verdicts.json,sha256=OQR1tVqAQmRK2_xBofeHZufFKjcN344LKx1Vp-fFsvw,3761
+replication_radar-0.1.0.dist-info/METADATA,sha256=crP-b27ljqVOFWOP-oOUfBZylUqz22KOSFsOvsPzPKU,4834
+replication_radar-0.1.0.dist-info/WHEEL,sha256=mffPy8wBnZQn2VnJUU5jE99KsxaSfiyMHV9Yt0aLVxs,87
+replication_radar-0.1.0.dist-info/entry_points.txt,sha256=y7KOZtmp05sKfs0e_JzAoJR08fB0JR5RjbCbhB5ATFA,68
+replication_radar-0.1.0.dist-info/licenses/LICENSE,sha256=97cSYKrE2bUYfMTtW1hpOptYWTZTXsWCWud5Qc4Tszc,1086
+replication_radar-0.1.0.dist-info/RECORD,,

replication_radar-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.30.1
+Root-Is-Purelib: true
+Tag: py3-none-any

replication_radar-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+replication-radar = replication_radar.server:main

replication_radar-0.1.0.dist-info/licenses/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.