Merge pull request #1 from will-rice/feat/papers-mcp

papers-mcp: MCP servers over the lipsync and TTS paper corpora

.dockerignore

@@ -0,0 +1,8 @@
+.git
+.venv
+data/
+tests/.cache
+__pycache__
+.pytest_cache
+docs/
+.superpowers/

.gitignore

@@ -0,0 +1,6 @@
+__pycache__/
+*.egg-info/
+.venv/
+.pytest_cache/
+data/
+tests/.cache/

.pre-commit-config.yaml

@@ -0,0 +1,14 @@
+repos:
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v5.0.0
+    hooks:
+      - id: trailing-whitespace
+      - id: end-of-file-fixer
+      - id: check-yaml
+      - id: check-added-large-files
+  - repo: https://github.com/astral-sh/ruff-pre-commit
+    rev: v0.12.0
+    hooks:
+      - id: ruff
+        args: [--fix]
+      - id: ruff-format

Dockerfile

@@ -0,0 +1,21 @@
+FROM python:3.13-slim
+
+RUN apt-get update && apt-get install -y --no-install-recommends git \
+    && rm -rf /var/lib/apt/lists/*
+COPY --from=ghcr.io/astral-sh/uv:latest /uv /usr/local/bin/uv
+
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+    HF_HOME=/home/user/.cache/huggingface \
+    UV_PROJECT_ENVIRONMENT=/home/user/.venv
+WORKDIR /app
+
+COPY --chown=user pyproject.toml uv.lock ./
+RUN uv sync --frozen --no-dev --no-install-project
+COPY --chown=user . .
+RUN uv sync --frozen --no-dev
+
+EXPOSE 7860
+CMD ["uv", "run", "--no-sync", "uvicorn", "--factory", "papers_mcp.server:create_app", \
+     "--host", "0.0.0.0", "--port", "7860"]

README.md

@@ -0,0 +1,39 @@
+---
+title: papers-mcp
+emoji: 📚
+colorFrom: blue
+colorTo: purple
+sdk: docker
+app_port: 7860
+pinned: false
+---
+
+# papers-mcp
+
+MCP servers over the [lipsync-papers](https://github.com/will-rice/lipsync-papers)
+and [tts-papers](https://github.com/will-rice/tts-papers) research corpora.
+Public, read-only, streamable HTTP.
+
+| Endpoint | Corpus |
+|---|---|
+| `https://wrice-papers-mcp.hf.space/lipsync/mcp` | lipsync-papers |
+| `https://wrice-papers-mcp.hf.space/tts/mcp` | tts-papers |
+
+Tools per server: `search_papers` (hybrid BM25 + embedding search),
+`get_paper` (full markdown), `get_citations` (in-corpus citation graph),
+`list_recent`. Corpora re-sync from GitHub every 6 hours.
+
+## Connect
+
+```bash
+claude mcp add --transport http lipsync-papers https://wrice-papers-mcp.hf.space/lipsync/mcp
+claude mcp add --transport http tts-papers https://wrice-papers-mcp.hf.space/tts/mcp
+```
+
+## Develop
+
+```bash
+uv sync
+uv run pytest
+uv run uvicorn --factory papers_mcp.server:create_app --port 7860
+```

pyproject.toml

@@ -0,0 +1,40 @@
+[project]
+name = "papers-mcp"
+version = "0.1.0"
+description = "MCP servers over the lipsync-papers and tts-papers research corpora"
+requires-python = ">=3.11"
+dependencies = [
+    "mcp>=1.27,<2",
+    "rank-bm25>=0.2.2",
+    "sentence-transformers>=3.0",
+    "starlette",
+    "uvicorn>=0.30",
+]
+
+[dependency-groups]
+dev = [
+    "httpx>=0.27",
+    "pre-commit>=4.0",
+    "pytest>=8.0",
+]
+
+[tool.uv.sources]
+torch = [{ index = "pytorch-cpu", marker = "sys_platform == 'linux'" }]
+
+[[tool.uv.index]]
+name = "pytorch-cpu"
+url = "https://download.pytorch.org/whl/cpu"
+explicit = true
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/papers_mcp"]
+
+[tool.ruff]
+line-length = 100
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

src/papers_mcp/corpus.py

@@ -0,0 +1,95 @@
+"""Load and sync a research-papers corpus (papers.csv + markdown) from GitHub."""
+
+import csv
+import logging
+import re
+import subprocess
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# In-corpus citation links: `](../<year>/<id>.md)` or same-directory `](<id>.md)`.
+CITATION_LINK_RE = re.compile(r"\]\((?:\.\./\d{4}/)?([^/()\s]+)\.md\)")
+
+
+@dataclass
+class Paper:
+    """One paper's metadata, markdown location, and in-corpus citation edges."""
+
+    paper_id: str
+    title: str
+    authors: str
+    submitted: str
+    url: str
+    abstract: str
+    md_path: Path | None = None
+    markdown: str = ""
+    cites: list[str] = field(default_factory=list)
+    cited_by: list[str] = field(default_factory=list)
+
+
+@dataclass
+class Corpus:
+    """A cloned corpus repo and its loaded papers, keyed by paper id."""
+
+    name: str
+    repo_url: str
+    clone_dir: Path
+    papers: dict[str, Paper] = field(default_factory=dict)
+
+    def sync(self) -> None:
+        """Clone the corpus repo if absent, otherwise hard-reset to the latest origin HEAD.
+
+        A reset-to-fetched-ref mirror (rather than `pull --ff-only`) is immune to the
+        upstream repo ever force-pushing, which would otherwise fail every refresh forever.
+        """
+        if (self.clone_dir / ".git").exists():
+            self._git(["-C", str(self.clone_dir), "fetch", "--depth", "1", "origin", "HEAD"])
+            self._git(["-C", str(self.clone_dir), "reset", "--hard", "FETCH_HEAD"])
+        else:
+            self.clone_dir.parent.mkdir(parents=True, exist_ok=True)
+            self._git(["clone", "--depth", "1", self.repo_url, str(self.clone_dir)])
+        logging.info("synced %s corpus at %s", self.name, self.clone_dir)
+
+    def _git(self, args: list[str]) -> None:
+        """Run a git command, surfacing its stderr on failure instead of swallowing it."""
+        try:
+            subprocess.run(["git", *args], check=True, capture_output=True, text=True)
+        except subprocess.CalledProcessError as exc:
+            raise RuntimeError(f"git {args} failed for {self.name}: {exc.stderr.strip()}") from exc
+
+    def load(self) -> None:
+        """Load papers.csv, locate corpus markdown files, and build the citation graph."""
+        papers: dict[str, Paper] = {}
+        with (self.clone_dir / "papers.csv").open(newline="", encoding="utf-8") as f:
+            for row in csv.DictReader(f):
+                papers[row["arxiv_id"]] = Paper(
+                    paper_id=row["arxiv_id"],
+                    title=row["title"],
+                    authors=row["authors"],
+                    submitted=row["submitted"],
+                    url=row["url"],
+                    abstract=row["abstract"],
+                )
+
+        for md_path in sorted(self.clone_dir.glob("papers/*/*.md")):
+            paper = papers.get(md_path.stem)  # skips per-year README.md files
+            if paper:
+                paper.md_path = md_path
+
+        for paper in papers.values():
+            if paper.md_path is None:
+                continue
+            paper.markdown = paper.md_path.read_text(encoding="utf-8")
+            for cited_id in CITATION_LINK_RE.findall(paper.markdown):
+                if (
+                    cited_id != paper.paper_id
+                    and cited_id in papers
+                    and cited_id not in paper.cites
+                ):
+                    paper.cites.append(cited_id)
+        for paper in papers.values():
+            for cited_id in paper.cites:
+                papers[cited_id].cited_by.append(paper.paper_id)
+
+        self.papers = papers
+        logging.info("loaded %d papers for %s corpus", len(papers), self.name)

