retrieval-mcp 0.1.0__tar.gz

retrieval_mcp-0.1.0/.gitignore

@@ -0,0 +1,60 @@
+__pycache__/
+*.pyc
+*.pyo
+
+# Virtual environments
+.venv/
+.ropeproject/
+
+# IDE / Claude Code
+.claude/
+.omc/
+.omx/
+.pytest_cache/
+
+# Data (150GB+ corpus, DB, indices)
+data/
+snapshots/
+
+# Code KB local Qdrant + eval scratch / ACE project-local playbook (per-project state)
+.code_kb/
+.ace/
+
+# Qdrant binary
+tools/qdrant/
+
+# Frontend build artifacts
+frontend/node_modules/
+frontend/dist/
+
+# Logs
+*.log
+myeasylog.log
+
+# Temp files
+tmp_*
+nul
+.qdrant-initialized
+
+# Secrets
+.env
+*.key
+*.pem
+
+# Gateway (app-tier) — secrets + local ledger, never commit
+gateway.env
+deploy/bwh/gateway.env
+gateway-data/
+gateway.db
+gateway.db-shm
+gateway.db-wal
+
+# wrangler / analysis artifacts (not source)
+.wrangler/
+frontend/public/landscape.json
+
+# OS
+Thumbs.db
+.DS_Store
+desktop.ini
+.playwright-mcp/

retrieval_mcp-0.1.0/.mcp.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "retrieval": {
+      "command": "uvx",
+      "args": ["retrieval-mcp"],
+      "env": {
+        "RETRIEVAL_API_URL": "http://10.100.100.111:8000"
+      }
+    }
+  }
+}

retrieval_mcp-0.1.0/PKG-INFO

@@ -0,0 +1,82 @@
+Metadata-Version: 2.4
+Name: retrieval-mcp
+Version: 0.1.0
+Summary: Installable MCP server for the Retrieval academic-paper search + ACE journal + index inventory API
+Project-URL: Homepage, https://retrieval.rnarket.com
+License: MIT
+Keywords: llm,mcp,model-context-protocol,papers,retrieval,search
+Requires-Python: >=3.10
+Requires-Dist: httpx>=0.27
+Requires-Dist: mcp>=1.2.0
+Description-Content-Type: text/markdown
+
+# retrieval-mcp
+
+An **MCP server** for the Retrieval academic-paper API — semantic paper search,
+document matching, ACE journal memory, and index inventory. Self-contained: it talks
+to the backend over HTTP only (just `mcp` + `httpx`), so it installs anywhere with
+`uvx` / `pip` — no repo checkout, no GPU, no models.
+
+By default it targets the compute box on the lab LAN (`http://10.100.100.111:8000`),
+which trusts LAN callers so **no key is needed**. Off-LAN, point `RETRIEVAL_API_URL` at
+the public gateway (`https://retrieval.rnarket.com`) and set `RETRIEVAL_API_KEY` (`sk-...`).
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `search_papers` | Semantic hybrid search over 95k+ top-venue CS papers |
+| `search_within_paper` | Every matching passage inside one paper |
+| `match_document` / `match_paper` | Content-nearest papers to a passage / a paper |
+| `list_conferences` / `corpus_stats` | Venue registry / corpus size |
+| `journal_record` / `journal_search` / `journal_recent` | ACE journal work-memory (cwd-scoped) |
+| `index_inventory` | Your indexed-file tree: user → host → project → dir → file |
+
+## Install
+
+### Claude Code
+
+```bash
+# LAN (no key):
+claude mcp add retrieval -- uvx retrieval-mcp
+# Off-LAN (public gateway + key):
+claude mcp add retrieval \
+  --env RETRIEVAL_API_URL=https://retrieval.rnarket.com \
+  --env RETRIEVAL_API_KEY=sk-... \
+  -- uvx retrieval-mcp
+```
+
+### Claude Desktop / any MCP client
+
+`claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/`,
+Windows: `%APPDATA%\Claude\`):
+
+```json
+{
+  "mcpServers": {
+    "retrieval": {
+      "command": "uvx",
+      "args": ["retrieval-mcp"],
+      "env": {
+        "RETRIEVAL_API_URL": "https://retrieval.rnarket.com",
+        "RETRIEVAL_API_KEY": "sk-...",
+        "JOURNAL_PROJECT_SLUG": "my-project"
+      }
+    }
+  }
+}
+```
+
+No `uv`? `pip install retrieval-mcp` then use `"command": "retrieval-mcp"`.
+
+## Config (env)
+
+| Var | Default | Notes |
+|-----|---------|-------|
+| `RETRIEVAL_API_URL` | `http://10.100.100.111:8000` | LAN compute box (no key). Off-LAN, set to `https://retrieval.rnarket.com`. |
+| `RETRIEVAL_API_KEY` | — | `sk-...` key for the gateway (create under `/auth/keys`). Required off-LAN. |
+| `JOURNAL_PROJECT_SLUG` | current dir name | Journal namespace; scopes journal reads/writes so projects don't leak into each other. |
+
+## License
+
+MIT

