Scholar Sidekick MCP Server

MCP server for Scholar Sidekick — catch AI-fabricated citations, one at a time or across a whole bibliography, from any AI assistant. It also checks retraction and open-access status, and resolves any scholarly identifier (DOI, PMID, PMCID, ISBN, arXiv, ISSN, NASA ADS bibcode, WHO IRIS URL) into 10,000+ CSL styles or nine export formats.

Highlights

• Citation-fabrication detection — `verifyCitation` cross-checks a claimed citation against the resolved record at its identifier, detecting the dominant AI-driven fabrication pattern documented by Topaz et al. (Lancet 2026)00603-3) — real DOI + invented title — that simple identifier resolution cannot catch. Long-form explainer at scholar-sidekick.com/citation-integrity.
• Whole-bibliography audit — `auditBibliography` runs that same check plus a retraction lookup across an entire reference list in one call, taking raw BibTeX, RIS, or CSL JSON and returning a per-entry verdict table with a corpus summary.
• Retraction & open-access checks — `checkRetraction` surfaces retractions, corrections, and expressions of concern (Crossref / Retraction Watch); `checkOpenAccess` returns OA status and the best legal landing or PDF URL (Unpaywall). Both accept any identifier type and resolve it to a DOI under the hood.
• Eight identifier types out of the box — DOIs, PMIDs, PMCIDs, ISBNs, arXiv IDs, ISSNs, NASA ADS bibcodes, and WHO IRIS URLs (rare in citation tooling).
• Batch-friendly resolve / format / export — each accepts a single identifier or a comma- or newline-separated list; the server normalises the list and resolves them in one round trip.
• 10,000+ citation styles — five hand-tuned builtins (Vancouver, AMA, APA, IEEE, CSE) plus any CSL style ID, with alias and dependent-style resolution.
• Nine export formats — BibTeX, RIS, CSL JSON, EndNote (XML/Refer), RefWorks, MEDLINE, Zotero RDF, CSV, plain text.
• Composable workflow — chain `resolveIdentifier` → `formatCitation` → `exportCitation` in one prompt for an end-to-end "raw IDs → exportable bibliography" pipeline.
• Provenance metadata on every response — formatted output is followed by a metadata block (`requestId`, `formatter`, `styleUsed`, `warnings`) so the assistant can show users *which* engine produced each citation.
• No key required — works anonymously against the public Scholar Sidekick API (rate-limited free tier); add a free first-party `ssk_` key for higher limits, or a RapidAPI key for paid/managed tiers.
• Hosted HTTP endpoint (no install) — prefer not to run a local stdio server? Connect any HTTP-capable MCP client straight to `https://scholar-sidekick.com/api/mcp` (Streamable HTTP, same 7 tools). See Hosted HTTP endpoint.
• REST API twin — the same endpoints are available as the Scholar Sidekick REST API for non-MCP integrations.

Tools

All seven tools are read-only (`readOnlyHint: true`, `destructiveHint: false`). The exact

`tools/list` payload — descriptions, JSON Schemas, and annotations — is committed as

`tools.json` and ships in the npm tarball, so you can review the full tool

surface without running anything.

Setup

No key required. The server works anonymously against the public Scholar Sidekick API

(`https://scholar-sidekick.com`) at a rate-limited free tier — just install and go. To raise

your limits, create a free first-party `ssk_` key at

scholar-sidekick.com/account and set `SCHOLAR_API_KEY`.

For paid/managed tiers, subscribe on

RapidAPI and

set `RAPIDAPI_KEY` (which routes calls through the RapidAPI gateway).

> Prefer zero install? There's also a hosted HTTP endpoint at

> `https://scholar-sidekick.com/api/mcp` (Streamable HTTP) — connect any HTTP-capable MCP

> client directly, no `npx` needed. See Hosted HTTP endpoint

> below. The stdio package documented here is the local-install alternative (and the path for

> RapidAPI-keyed users).

Claude Desktop

Add to `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows). No key, no `env` block:

{
  "mcpServers": {
    "scholar-sidekick": {
      "command": "npx",
      "args": ["-y", "scholar-sidekick-mcp@latest"]
    }
  }
}

Only if you want higher rate limits, add an `env` block with a free `ssk_` key from

scholar-sidekick.com/account:

"env": { "SCHOLAR_API_KEY": "ssk_your-first-party-key" }

Claude Code

# Anonymous (no key):
claude mcp add scholar-sidekick -- npx -y scholar-sidekick-mcp@latest

# With a free first-party key for higher limits:
claude mcp add scholar-sidekick \
  -e SCHOLAR_API_KEY=ssk_your-first-party-key \
  -- npx -y scholar-sidekick-mcp@latest

Claude Code plugin (server + skill in one step)

This repo is also a Claude Code plugin marketplace. Installing the plugin wires

up the MCP server *and* the companion agent skill together — no separate

`claude mcp add`, no `env` block:

/plugin marketplace add mlava/scholar-sidekick-mcp
/plugin install scholar-sidekick@scholar-sidekick

The plugin runs the server anonymously (no key). For higher rate limits, add a free

`ssk_` key from scholar-sidekick.com/account

via `claude mcp add` as shown above, or use the hosted endpoint below.

Cursor / VS Code / Windsurf

Add to `.cursor/mcp.json` or `.vscode/mcp.json`. No key needed:

{
  "mcpServers": {
    "scholar-sidekick": {
      "command": "npx",
      "args": ["-y", "scholar-sidekick-mcp@latest"]
    }
  }
}

For higher rate limits, add `"env": { "SCHOLAR_API_KEY": "ssk_your-first-party-key" }`.

Run in a container (sandboxed)

The server speaks MCP over stdio and needs outbound HTTPS to the Scholar Sidekick API and

nothing else — no filesystem access, no shell. If your policy is that MCP servers don't get

host access, build the image in this repo and run it isolated:

docker build -t scholar-sidekick-mcp .

{
  "mcpServers": {
    "scholar-sidekick": {
      "command": "docker",
      "args": [
        "run", "-i", "--rm",
        "--read-only", "--cap-drop", "ALL", "--security-opt", "no-new-privileges",
        "scholar-sidekick-mcp"
      ]
    }
  }
}

`-i` is required — that's the stdio pipe. Add `"-e", "SCHOLAR_API_KEY",` to the args only if

you are passing a key for higher limits.

No image is published to a registry; build it locally so you're running a bundle you built

from source you can read.

Agent skill (optional)

Install a companion Agent Skill that teaches Claude Code, Cline, and other agents when and how to use these tools — it complements the server config above:

npx skills add mlava/scholar-sidekick-mcp

Hosted HTTP endpoint (no install)

Don't want to run a local stdio server? Scholar Sidekick is also a **hosted Streamable HTTP

MCP** at `https://scholar-sidekick.com/api/mcp` — the same seven tools, no `npx`, no local