src/papers_mcp/search.py

@@ -0,0 +1,46 @@
+"""Hybrid BM25 + embedding search over a corpus's papers."""
+
+import re
+
+import torch
+from rank_bm25 import BM25Okapi
+from sentence_transformers import SentenceTransformer
+
+from papers_mcp.corpus import Paper
+
+EMBEDDING_MODEL = "sentence-transformers/all-MiniLM-L6-v2"
+RRF_K = 60
+
+TOKEN_RE = re.compile(r"[a-z0-9]+")
+
+
+def tokenize(text: str) -> list[str]:
+    """Lowercase alphanumeric tokens for BM25."""
+    return TOKEN_RE.findall(text.lower())
+
+
+class SearchIndex:
+    """Ranks papers by reciprocal-rank fusion of BM25 and embedding-cosine ranks."""
+
+    def __init__(self, papers: list[Paper], model: SentenceTransformer) -> None:
+        self.papers = papers
+        self.model = model
+        texts = [f"{p.title} {p.abstract}" for p in papers]
+        self.bm25 = BM25Okapi([tokenize(f"{text} {p.authors}") for text, p in zip(texts, papers)])
+        self.embeddings = model.encode(texts, convert_to_tensor=True, normalize_embeddings=True)
+
+    def search(self, query: str, limit: int) -> list[Paper]:
+        """Return the top *limit* papers for *query* by fused BM25 + cosine rank."""
+        bm25_scores = torch.tensor(self.bm25.get_scores(tokenize(query)))
+        query_embedding = self.model.encode(
+            [query], convert_to_tensor=True, normalize_embeddings=True
+        )
+        cosine_scores = (self.embeddings @ query_embedding.T).flatten()
+
+        fused = torch.zeros(len(self.papers))
+        for scores in (bm25_scores, cosine_scores):
+            ranks = scores.argsort(descending=True).argsort()
+            fused += 1.0 / (RRF_K + 1 + ranks)
+
+        top = fused.argsort(descending=True)[:limit]
+        return [self.papers[i] for i in top.tolist()]