retrieval_mcp-0.1.0/README.md

@@ -0,0 +1,70 @@
+# retrieval-mcp
+
+An **MCP server** for the Retrieval academic-paper API — semantic paper search,
+document matching, ACE journal memory, and index inventory. Self-contained: it talks
+to the backend over HTTP only (just `mcp` + `httpx`), so it installs anywhere with
+`uvx` / `pip` — no repo checkout, no GPU, no models.
+
+By default it targets the compute box on the lab LAN (`http://10.100.100.111:8000`),
+which trusts LAN callers so **no key is needed**. Off-LAN, point `RETRIEVAL_API_URL` at
+the public gateway (`https://retrieval.rnarket.com`) and set `RETRIEVAL_API_KEY` (`sk-...`).
+
+## Tools
+
+| Tool | What it does |
+|------|--------------|
+| `search_papers` | Semantic hybrid search over 95k+ top-venue CS papers |
+| `search_within_paper` | Every matching passage inside one paper |
+| `match_document` / `match_paper` | Content-nearest papers to a passage / a paper |
+| `list_conferences` / `corpus_stats` | Venue registry / corpus size |
+| `journal_record` / `journal_search` / `journal_recent` | ACE journal work-memory (cwd-scoped) |
+| `index_inventory` | Your indexed-file tree: user → host → project → dir → file |
+
+## Install
+
+### Claude Code
+
+```bash
+# LAN (no key):
+claude mcp add retrieval -- uvx retrieval-mcp
+# Off-LAN (public gateway + key):
+claude mcp add retrieval \
+  --env RETRIEVAL_API_URL=https://retrieval.rnarket.com \
+  --env RETRIEVAL_API_KEY=sk-... \
+  -- uvx retrieval-mcp
+```
+
+### Claude Desktop / any MCP client
+
+`claude_desktop_config.json` (macOS: `~/Library/Application Support/Claude/`,
+Windows: `%APPDATA%\Claude\`):
+
+```json
+{
+  "mcpServers": {
+    "retrieval": {
+      "command": "uvx",
+      "args": ["retrieval-mcp"],
+      "env": {
+        "RETRIEVAL_API_URL": "https://retrieval.rnarket.com",
+        "RETRIEVAL_API_KEY": "sk-...",
+        "JOURNAL_PROJECT_SLUG": "my-project"
+      }
+    }
+  }
+}
+```
+
+No `uv`? `pip install retrieval-mcp` then use `"command": "retrieval-mcp"`.
+
+## Config (env)
+
+| Var | Default | Notes |
+|-----|---------|-------|
+| `RETRIEVAL_API_URL` | `http://10.100.100.111:8000` | LAN compute box (no key). Off-LAN, set to `https://retrieval.rnarket.com`. |
+| `RETRIEVAL_API_KEY` | — | `sk-...` key for the gateway (create under `/auth/keys`). Required off-LAN. |
+| `JOURNAL_PROJECT_SLUG` | current dir name | Journal namespace; scopes journal reads/writes so projects don't leak into each other. |
+
+## License
+
+MIT

retrieval_mcp-0.1.0/pyproject.toml

@@ -0,0 +1,28 @@
+[project]
+name = "retrieval-mcp"
+version = "0.1.0"
+description = "Installable MCP server for the Retrieval academic-paper search + ACE journal + index inventory API"
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["mcp", "model-context-protocol", "retrieval", "papers", "search", "llm"]
+dependencies = [
+    "mcp>=1.2.0",
+    "httpx>=0.27",
+]
+
+[project.urls]
+Homepage = "https://retrieval.rnarket.com"
+
+[project.scripts]
+retrieval-mcp = "retrieval_mcp:main"
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[tool.hatch.build.targets.wheel]
+only-include = ["retrieval_mcp.py"]
+
+[tool.hatch.build.targets.wheel.sources]
+"retrieval_mcp.py" = "retrieval_mcp.py"

retrieval_mcp-0.1.0/retrieval_mcp.py

@@ -0,0 +1,354 @@
+#!/usr/bin/env python3
+# /// script
+# requires-python = ">=3.10"
+# dependencies = ["mcp>=1.2.0", "httpx>=0.27"]
+# ///
+"""Retrieval MCP — a self-contained, installable MCP server.
+
+Unlike the in-repo ``mcp_server/`` (which also hosts the local code KB and needs the
+project's Python modules), THIS file is standalone: it only talks to the Retrieval
+REST API over HTTP, so it installs anywhere with just ``mcp`` + ``httpx`` and needs
+no checkout, no GPU, no models.
+
+Default target is the compute box directly:  http://10.100.100.111:8000
+On the lab LAN that is trusted as an internal admin, so no key is needed. Off-LAN,
+point RETRIEVAL_API_URL at the public gateway and set RETRIEVAL_API_KEY (sk-...).
+
+Config (env):
+  RETRIEVAL_API_URL     backend base URL   (default http://10.100.100.111:8000)
+  RETRIEVAL_API_KEY     sk-key for the paid gateway (optional; unset on LAN)
+  JOURNAL_PROJECT_SLUG  override the journal project namespace (default: cwd dir name)
+
+  (The misspelled legacy names RETRIVAL_API_URL / RETRIVAL_API_KEY are still honored
+  as a fallback so existing configs keep working.)
+
+Run:
+  uvx retrieval-mcp                # or: uv run retrieval_mcp.py
+  python retrieval_mcp.py          # if mcp + httpx are already installed
+"""
+from __future__ import annotations
+
+import glob
+import os
+import socket
+from typing import Any
+
+import httpx
+from mcp.server.fastmcp import FastMCP
+
+
+# NOTE: intentionally duplicated in mcp_server/server.py — this file ships as a
+# zero-dependency standalone package (pyproject bundles ONLY this file), so it must
+# not import from the repo. Keep the two copies identical.
+def _env(*names: str, default: str | None = None) -> str | None:
+    """First set value among `names` (new spelling first, legacy fallback), else default."""
+    for name in names:
+        value = os.environ.get(name)
+        if value:
+            return value
+    return default
+
+
+BASE_URL = (_env("RETRIEVAL_API_URL", "RETRIVAL_API_URL",
+                 default="http://10.100.100.111:8000") or "").rstrip("/")
+API_KEY = _env("RETRIEVAL_API_KEY", "RETRIVAL_API_KEY")
+_HEADERS = {"Authorization": f"Bearer {API_KEY}"} if API_KEY else {}
+_TIMEOUT = 180.0
+
+
+def _default_project() -> str:
+    """Journal project scope, defaulting to the current working directory's name.
+
+    Precedence: explicit ``JOURNAL_PROJECT_SLUG`` env > cwd basename > ``"default"``.
+    Scoping journal reads/writes to the cwd project by default keeps one project's
+    memory out of another's results; pass ``project_slug=...`` to a tool to override.
+    """
+    env = os.environ.get("JOURNAL_PROJECT_SLUG")
+    if env:
+        return env
+    try:
+        base = os.path.basename(os.getcwd()).strip().lower()
+        return base or "default"
+    except OSError:
+        return "default"
+
+mcp = FastMCP("retrieval")
+
+
+async def _post(path: str, payload: dict) -> dict:
+    async with httpx.AsyncClient(base_url=BASE_URL, timeout=_TIMEOUT) as c:
+        r = await c.post(path, json=payload, headers=_HEADERS)
+        r.raise_for_status()
+        return r.json()
+
+
+async def _get(path: str, params: dict | None = None) -> dict:
+    async with httpx.AsyncClient(base_url=BASE_URL, timeout=_TIMEOUT) as c:
+        r = await c.get(path, params=params or {}, headers=_HEADERS)
+        r.raise_for_status()
+        return r.json()
+
+
+def _snippet(text: str, limit: int = 280) -> str:
+    text = " ".join((text or "").split())
+    return text if len(text) <= limit else text[:limit].rstrip() + "…"
+
+
+# ------------------------------- paper retrieval ------------------------------- #
+
+@mcp.tool()
+async def search_papers(query: str, top_k: int = 10, venue: str | None = None,
+                        year: int | None = None, title_only: bool = False) -> str:
+    """Semantic hybrid search over 94k+ top-venue CS papers. Phrase the query as a
+    full, specific description (not a bare keyword). Returns title + venue/year +
+    paper_id + snippet. Pass paper_id to search_within_paper / match_paper."""
+    payload: dict[str, Any] = {"query": query, "top_k": top_k, "method": "hybrid",
+                               "title_only": title_only, "dedup_by_paper": True}
+    if venue:
+        payload["venue"] = venue
+    if year:
+        payload["year"] = year
+    return _fmt_papers(await _post("/api/search", payload))
+
+
+@mcp.tool()
+async def search_within_paper(paper_id: str, query: str, top_k: int = 20) -> str:
+    """Search inside ONE paper; returns every matching passage with its score."""
+    payload = {"query": query, "top_k": top_k, "paper_ids": [paper_id],
+               "dedup_by_paper": False, "method": "hybrid"}
+    return _fmt_papers(await _post("/api/search", payload))
+
+
+@mcp.tool()
+async def match_document(text: str, top_k: int = 10) -> str:
+    """Find corpus papers whose CONTENT is most similar to a passage (related-work
+    discovery). Aggregated per paper by coverage."""
+    return _fmt_match(await _post("/api/match-doc",
+                                  {"input_type": "text", "text": text, "top_k": top_k}))
+
+
+@mcp.tool()
+async def match_paper(paper_id: str, top_k: int = 10) -> str:
+    """Content-nearest neighbours of an already-indexed paper (self excluded)."""
+    return _fmt_match(await _post("/api/match-doc",
+                                  {"input_type": "paper_id", "paper_id": paper_id, "top_k": top_k}))
+
+
+@mcp.tool()
+async def list_conferences() -> str:
+    """List venues in the corpus with CCF tier + years available."""
+    resp = await _get("/api/conferences")
+    confs = resp.get("conferences") or []
+    lines = [f"{len(confs)} venues:"]
+    for c in confs:
+        years = c.get("years") or []
+        yr = f"{min(years)}-{max(years)}" if years else "?"
+        lines.append(f"- {c.get('title', c.get('sub', '?'))} [{c.get('venue_tier', '?')}] {yr}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+async def corpus_stats() -> str:
+    """Corpus size: papers, chunks, vectors, embedding model."""
+    r = await _get("/api/stats")
+    return (f"Corpus: {r.get('total_papers', '?')} papers, {r.get('total_chunks', '?')} chunks, "
+            f"{r.get('vector_index_size', '?')} vectors ({r.get('embedding_model', '?')}).")
+
+
+# ------------------------------ journal memory -------------------------------- #
+
+@mcp.tool()
+async def journal_record(body: str, project_slug: str | None = None, title: str | None = None,
+                         source_kind: str = "memory", tags: list[str] | None = None) -> str:
+    """Record this session's detailed work memory into the authenticated journal.
+
+    Scoped to the current project by default (cwd name); pass project_slug to override.
+    Example: journal_record(body="Fixed the RRF fusion off-by-one in pipeline.py; root
+    cause was 0-indexed rank. Verified with test_pipeline_rrf.", title="RRF rank fix",
+    tags=["bugfix","retrieval"]).
+    """
+    payload: dict[str, Any] = {"project_slug": project_slug or _default_project(), "client": "mcp",
+                               "source_kind": source_kind, "body": body, "tags": tags or []}
+    if title:
+        payload["title"] = title
+    resp = await _post("/api/journal/entries", payload)
+    e = resp.get("entry") or {}
+    return (f"Recorded {e.get('entry_id', '?')} "
+            f"(chunks={resp.get('chunk_count', 0)}, indexed={resp.get('indexed', False)}).")
+
+
+@mcp.tool()
+async def journal_search(query: str, project_slug: str | None = None, top_k: int = 5,
+                         mode: str = "keyword", dedup_by_entry: bool = True) -> str:
+    """Search journal memory, scoped to the current project by default (cwd name) so
+    other projects' notes don't leak into results — pass project_slug to widen/switch.
+
+    mode="keyword" (default, FTS5, needs no embedding — always works) or
+    "hybrid"/"dense"/"sparse" (semantic; needs the embed endpoint up).
+    Example: journal_search(query="qdrant upsert wait flag", mode="keyword").
+    """
+    resp = await _post("/api/journal/search", {"project_slug": project_slug or _default_project(),
+                                               "query": query, "top_k": top_k, "mode": mode,
+                                               "dedup_by_entry": dedup_by_entry,
+                                               "include_chunks": True})
+    hits = resp.get("hits") or []
+    if not hits:
+        return "No matching journal entries found."
+    lines = [f"Found {len(hits)} journal entries ({resp.get('mode', '?')}):", ""]
+    for i, hit in enumerate(hits, 1):
+        e = hit.get("entry") or {}
+        chunk = hit.get("best_chunk") or {}
+        lines.append(f"{i}. {e.get('title') or e.get('entry_id')} "
+                     f"[{e.get('source_kind', '?')}] score={hit.get('score', 0.0):.3f}")
+        lines.append(f"   entry_id: {e.get('entry_id', '')}")
+        if chunk.get("content"):
+            lines.append(f"   ▸ {_snippet(chunk.get('content', ''))}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+async def journal_recent(project_slug: str | None = None, limit: int = 10) -> str:
+    """List recent journal entries for the current project (cwd name by default;
+    pass project_slug to override). Example: journal_recent(limit=5)."""
+    resp = await _get("/api/journal/entries",
+                      {"project_slug": project_slug or _default_project(), "limit": limit})
+    entries = resp.get("entries") or []
+    if not entries:
+        return "No recent journal entries found."
+    lines = [f"Recent journal entries ({len(entries)} of {resp.get('total', len(entries))}):", ""]
+    for i, e in enumerate(entries, 1):
+        lines.append(f"{i}. {e.get('title') or e.get('entry_id')} [{e.get('source_kind', '?')}]  "
+                     f"{e.get('entry_id', '')}")
+    return "\n".join(lines)
+
+
+@mcp.tool()
+async def journal_index_dir(
+    dir: str = ".",
+    project_slug: str | None = None,
+    recursive: bool = False,
+    pattern: str = "*.md",
+) -> str:
+    """Batch-index every matching text file in a LOCAL directory into the journal,
+    then register them in your index inventory — the bulk counterpart to journal_record.
+
+    Runs where THIS server runs (your machine): reads each file locally, sends its
+    CONTENT to the backend as a journal entry (so the full text is searchable via
+    journal_search), and reports the file list to your inventory (so index_inventory
+    shows them). Non-recursive by default. Safe to re-run (incremental upsert).
+
+    Example: journal_index_dir(dir="~/Prd/retrival", pattern="*.md") — index the repo's
+    root Markdown files into the cwd-named project.
+
+    Args:
+        dir: Directory to index (default: current directory).
+        project_slug: Journal project namespace. Default = cwd dir name.
+        recursive: Recurse into subdirectories (default: false — root files only).
+            Note: dot-dirs (.git/.venv) are skipped by glob, but non-dot junk dirs
+            (node_modules, etc.) are not — point `dir` at a clean docs tree.
+        pattern: Glob for files to index (default: "*.md").
+    """
+    project = project_slug or _default_project()
+    root = os.path.abspath(os.path.expanduser(dir))
+    globpat = os.path.join(glob.escape(root), "**", pattern) if recursive else os.path.join(glob.escape(root), pattern)
+    files = sorted(p for p in glob.glob(globpat, recursive=recursive) if os.path.isfile(p))
+    if not files:
+        return f"No files matching {pattern!r} in {root} (recursive={recursive})."
+
+    indexed = failed = 0
+    records: list[dict[str, Any]] = []
+    for path in files:
+        try:
+            with open(path, encoding="utf-8", errors="replace") as fh:
+                content = fh.read()
+            if not content.strip():
+                continue
+            resp = await _post("/api/journal/entries", {
+                "project_slug": project, "client": "mcp", "source_kind": "doc",
+                "title": os.path.basename(path), "body": content, "tags": [],
+            })
+            indexed += 1
+            records.append({
+                "rel_path": os.path.relpath(path, root), "kind": "doc",
+                "collection": "journal_chunks", "chunk_count": resp.get("chunk_count", 0),
+            })
+        except Exception:  # noqa: BLE001 — keep going; one bad file shouldn't abort the batch
+            failed += 1
+
+    host = _env("RETRIEVAL_HOST", "RETRIVAL_HOST", default=socket.gethostname())
+    reported = 0
+    try:
+        rep = await _post("/api/index/report", {
+            "host": host, "project": project, "root_dir": root, "files": records, "replace": False,
+        })
+        reported = rep.get("total_files", len(records))
+    except Exception as exc:  # noqa: BLE001 — inventory reporting is best-effort
+        return (f"Indexed {indexed} file(s) into journal '{project}' ({failed} failed); "
+                f"inventory report skipped: {exc}")
+    return (f"Indexed {indexed} file(s) into journal '{project}' ({failed} failed); "
+            f"reported {reported} to inventory (host={host}).")
+
+
+@mcp.tool()
+async def index_inventory(host: str | None = None, project: str | None = None) -> str:
+    """Show YOUR indexed-file inventory: user → host → project → dir → file."""
+    params = {k: v for k, v in {"host": host, "project": project}.items() if v}
+    resp = await _get("/api/index/inventory", params)
+    users = resp.get("users") or []
+    t = resp.get("totals") or {}
+    if not users:
+        return "No indexed files reported yet."
+    lines = [f"Inventory: {t.get('hosts', 0)} host(s), {t.get('projects', 0)} project(s), "
+             f"{t.get('files', 0)} file(s), {t.get('chunks', 0)} chunk(s).", ""]
+    for u in users:
+        lines.append(f"● {u.get('owner_user_id', '?')} ({u.get('file_count', 0)} files)")
+        for h in u.get("hosts") or []:
+            lines.append(f"  ▸ {h.get('host', '?')}")
+            for p in h.get("projects") or []:
+                lines.append(f"    · {p.get('project', '?')} [{p.get('root_dir') or '?'}] "
+                             f"({p.get('file_count', 0)} files)")
+    return "\n".join(lines)
+
+
+# ------------------------------ shared formatters ----------------------------- #
+
+def _fmt_papers(resp: dict) -> str:
+    papers = resp.get("papers") or []
+    if not papers:
+        return "No matching papers found."
+    lines = [f"Found {len(papers)} papers:", ""]
+    for i, p in enumerate(papers, 1):
+        meta = p.get("metadata") or {}
+        venue = meta.get("venue") or p.get("venue") or "?"
+        year = meta.get("year") or p.get("year") or "?"
+        title = p.get("doc_title") or p.get("title") or "(untitled)"
+        score = p.get("max_score", p.get("score", 0.0))
+        lines.append(f"{i}. {title}  [{venue} {year}]  score={score:.3f}")
+        lines.append(f"   paper_id: {p.get('paper_id') or ''}")
+        chunks = p.get("chunks") or []
+        if chunks:
+            lines.append(f"   ▸ {_snippet(chunks[0].get('content', ''))}")
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+def _fmt_match(resp: dict) -> str:
+    papers = resp.get("papers") or []
+    if not papers:
+        return "No similar papers found."
+    lines = [f"Top {len(papers)} content-nearest papers:", ""]
+    for i, p in enumerate(papers, 1):
+        lines.append(f"{i}. {p.get('title') or '(untitled)'}  [{p.get('venue', '?')} "
+                     f"{p.get('year', '?')}]  score={p.get('score', 0.0):.3f}  "
+                     f"coverage={p.get('coverage', 0)}")
+        lines.append(f"   paper_id: {p.get('paper_id') or ''}")
+        lines.append("")
+    return "\n".join(lines).rstrip()
+
+
+def main() -> None:
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()