process. It works anonymously (rate-limited free tier); add an `Authorization: Bearer ssk_…`

header (a free key from scholar-sidekick.com/account) for

higher limits.

Point any HTTP-capable MCP client at it:

{
  "mcpServers": {
    "scholar-sidekick": {
      "type": "http",
      "url": "https://scholar-sidekick.com/api/mcp"
    }
  }
}

In Claude Desktop, use Settings → Connectors → Add custom connector (or "Add HTTP server")

and paste the URL. Add the bearer token in the client's header/auth field if you have one.

Discovery: `/.well-known/mcp.json`

(SEP-1649 server card) lists this endpoint plus the no-auth ChatGPT Apps endpoint at

`/api/apps/mcp`. The stdio package above remains the local-install alternative and the path for

RapidAPI-keyed users.

Environment Variables

No key at all → anonymous, rate-limited free tier. With both `SCHOLAR_API_KEY` and `RAPIDAPI_KEY` set, RapidAPI takes precedence.

Supported Citation Styles

Scholar Sidekick supports 10,000+ CSL styles, including all major formats used in academic publishing:

Any CSL style ID can be passed as the `style` parameter.

Example Usage

Once connected, ask your AI assistant:

Single identifier

• "Format 10.1056/NEJMoa2033700 in Vancouver style"
• "Resolve PMID:30049270 and export as BibTeX"
• "Give me a Chicago citation for arXiv:2301.08745"

Batch input (comma- or newline-separated — every tool handles it)

• "Format these as APA: 10.1056/NEJMoa2033700, PMID:30049270, ISBN:9780192854087"
• "Resolve all of these and tell me which are journal articles vs books: 10.1056/NEJMoa2033700, ISBN:9780192854087, PMC7793608"

End-to-end workflow (the assistant chains `resolveIdentifier` → `formatCitation` → `exportCitation` in one prompt)

• "Resolve these three identifiers, format each in AMA, and export the set as BibTeX: 10.1056/NEJMoa2033700, PMID:30049270, ISBN:9780192854087"
• "Build me a Nature-style bibliography from this list and give me a `.bib` file at the end: PMID:30049270, arXiv:2301.08745, 10.1038/s41586-021-03819-2"

Retraction & open-access checks (one identifier per call)

• "Has 10.1016/S0140-6736(20)31180-6 been retracted?" → returns `isRetracted: true` with the retraction notice and date
• "Is the NumPy paper (10.1038/s41586-020-2649-2) open access? Where can I read it for free?" → returns OA status plus the best legal PDF URL with license and version
• "Check whether arXiv:2301.08745 has any corrections or expressions of concern." → resolves arXiv → DOI, then queries Retraction Watch

Supported Identifiers

• DOIs (e.g. `10.1056/NEJMoa2033700`)
• PubMed IDs (e.g. `PMID:30049270`)
• PubMed Central IDs (e.g. `PMC7793608`)
• ISBNs (e.g. `ISBN:9780192854087`)
• arXiv IDs (e.g. `2301.08745`)
• ISSNs and eISSNs
• NASA ADS bibcodes
• WHO IRIS URLs

Provenance & Determinism

Every `formatCitation` and `exportCitation` response is followed by a metadata block so the assistant — and the user — can see exactly which engine produced each citation:

• `formatter` — `builtin` (one of Vancouver, AMA, APA, IEEE, CSE — hand-tuned in TypeScript) or `csl` (citeproc-js with a CSL stylesheet).
• `styleUsed` — the canonical style ID after alias and dependent-style resolution (e.g. asking for `harvard` resolves to `harvard-cite-them-right`).
• `requestId` — for support, reproducibility, and log correlation.
• `warnings` — populated when a fallback was used or the requested style was a dependent of another.

Identifier resolution is deterministic given the same inputs and pinned upstream metadata. Repeated identical requests are cache-hit on the underlying REST API and surface that via the `x-scholar-cache` header.

REST API

For programmatic access outside of MCP clients, the same capabilities are available as a REST API at scholar-sidekick.com — anonymously, with a free first-party `ssk_` key (`Authorization: Bearer`), or via RapidAPI for paid tiers. Whichever credential you use here works there too.

Development

npm install
npm run build    # Bundle to dist/mcp-server.mjs
npm test         # Run tests
npm run typecheck

License

MIT