src/papers_mcp/server.py

@@ -0,0 +1,181 @@
+"""MCP servers over research paper corpora — one streamable-HTTP endpoint per corpus."""
+
+import contextlib
+import logging
+import threading
+import time
+from concurrent.futures import ThreadPoolExecutor
+from datetime import date, timedelta
+from pathlib import Path
+
+from mcp.server.fastmcp import FastMCP
+from mcp.server.transport_security import TransportSecuritySettings
+from sentence_transformers import SentenceTransformer
+from starlette.applications import Starlette
+from starlette.requests import Request
+from starlette.responses import PlainTextResponse
+from starlette.routing import Mount, Route
+
+from papers_mcp.corpus import Corpus, Paper
+from papers_mcp.search import EMBEDDING_MODEL, SearchIndex
+
+CORPORA = {
+    "lipsync": "https://github.com/will-rice/lipsync-papers",
+    "tts": "https://github.com/will-rice/tts-papers",
+}
+DATA_DIR = Path("data")
+REFRESH_INTERVAL_SECONDS = 6 * 60 * 60
+MAX_SEARCH_LIMIT = 50
+
+corpora: dict[str, Corpus] = {}
+indexes: dict[str, SearchIndex] = {}
+
+
+def create_app() -> Starlette:
+    """Build the Starlette app mounting one MCP server per corpus (uvicorn factory)."""
+    logging.basicConfig(level=logging.INFO)
+    servers = {name: make_server(name) for name in CORPORA}
+
+    @contextlib.asynccontextmanager
+    async def lifespan(app: Starlette):
+        model = SentenceTransformer(EMBEDDING_MODEL, device="cpu")
+        with ThreadPoolExecutor() as pool:
+            list(pool.map(lambda name: build_corpus(name, model), CORPORA))
+        threading.Thread(target=refresh_loop, args=(model,), daemon=True).start()
+        async with contextlib.AsyncExitStack() as stack:
+            for server in servers.values():
+                await stack.enter_async_context(server.session_manager.run())
+            yield
+
+    async def index_page(request: Request) -> PlainTextResponse:
+        lines = ["papers-mcp — MCP servers over research paper corpora", ""]
+        lines += [f"  {CORPORA[name]}  →  /{name}/mcp" for name in CORPORA]
+        return PlainTextResponse("\n".join(lines))
+
+    routes: list[Mount | Route] = [Route("/", index_page)]
+    routes += [Mount(f"/{name}", server.streamable_http_app()) for name, server in servers.items()]
+    return Starlette(routes=routes, lifespan=lifespan)
+
+
+def make_server(name: str) -> FastMCP:
+    """Create the FastMCP server (and its four tools) for one corpus."""
+    import os
+
+    enable_dns_rebinding_protection = os.getenv("MCP_ENABLE_DNS_REBINDING_PROTECTION", "0") == "1"
+
+    mcp = FastMCP(
+        name=f"{name}-papers",
+        instructions=(
+            f"Query the {name}-papers research corpus ({CORPORA[name]}): "
+            "search titles/abstracts, read full papers as markdown, follow the "
+            "in-corpus citation graph, and list recent papers."
+        ),
+        stateless_http=True,
+        json_response=True,
+        # This server is mounted into a Starlette app (not run standalone via
+        # mcp.run()), so FastMCP's own Host-header DNS-rebinding heuristic --
+        # which only ever allowlists 127.0.0.1/localhost -- would 421 every
+        # request once deployed under a real hostname. Access control belongs
+        # at the reverse-proxy/deployment layer instead.
+        transport_security=TransportSecuritySettings(
+            enable_dns_rebinding_protection=enable_dns_rebinding_protection
+        ),
+    )
+
+    @mcp.tool()
+    def search_papers(query: str, limit: int = 10) -> str:
+        """Hybrid keyword + semantic search over paper titles, abstracts, and authors.
+
+        Returns the top matches with paper id, title, authors, submission date,
+        and abstract. Use the paper id with get_paper or get_citations.
+        """
+        if not query.strip():
+            raise ValueError("query must be non-empty")
+        if not 1 <= limit <= MAX_SEARCH_LIMIT:
+            raise ValueError(f"limit must be between 1 and {MAX_SEARCH_LIMIT}")
+        results = indexes[name].search(query, limit)
+        return "\n\n".join(format_paper(paper) for paper in results)
+
+    @mcp.tool()
+    def get_paper(paper_id: str) -> str:
+        """Return the paper's full converted markdown (methods, figures, references)."""
+        paper = lookup(corpora[name].papers, name, paper_id)
+        if paper.md_path is None:
+            raise ValueError(
+                f"{paper_id} has no converted markdown; its metadata and abstract "
+                "are available via search_papers"
+            )
+        return paper.markdown
+
+    @mcp.tool()
+    def get_citations(paper_id: str) -> str:
+        """List in-corpus papers this paper cites, and in-corpus papers citing it."""
+        # One snapshot: the refresh loop may swap corpora[name] between reads,
+        # so resolve the paper and its cited titles from the same generation.
+        papers = corpora[name].papers
+        paper = lookup(papers, name, paper_id)
+
+        def title_list(ids: list[str]) -> str:
+            if not ids:
+                return "(none in corpus)"
+            return "\n".join(f"- {pid}: {papers[pid].title}" for pid in ids)
+
+        return (
+            f"## Cites ({len(paper.cites)})\n{title_list(paper.cites)}\n\n"
+            f"## Cited by ({len(paper.cited_by)})\n{title_list(paper.cited_by)}"
+        )
+
+    @mcp.tool()
+    def list_recent(days: int = 30) -> str:
+        """List papers submitted in the last N days, newest first."""
+        if days < 1:
+            raise ValueError("days must be at least 1")
+        cutoff = (date.today() - timedelta(days=days)).isoformat()
+        recent = sorted(
+            (p for p in corpora[name].papers.values() if p.submitted >= cutoff),
+            key=lambda p: p.submitted,
+            reverse=True,
+        )
+        if not recent:
+            return f"No papers submitted in the last {days} days."
+        return "\n\n".join(format_paper(paper) for paper in recent)
+
+    return mcp
+
+
+def build_corpus(name: str, model: SentenceTransformer) -> None:
+    """Sync, load, and index one corpus, then swap it into the registry."""
+    corpus = Corpus(name=name, repo_url=CORPORA[name], clone_dir=DATA_DIR / f"{name}-papers")
+    corpus.sync()
+    corpus.load()
+    index = SearchIndex(list(corpus.papers.values()), model)
+    corpora[name] = corpus
+    indexes[name] = index
+
+
+def refresh_loop(model: SentenceTransformer) -> None:
+    """Re-sync and re-index every corpus on an interval; keep the old index on failure."""
+    while True:
+        time.sleep(REFRESH_INTERVAL_SECONDS)
+        for name in CORPORA:
+            try:
+                build_corpus(name, model)
+            except Exception:
+                logging.exception("refresh failed for %s; serving previous index", name)
+
+
+def lookup(papers: dict[str, Paper], name: str, paper_id: str) -> Paper:
+    """Return the paper for *paper_id* in *papers*, raising a concise error when unknown."""
+    paper = papers.get(paper_id)
+    if paper is None:
+        raise ValueError(f"paper id {paper_id!r} not found in the {name} corpus")
+    return paper
+
+
+def format_paper(paper: Paper) -> str:
+    """One search/listing hit as compact markdown."""
+    return (
+        f"**{paper.title}** ({paper.paper_id}, {paper.submitted})\n"
+        f"{paper.authors}\n"
+        f"{paper.abstract}"
+    )

tests/conftest.py

@@ -0,0 +1,24 @@
+"""Shared fixtures: a real lipsync-papers clone, cached across test runs."""
+
+from pathlib import Path
+
+import pytest
+
+from papers_mcp.corpus import Corpus
+
+CACHE_DIR = Path(__file__).parent / ".cache"
+LIPSYNC_REPO = "https://github.com/will-rice/lipsync-papers"
+
+
+@pytest.fixture(scope="session")
+def lipsync_corpus() -> Corpus:
+    corpus = Corpus(name="lipsync", repo_url=LIPSYNC_REPO, clone_dir=CACHE_DIR / "lipsync-papers")
+    corpus.sync()
+    corpus.load()
+    return corpus
+
+
+@pytest.fixture(scope="module")
+def monkeypatch_module():
+    with pytest.MonkeyPatch.context() as mp:
+        yield mp

tests/test_corpus.py

@@ -0,0 +1,31 @@
+"""Tests for corpus syncing and loading against the real lipsync-papers repo."""
+
+from papers_mcp.corpus import Corpus
+
+
+def test_sync_clones_then_pulls(lipsync_corpus: Corpus) -> None:
+    assert (lipsync_corpus.clone_dir / "papers.csv").exists()
+    # Second sync takes the pull path and must not raise.
+    lipsync_corpus.sync()
+    assert (lipsync_corpus.clone_dir / "papers.csv").exists()
+
+
+def test_load_populates_papers(lipsync_corpus: Corpus) -> None:
+    assert len(lipsync_corpus.papers) > 500
+    latentsync = lipsync_corpus.papers["2412.09262"]
+    assert "LatentSync" in latentsync.title
+    assert latentsync.md_path is not None and latentsync.md_path.exists()
+    assert latentsync.submitted == "2024-12-12"
+
+
+def test_readme_files_are_not_papers(lipsync_corpus: Corpus) -> None:
+    assert "README" not in lipsync_corpus.papers
+
+
+def test_citation_graph_is_consistent(lipsync_corpus: Corpus) -> None:
+    papers = lipsync_corpus.papers
+    assert any(p.cites for p in papers.values())
+    for paper in papers.values():
+        for cited_id in paper.cites:
+            assert cited_id in papers
+            assert paper.paper_id in papers[cited_id].cited_by

tests/test_search.py

@@ -0,0 +1,29 @@
+"""Search tests against the real lipsync corpus."""
+
+import pytest
+from sentence_transformers import SentenceTransformer
+
+from papers_mcp.corpus import Corpus
+from papers_mcp.search import EMBEDDING_MODEL, SearchIndex
+
+
+@pytest.fixture(scope="session")
+def lipsync_index(lipsync_corpus: Corpus) -> SearchIndex:
+    model = SentenceTransformer(EMBEDDING_MODEL, device="cpu")
+    return SearchIndex(list(lipsync_corpus.papers.values()), model)
+
+
+def test_keyword_query_finds_latentsync(lipsync_index: SearchIndex) -> None:
+    results = lipsync_index.search("latent diffusion lip sync SyncNet", limit=10)
+    assert "2412.09262" in [p.paper_id for p in results]
+
+
+def test_semantic_query_returns_relevant_papers(lipsync_index: SearchIndex) -> None:
+    results = lipsync_index.search("make the mouth match new audio in a video", limit=5)
+    assert len(results) == 5
+    haystack = " ".join(f"{p.title} {p.abstract}".lower() for p in results)
+    assert "lip" in haystack
+
+
+def test_limit_is_respected(lipsync_index: SearchIndex) -> None:
+    assert len(lipsync_index.search("talking head", limit=3)) == 3

tests/test_server.py

@@ -0,0 +1,99 @@
+"""End-to-end MCP wire tests over the mounted lipsync endpoint."""
+
+import pytest
+from starlette.testclient import TestClient
+
+from papers_mcp import server
+from tests.conftest import CACHE_DIR, LIPSYNC_REPO
+
+MCP_HEADERS = {
+    "Accept": "application/json, text/event-stream",
+    "Content-Type": "application/json",
+}
+
+
+def rpc(method: str, params: dict) -> dict:
+    return {"jsonrpc": "2.0", "id": 1, "method": method, "params": params}
+
+
+@pytest.fixture(scope="module")
+def client(monkeypatch_module, lipsync_corpus) -> TestClient:
+    monkeypatch_module.setattr(server, "CORPORA", {"lipsync": LIPSYNC_REPO})
+    monkeypatch_module.setattr(server, "DATA_DIR", CACHE_DIR)
+    app = server.create_app()
+    with TestClient(app) as test_client:  # runs lifespan: sync + load + index
+        yield test_client
+
+
+def test_tools_are_listed(client: TestClient) -> None:
+    resp = client.post("/lipsync/mcp", json=rpc("tools/list", {}), headers=MCP_HEADERS)
+    assert resp.status_code == 200
+    tools = {t["name"] for t in resp.json()["result"]["tools"]}
+    assert tools == {"search_papers", "get_paper", "get_citations", "list_recent"}
+
+
+def test_search_papers_tool(client: TestClient) -> None:
+    resp = client.post(
+        "/lipsync/mcp",
+        json=rpc(
+            "tools/call",
+            {"name": "search_papers", "arguments": {"query": "latent diffusion lip sync SyncNet"}},
+        ),
+        headers=MCP_HEADERS,
+    )
+    text = resp.json()["result"]["content"][0]["text"]
+    assert "2412.09262" in text
+
+
+def test_get_paper_tool(client: TestClient) -> None:
+    resp = client.post(
+        "/lipsync/mcp",
+        json=rpc("tools/call", {"name": "get_paper", "arguments": {"paper_id": "2412.09262"}}),
+        headers=MCP_HEADERS,
+    )
+    text = resp.json()["result"]["content"][0]["text"]
+    assert "LatentSync" in text and len(text) > 5000
+
+
+def test_unknown_paper_id_is_an_error(client: TestClient) -> None:
+    resp = client.post(
+        "/lipsync/mcp",
+        json=rpc("tools/call", {"name": "get_paper", "arguments": {"paper_id": "0000.00000"}}),
+        headers=MCP_HEADERS,
+    )
+    assert resp.json()["result"]["isError"] is True
+
+
+def test_blank_query_is_an_error(client: TestClient) -> None:
+    resp = client.post(
+        "/lipsync/mcp",
+        json=rpc("tools/call", {"name": "search_papers", "arguments": {"query": "  "}}),
+        headers=MCP_HEADERS,
+    )
+    assert resp.json()["result"]["isError"] is True
+
+
+def test_get_citations_tool(client: TestClient) -> None:
+    resp = client.post(
+        "/lipsync/mcp",
+        json=rpc("tools/call", {"name": "get_citations", "arguments": {"paper_id": "2412.09262"}}),
+        headers=MCP_HEADERS,
+    )
+    text = resp.json()["result"]["content"][0]["text"]
+    assert "Cites" in text and "Cited by" in text
+
+
+def test_list_recent_tool(client: TestClient) -> None:
+    import re
+    from datetime import date, timedelta
+
+    resp = client.post(
+        "/lipsync/mcp",
+        json=rpc("tools/call", {"name": "list_recent", "arguments": {"days": 365}}),
+        headers=MCP_HEADERS,
+    )
+    text = resp.json()["result"]["content"][0]["text"]
+    dates = re.findall(r", (\d{4}-\d{2}-\d{2})\)", text)
+    assert len(dates) > 5
+    assert dates == sorted(dates, reverse=True)  # newest first
+    assert min(dates) >= (date.today() - timedelta(days=365)).isoformat()