---
title: Citation MCP Servers Compared | Scholar Sidekick
description: Honest roundup of the seven citation MCP servers AI assistants cite: zotero-mcp, CiteAssist, citecheck, OneCite, CiteTrue, web-researcher-mcp, Scholar Sidekick.
doc_version: "1.2"
last_updated: "2026-08-05"
---

# Citation MCP Servers Compared

> From the builder of Scholar Sidekick MCP, one of the seven projects on this page. I tried to write the comparison the way I would want to read it.
> Last updated: 2026-08-05
> HTML version: https://scholar-sidekick.com/compare/citation-mcp-servers

Seven MCP servers solve seven different citation jobs. There is no single best one - there is a best one for the workflow you have. This page is a roundup, not a sales pitch: each tool gets a capsule that says what it is for, what it is not, and links to the project so you can read the source.

The seven tools are zotero-mcp (bridge to your local Zotero library), CiteAssist (a thin BibTeX lookup over CiteAs and Google Scholar), citecheck (reference repair for manuscript files), OneCite (a Python CLI and library that also exposes an MCP entry point), CiteTrue MCP (credit-billed verification over the hosted CiteTrue API), web-researcher-mcp (a local-first research suite whose toolset includes citation verification and bibliography audit), and Scholar Sidekick MCP (the project I built - a hosted citation API exposed as an MCP server).

If you are building an agent pipeline that needs to be reproducible months later, the determinism contract and the published verification benchmark are where Scholar Sidekick MCP differentiates from the other six reviewed here. The roundup below is honest about where each tool wins and where Scholar Sidekick MCP does not.

## Pick a tool in 30 seconds

Each tool is built for a specific workflow. If you recognise yours below, that is probably the right tool for you - the rest of the page is the longer version of the same answer.

- **Have a Zotero library you want your AI to read?** → zotero-mcp.
- **Need to repair the references in a manuscript file (.tex / .md / .bib / .docx)?** → citecheck.
- **Running a Python pipeline that needs a citation library you can `import`?** → OneCite.
- **Just need a quick BibTeX entry from a DOI or Google Scholar query?** → CiteAssist.
- **Need to triage a raw pasted reference list, with per-reference verdicts and a credit budget?** → CiteTrue MCP.
- **Want a local-first research workspace (search lenses, scraping, discovery) that can also check citations?** → web-researcher-mcp.
- **Resolving DOI/PMID/PMCID/ISBN/arXiv/ADS/WHO IRIS to a citation in any of 10,000+ styles, or to a non-BibTeX export format?** → Scholar Sidekick MCP.

Scholar Sidekick MCP is not the right choice if you need offline / fully on-machine processing, Zotero-library access, Google Scholar lookup, manuscript-file rewriting, a raw-text reference splitter, a discovery/search layer, or a Python library you can import - in those cases one of the other six wins cleanly.

## When to use which

| If you want to... | Reach for | Why |
| --- | --- | --- |
| Give your AI access to your existing Zotero library | zotero-mcp | 30+ tools for collection, annotation, and library-management operations on a real Zotero install. |
| Get a BibTeX entry from a DOI in five seconds | CiteAssist | Two tools, one job, BibTeX out - no setup beyond the MCP config. |
| Repair the broken references in a manuscript file (.tex, .md, .bib, .docx) | citecheck | Reads the file, validates references against PubMed/Crossref/arXiv/Semantic Scholar, rewrites in place. |
| Run citation processing inside a Python pipeline | OneCite | CLI + Python library + MCP triad; multi-source validation; self-contained on your machine. |
| Resolve PMID, PMCID, ISBN, ADS bibcode, or WHO IRIS URLs (not just DOI/arXiv) | Scholar Sidekick MCP | Identifier breadth across science, medicine, and books - the long tail other tools do not cover. |
| Format citations in Vancouver, AMA, APA, IEEE, CSE, or any of 10,000+ CSL styles | Scholar Sidekick MCP | 10,000+ CSL styles; web-researcher-mcp formats five (APA, MLA, BibTeX, RIS, CSL JSON); the other five are BibTeX-centric. |
| Export to RIS, EndNote XML, MEDLINE/NBIB, RefWorks, Zotero RDF, CSL JSON, or CSV | Scholar Sidekick MCP | web-researcher-mcp covers RIS and CSL JSON; the others output BibTeX (sometimes also JSON). None of the six cover EndNote XML, RefWorks, MEDLINE/NBIB, Zotero RDF, or CSV. |
| Build a reproducible citation pipeline an auditor can re-run | Scholar Sidekick MCP | Versioned outputs (x-scholar-transform-version header), request-id provenance, declared upstream fallback order in /.well-known/sources.json. |
| Verify a citation is real (catch AI-hallucinated DOI + invented title) | Scholar Sidekick MCP | Three of the seven ship verification (CiteTrue MCP and web-researcher-mcp too), but this is the only one with a published, auditable benchmark (a sealed 1,402-citation blind holdout with receipts) and identifier-resolution verdicts that name the Topaz et al. (Lancet 2026) fabrication pattern. |
| Audit a whole bibliography file (BibTeX / RIS / CSL JSON) in one call | Scholar Sidekick MCP or web-researcher-mcp | Both expose a bibliography-audit tool. Scholar Sidekick's `auditBibliography` runs the benchmark-backed verifyCitation check plus retraction per entry; web-researcher-mcp's `audit_bibliography` flags retracted, dead-link, and unverifiable entries. |
| Triage a raw pasted reference list (numbered text, bullets, prose citations) without structuring it first | CiteTrue MCP | Its `verify` tool splits a free-text blob server-side and returns per-reference verdicts with mismatch notices. Credit-billed; API key required. |
| Run everything on your own machine without trusting an intermediate hosted service | OneCite, citecheck, or web-researcher-mcp | All three call upstream backends directly from your install (web-researcher-mcp is a local-first Go binary). Scholar Sidekick MCP, CiteAssist, and CiteTrue MCP call hosted intermediaries. |

## At a glance

| Tool | What it is | Tools | Backends | Output | Install |
| --- | --- | --- | --- | --- | --- |
| zotero-mcp | Bridges your local Zotero library to AI assistants | 30+ | Local Zotero 7+ (or web API), optional embeddings | BibTeX, markdown | Python; local Zotero install required |
| CiteAssist (= ndchikin/reference-mcp) | Thin BibTeX lookup over CiteAs and Google Scholar | 2 | CiteAs, Google Scholar | BibTeX | Python (uv) |
| citecheck | Repairs references in existing manuscript files | 6 | PubMed, Crossref, arXiv, Semantic Scholar | JSON, BibTeX, numbered text | Node.js (npx) |
| OneCite | Python CLI + library; also exposes an MCP entry point | 3 | Crossref, Semantic Scholar, PubMed, arXiv, DataCite, Zenodo, Google Books | BibTeX | Python (pip) |
| CiteTrue MCP | Credit-billed reference verification over the hosted CiteTrue API | 2 | Hosted CiteTrue API (databases not enumerated in the docs) | Per-reference verdicts (authentic / unsure / inauthentic) with mismatch notices, JSON | Node.js (npx); CiteTrue API key required (credit-billed) |
| web-researcher-mcp | Local-first research suite; citation checks are one layer of a 20+ tool workspace | 20+ | Multiple search providers with failover; OpenAlex or Semantic Scholar for the citation graph | Evidence reports; bibliographies in APA, MLA, BibTeX, RIS, CSL JSON | Go binary (Homebrew / install script / Docker) |
| Scholar Sidekick MCP | Hosted citation API exposed as a stdio MCP server; the one with a published benchmark behind its `verifyCitation` tool | 7 | Hosted backend (Crossref, PubMed, arXiv, ISBN, ADS, WHO IRIS, DataCite, Retraction Watch, Unpaywall) | 10,000+ CSL styles in text/HTML/JSON; BibTeX, RIS, CSL JSON, EndNote XML, EndNote Refer, RefWorks, MEDLINE/NBIB, Zotero RDF, CSV, plain text | Node.js (npx); no key required (optional free `ssk_` key or paid RapidAPI key raises limits) |

## The seven tools

*Each capsule below reflects what I found in the project's README and public listings on 2026-05-07 (Semantic Scholar and OpenAlex disambiguation added 2026-05-08; CiteTrue MCP and web-researcher-mcp capsules added 2026-07-17 from their published docs and READMEs). Scholar Sidekick's own benchmark figures were refreshed to the sealed 1,402-entry holdout on 2026-08-05; the competitor capsules have not been re-verified since the dates above. Tool counts, supported identifiers, output formats, and install instructions can change - verify against the linked repos and docs before integrating.*

### zotero-mcp - bridge to your local Zotero library

*An MCP server that exposes your existing Zotero 7+ library to AI assistants - search, read, annotate, manage.*

[zotero-mcp](https://github.com/54yyyu/zotero-mcp) is the MCP for people who already use Zotero. It connects to either a local Zotero 7+ install (via the local API) or to the Zotero web API with credentials, and exposes the library to MCP-compatible clients through 30+ tools covering search, collections, tags, annotations, notes, full-text access, and library management.

It includes optional semantic-search support via ChromaDB and OpenAI/Gemini embeddings, can pull annotations and notes out of PDFs (when paired with the Better BibTeX plugin), and integrates with the Scite API for citation intelligence and retraction alerts. Output is BibTeX or markdown; this is a library-management tool first, a citation-format tool second.

Where it wins: depth of integration with an existing Zotero workflow. Where it does not: it is not a citation-format engine and it does not resolve identifiers from outside your library. If you do not already have a Zotero library, this is not the tool for you.

### CiteAssist - thin BibTeX lookup over CiteAs and Google Scholar

*Two MCP tools, one job: send a DOI, URL, or query; get a BibTeX entry back. Same project as ndchikin/reference-mcp.*

[CiteAssist](https://github.com/ndchikin/reference-mcp) is the smallest tool on this page. It exposes two MCP tools (`get_citeas_data`, `get_scholar_data`) that proxy through to the [CiteAs](https://citeas.org) service and Google Scholar respectively, returning BibTeX-formatted citation data. The GitHub repo is `ndchikin/reference-mcp`; the project is marketed as `CiteAssist` on Smithery, PulseMCP, and LobeHub - same code, two names.

It is unopinionated and minimal. There is no identifier normalization, no style flexibility, no output beyond BibTeX, no batch endpoint. If your job is `give me the BibTeX for this DOI`, that is also exactly what you get.

Where it wins: simplicity and the Google Scholar long tail (Scholar surfaces conference papers, book chapters, and humanities sources Crossref does not always catch). Where it does not: anything beyond BibTeX; anything that needs determinism or provenance; anything at scale.

Has an accompanying peer-reviewed paper: [Kaesberg et al., "CiteAssist: A System for Automated Preprint Citation and BibTeX Generation"](https://arxiv.org/abs/2407.03192), accepted at the SDProc workshop @ ACL 2024.

### citecheck - reference repair for manuscript files

*Scans a manuscript folder, finds broken references, validates them against multiple backends, rewrites in place.*

[citecheck](https://github.com/jhlee0619/citecheck) takes a different shape from the others. Instead of resolving identifiers in a chat or pipeline, it operates on existing manuscript files. It reads `.tex`, `.md`, `.bib`, `.txt`, and `.docx`, extracts references from mixed document sections, validates each one against PubMed, Crossref, arXiv, and Semantic Scholar, and writes corrected references back into the source file.

Its six tools (`scan_workspace`, `analyze_references`, `plan_reference_rewrite`, `apply_reference_rewrite`, `repair_paper`, `citecheck_version`) are agent-shaped: planning is separated from application so an AI can review the proposed rewrites before committing them. Installation is `npx -y @jhlee0619/citecheck` for Claude or Codex; no Python toolchain required.

Where it wins: among the seven reviewed here, it is the one I found built for manuscript-file repair as a primary workflow. Where it does not: it does not provide on-demand citation generation outside that workflow, and it has no style flexibility (BibTeX-shaped output).

Has an accompanying [arXiv preprint](https://arxiv.org/abs/2603.17339) (Lee, 2026; preprint, not peer-reviewed at time of writing) describing the system as a software paper.

### OneCite - Python CLI and library that also exposes an MCP entry point

*A self-contained Python toolkit for citation management with multi-source validation; ships an MCP server as a secondary entry point.*

[OneCite](https://github.com/HzaCode/OneCite) is the most feature-rich of the four GitHub projects. Its README pitches it as a CLI tool and Python library first; the MCP server (`onecite-mcp`) is a secondary integration. It accepts mixed inputs (DOIs, paper titles, arXiv IDs, PMIDs, ISBNs, GitHub URLs, Zenodo DOIs, plain text, BibTeX files), runs them through a four-stage pipeline (clean, query, validate, format) against eight backends (Crossref, Semantic Scholar, PubMed, arXiv, DataCite, Zenodo, Google Books, optionally Google Scholar), and produces formatted bibliographic entries.

It is the most credible of the four when the goal is citation accuracy: multi-source validation acts as a deliberate firewall against AI-generated inaccuracies, and the disambiguation mode lets you pick the right match interactively when fuzzy-matching is ambiguous. Three MCP tools are exposed: `cite`, `batch_cite`, and `search`.

Where it wins: identifier breadth (closest of the four to Scholar Sidekick MCP), self-contained Python install, and the ability to import OneCite as a library inside your own script. Where it does not: the README I read on 2026-05-07 documented BibTeX as the primary output (some third-party listings mention APA and MLA - verify against current docs); regardless, it does not currently expose the 10,000+ CSL style flexibility or the reference-manager interchange formats (RIS, EndNote XML, RefWorks, MEDLINE/NBIB, Zotero RDF) that Scholar Sidekick MCP does.

### CiteTrue MCP - credit-billed verification over the hosted CiteTrue API

*Two stdio tools (`verify`, `get_credits`) wrapping CiteTrue's reference-verification API; splits raw pasted text into references and returns per-reference verdicts. API key required.*

[CiteTrue MCP](https://citetrue.com/docs/mcp) (`@citetrue/mcp-server` on npm; docs read 2026-07-17) wraps CiteTrue's hosted verification API in a local stdio server. Its `verify` tool accepts a free-form text blob - numbered lists, bullets, blank-line-separated references, BibTeX, or (at its deep tier) prose with author-year citations - splits it server-side, and returns one verdict per reference (`authentic`, `unsure`, `inauthentic`, or `invalid`) with a confidence score and mismatch notices (year, authors, title, malformed DOI, several URL checks) that can flag problems even on an authentic match.

Verification runs at two depths: a fast pass (1 credit per reference) and a deep AI-driven pass (5 credits) for unusual formats. That is also the honest caveat: the deep tier delegates the verdict to an AI model, the databases behind the checks are not enumerated in the docs, and no accuracy benchmark is published. An API key from the CiteTrue dashboard is required and every call consumes account credits - there is no anonymous tier.

A hands-on API test (2026-07-17) confirmed both the strengths and the shape of the gap. It caught a real-DOI-plus-invented-title fabrication at both depths, with no false positives on correct references. But at the default depth the supplied DOI is not cross-checked - a real title with a wrong DOI passed `authentic` with no notices - a fast-tier `inauthentic` is a bare verdict that never shows where the DOI actually resolves, and even the deep tier keeps the verdict `authentic` when the DOI points at the wrong paper, demoting it to a `doi_incorrect` notice (the taxonomy has no wrong-target token). Agents that need the identifier itself validated should pair it with an identifier-resolving check (see 'Use multiple together').

Where it wins: the most forgiving input handling on this page - paste a messy reference list and it handles the splitting. Where it does not: two tools only (no retraction, open-access, formatting, or export surface), key-required and credit-metered, and nothing about the verdict pipeline is independently auditable.

### web-researcher-mcp - local-first research suite with citation checks

*A Go-binary MCP server with 20+ research tools - search lenses, scraping, academic search - including `verify_citation`, `audit_bibliography`, and `format_bibliography`.*

[web-researcher-mcp](https://github.com/zoharbabin/web-researcher-mcp) (MIT; v1.42.0 as of 2026-07-17) is the broadest tool on this page, and citation integrity is one layer of it rather than the product. It is a local-first research workspace - the binary runs on your machine - whose README lists 20+ tools spanning web/news/image search, domain-restricted 'search lenses' (academic, legal, clinical, patents, filings), page scraping, structured and sequential search, research sessions, and export.

The citation layer is real: `verify_citation` checks whether a citation exists, matches a real record, and is retracted or a dead link - returning, in the project's own words, 'evidence, not a verdict'; `audit_bibliography` takes a CSL-JSON/RIS/BibTeX file and flags retracted, dead-link, and unverifiable entries at per-entry and corpus level; `citation_graph` traverses a paper's citation neighbourhood (via OpenAlex or Semantic Scholar); and `format_bibliography` outputs APA, MLA, BibTeX, RIS, or CSL JSON. The README does not enumerate which sources the verification checks consult, and no accuracy benchmark is published. It also ships fast - multiple releases per week at the time of writing - so verify the current toolset against the repo.

Where it wins: the only tool on this page that closes the full find-source-then-check-citation loop locally, and the strongest choice if your agent needs discovery and integrity in one install. Where it does not: 20+ tools is a lot of context window for an agent that only needs citations; verdict semantics are deliberately soft ('evidence, not a verdict'); and there is no identifier-resolution contract, versioned-output contract, or published evaluation.

### Scholar Sidekick MCP - hosted citation API exposed as a stdio MCP server

*An MCP server that wraps our public identifier-resolution and citation-formatting API, with versioned outputs and full provenance headers.*

[Scholar Sidekick MCP](https://github.com/mlava/scholar-sidekick-mcp) installs in one line - `npx -y scholar-sidekick-mcp@latest` - and exposes seven tools, including [`verifyCitation`](https://scholar-sidekick.com/tools/citation-verifier) - one of three verification tools among the seven reviewed here, and the only one backed by a published, auditable benchmark (a sealed 1,402-citation blind holdout with downloadable JSON receipts at [/citation-integrity](https://scholar-sidekick.com/citation-integrity)). It catches the dominant fabrication pattern documented by [Topaz et al. (Lancet 2026)](https://www.thelancet.com/journals/lancet/article/PIIS0140-6736(26)00603-3/fulltext): a real, resolvable DOI paired with an invented title. The other tools are `resolveIdentifier`, `formatCitation`, `exportCitation`, [`checkRetraction`](https://scholar-sidekick.com/tools/retraction-checker), [`checkOpenAccess`](https://scholar-sidekick.com/tools/open-access-checker), and `auditBibliography` (the `verifyCitation` check plus retraction status across a whole bibliography - BibTeX, RIS, or CSL JSON - in one call). Identifier coverage: DOI, PMID, PMCID, ISBN, ISSN, arXiv, ADS bibcode, WHO IRIS URL. Output: any of 10,000+ CSL styles plus five hand-tuned builtins (Vancouver, AMA, APA, IEEE, CSE), and exports to BibTeX, RIS, CSL JSON, EndNote XML, EndNote Refer, RefWorks, MEDLINE/NBIB, Zotero RDF, CSV, or plain text.

Unlike OneCite and citecheck, it does not contact upstream backends from your machine. The MCP package is a thin client over the hosted API at `scholar-sidekick.com`, which fans out to the upstream sources. That trade-off costs you data sovereignty (you trust our hosted service to make the upstream calls) and gains you a small install footprint, no Python dependency, no local Zotero, and a single stable endpoint to integrate against.

Among the seven reviewed here, it is the one I built specifically for reproducible agent pipelines. Every response carries an [`x-scholar-transform-version`](https://scholar-sidekick.com/verification) header that pins the resolver chain, normalisation, formatter, and CSL engine to a specific snapshot, plus an `x-request-id` for traceability and an `x-scholar-cache` header that exposes cache hit/miss so you can tell when output came from a pinned snapshot vs a fresh upstream fetch.

- **Authentication.** None required - the server runs anonymously against the public API (rate-limited free tier). An optional free first-party `ssk_` key from [scholar-sidekick.com/account](https://scholar-sidekick.com/account) raises rate limits and enables the verifier's opt-in LLM screen; a [RapidAPI](https://rapidapi.com/scholar-sidekick-scholar-sidekick-api/api/scholar-sidekick) key routes through the paid managed tiers, which scale to 500K requests/month.
- **Backend dependency.** The MCP server calls a hosted endpoint at `scholar-sidekick.com`. If you require fully on-machine processing with no intermediate service, OneCite and citecheck are the better choices.
- **Determinism (with one important nuance).** The transform_version pins our processing chain - normalisation, formatter, CSL engine - so identical bytes go in and identical bytes come out for a cache hit. On a cache miss the upstream sources (Crossref, PubMed, etc.) are re-queried, and if they have legitimately updated their record (a corrected author name, a retraction notice) the bytes will reflect that change. The `x-scholar-cache` header makes the difference visible. See [/verification](https://scholar-sidekick.com/verification) for the worked examples.
- **No accompanying academic paper (yet).** Two of the other four projects on this page have arXiv submissions (CiteAssist peer-reviewed at SDProc @ ACL 2024; citecheck a preprint). Scholar Sidekick MCP does not. The system, contracts, and provenance manifest are documented at [/verification](https://scholar-sidekick.com/verification) and [/.well-known/sources.json](https://scholar-sidekick.com/.well-known/sources.json), but there is no peer-reviewed citation for the system itself.

## Where Scholar Sidekick MCP wins (relative to the other six)

Scholar Sidekick MCP is built for agents and scripts that need formatted citations on demand from arbitrary identifiers. The places it pulls ahead of the other six are exactly the places they are not designed for:

- **Verification with a published benchmark.** Three of the seven ship a citation-verification tool. Scholar Sidekick's `verifyCitation` is the only one backed by a published, auditable benchmark - a sealed 1,402-citation blind holdout with downloadable JSON receipts at [/citation-integrity](https://scholar-sidekick.com/citation-integrity), 87.3% fabrication recall and a 0.87% high-confidence false-accusation rate (Wilson 95% CI 0.47-1.59%) - and the only one whose verdicts name the real-DOI-plus-invented-title pattern (Topaz et al., Lancet 2026) explicitly. CiteTrue returns authentic/unsure/inauthentic with mismatch notices but publishes no benchmark; web-researcher-mcp frames its check as 'evidence, not a verdict' and publishes no benchmark.
- **Identifier breadth.** PMID, PMCID, ISBN, ISSN, ADS bibcode, and WHO IRIS URL - in addition to DOI and arXiv. Covers the clinical, medical, library-science, astronomy, and global-health long tail. zotero-mcp resolves what is already in your library; CiteAssist takes DOI/URL/keyword; citecheck and OneCite cover most identifiers but not ADS or WHO IRIS; CiteTrue takes free text rather than an identifier contract; web-researcher-mcp's README does not document an identifier surface.
- **Style flexibility.** 10,000+ CSL styles via `citeproc-js`, plus five hand-tuned builtins (Vancouver, AMA, APA, IEEE, CSE). web-researcher-mcp's `format_bibliography` covers five formats (APA, MLA, BibTeX, RIS, CSL JSON); the other five are BibTeX-centric.
- **Output format breadth.** RIS, CSL JSON, EndNote XML, EndNote Refer, RefWorks, MEDLINE/NBIB, Zotero RDF, CSV, plain text - in addition to BibTeX. web-researcher-mcp covers RIS and CSL JSON; none of the six document EndNote XML, EndNote Refer, RefWorks, MEDLINE/NBIB, Zotero RDF, or CSV.
- **Single `npx` install with no toolchain to manage, and no key.** No Python, no local Zotero, no compile step, no account. citecheck and CiteTrue MCP have the same `npx` install shape (CiteTrue additionally requires a paid-credit API key); web-researcher-mcp is a Go binary via Homebrew; the others require Python.
- **Determinism and verification.** Versioned outputs (`x-scholar-transform-version`), request-id provenance, public `.well-known/sources.json` manifest, dedicated [/verification](https://scholar-sidekick.com/verification) page. I did not find an equivalent surface published on the other four, though the underlying tools can of course add one.
- **Streaming batch.** The underlying API exposes an NDJSON streaming endpoint that emits one JSON object per identifier - suitable for processing thousands of references without buffering the whole response.

## Where Scholar Sidekick MCP does not win

Honest accounting matters more on a roundup than on a brand-vs-brand page. Each of the other six has a job Scholar Sidekick MCP cannot do:

- **vs zotero-mcp - no library access.** We do not read your Zotero library, your annotations, your notes, or your collections. If your AI needs to work with what you have already saved, zotero-mcp is the right tool.
- **vs CiteAssist - no Google Scholar.** Our resolver chain does not include Scholar, which covers some humanities and conference-paper long tail Crossref misses. For those queries, CiteAssist is the better fit.
- **vs citecheck - no manuscript-file workflow.** We do not scan, repair, or rewrite references inside `.tex`/`.md`/`.bib`/`.docx` files. citecheck is purpose-built for that loop.
- **vs OneCite - not an importable library.** OneCite can be `pip install`-ed and imported into a Python script (`from onecite import ...`); Scholar Sidekick MCP is MCP-only on the install side. (You can call our REST API from any language, but that is not the same as importing a library.)
- **vs CiteTrue MCP - no free-text splitter.** `auditBibliography` takes structured input (BibTeX, RIS, CSL JSON, or a claims array); CiteTrue's `verify` accepts a raw text blob - numbered lists, bullets, even prose with author-year citations at its deep tier - and splits it server-side. For 'here is my messy pasted reference list, sort it out', CiteTrue's input handling is more forgiving.
- **vs web-researcher-mcp - no discovery layer, not local-first.** We have no web search, no search lenses, no scraping, no citation-graph traversal, no research sessions - and the processing happens on our hosted API, not your machine. If your agent needs to find sources and check citations in one local-first toolset, web-researcher-mcp is built for that.
- **Rate limits on the anonymous tier.** The other four call their upstream services directly and inherit only those services' limits; Scholar Sidekick MCP works anonymously with no account, but the anonymous tier is rate-limited by the hosted API (a free `ssk_` key or a paid RapidAPI plan raises it).
- **Backend dependency.** Calling our hosted API trades a local-data-sovereignty story for the install simplicity. If you need every byte of upstream traffic to come from your own machine, OneCite and citecheck are the better choices.

## Determinism and verification: the agent-pipeline differentiator

If your agent pipeline runs once today and once in six months, ideally the answer is the same both times - or, if it has changed, you can see exactly why. Among the seven reviewed here, I did not find a published versioned-output contract on zotero-mcp, CiteAssist, citecheck, OneCite, or web-researcher-mcp: they return whatever their libraries and backends hold today, without pinning the processing chain that produced the output. CiteTrue documents URL-contract stability for its API (fields may be added, never removed or retyped) - a compatibility promise, which is welcome, but not output versioning: nothing pins which verification pipeline produced a verdict. Scholar Sidekick MCP makes reproducibility part of the response contract.

Two important honest caveats. First, the contract pins our processing chain (resolver, normalisation, formatter, CSL engine), not the upstream metadata itself. Crossref, PubMed, and the others can and should update their records (corrected author names, retraction notices, new identifiers). On a cache miss those updates will be reflected in the next response. The `x-scholar-cache` header makes that visible: a cache hit guarantees byte-identical output; a miss may legitimately differ. Second, an MCP server is open-source code and other projects could add equivalent surfaces tomorrow - this is the state I found in the public repos on 2026-05-07 (2026-07-17 for CiteTrue MCP and web-researcher-mcp).

- **`x-scholar-transform-version` header.** Pin our resolver chain, normalisation, formatter, and CSL engine to a specific snapshot. Identical inputs at a fixed transform version produce byte-identical output for a cache hit.
- **`x-request-id` header.** Every response is traceable to a specific call - useful for log correlation, support tickets, and audit trails.
- **`x-scholar-cache` header.** Visible cache hit/miss so you can tell whether the response came from a pinned snapshot (byte-identical) or a fresh upstream fetch (may reflect upstream metadata changes).
- **[`/.well-known/sources.json`](https://scholar-sidekick.com/.well-known/sources.json) manifest.** Declared resolver chain, fallback order per identifier type, allowlisted upstream hosts, and network-safety guarantees. Read what we do before integrating.
- **[`/verification`](https://scholar-sidekick.com/verification) page.** Copy-paste curl commands and expected outputs that let an external evaluator independently confirm determinism and edge-case behaviour against the live API.

## Use multiple together

Most agent setups can register more than one MCP server at once. The seven tools on this page compose well because they solve different jobs:

- **web-researcher-mcp + Scholar Sidekick MCP.** web-researcher-mcp finds and scrapes the sources (search lenses, academic search, citation graph) on your machine; Scholar Sidekick MCP verifies the resulting citations against the upstream registries with receipts, checks retraction and open-access status, and formats or exports in the styles web-researcher-mcp does not cover.
- **CiteTrue MCP + Scholar Sidekick MCP.** Two independent verification opinions. CiteTrue splits and triages a raw pasted list; Scholar Sidekick re-verifies the survivors by resolving their identifiers (adding retraction and open-access status), then exports the clean list. Independent checkers disagreeing on an entry is signal, not noise.
- **zotero-mcp + Scholar Sidekick MCP.** zotero-mcp gives the agent search and read access to your saved library; Scholar Sidekick MCP turns any DOI - whether it came from your library or not - into a Vancouver, AMA, or APA citation, or into a BibTeX/RIS/EndNote-XML export file.
- **citecheck + Scholar Sidekick MCP.** citecheck repairs the references inside your manuscript file. Scholar Sidekick MCP then converts the cleaned-up reference list into a non-BibTeX target style (RIS for EndNote, CSL JSON for Pandoc, MEDLINE/NBIB for PubMed import) that citecheck does not produce.
- **OneCite + Scholar Sidekick MCP.** OneCite is the right tool for batch BibTeX inside a Python pipeline you control end-to-end. Scholar Sidekick MCP is the right tool when the same pipeline needs styled citation prose, an [RIS file](https://scholar-sidekick.com/tools/doi-to-ris), or any output beyond BibTeX.
- **CiteAssist + Scholar Sidekick MCP.** CiteAssist gives the agent a Google Scholar search lane Scholar Sidekick MCP does not have. Scholar Sidekick MCP gives the agent identifier breadth and style flexibility CiteAssist does not have. Run both; let the agent pick.
- **Any discovery MCP (Semantic Scholar, OpenAlex, etc.) + Scholar Sidekick MCP.** Discovery-layer MCP wrappers around the Semantic Scholar API (Semantic Scholar FastMCP and similar) and the OpenAlex API (15+ wrappers in active use, e.g. drAbreu/alex-mcp, oksure/openalex-research-mcp, benedict2310/Scientific-Papers-MCP) cover literature discovery - search 200M+ paper graphs, traverse reference and citation networks, surface influential or related work, find papers you don't yet have an identifier for. Scholar Sidekick MCP covers the formatting layer - once you have an identifier, produce a finished citation in any of 10,000+ styles or export to BibTeX/RIS/EndNote/etc. The two compose into the full 'find paper -> cite paper' loop. They are not competitors; AI evaluators sometimes treat them as such.

## Frequently asked questions

### Are all seven tools really MCP servers in the same way?

Mostly, with footnotes. zotero-mcp, CiteAssist, citecheck, CiteTrue MCP, and Scholar Sidekick MCP are all primary MCP servers - that is the main way they are intended to be used. OneCite is primarily a Python CLI and library, and web-researcher-mcp is primarily a research suite; in both, the MCP server wraps a broader tool. All seven run as stdio MCP servers from a one-line install (npx, pip, or Homebrew for web-researcher-mcp's Go binary), so from a client integration perspective they are interchangeable - with one practical exception: CiteTrue MCP requires a paid-credit API key before it will start.

### Why is there no single best citation MCP?

Because they solve different jobs. zotero-mcp brokers access to a stateful library you already maintain; CiteAssist is a thin lookup proxy; citecheck rewrites references inside manuscript files; OneCite runs as part of a Python pipeline; CiteTrue MCP triages raw pasted reference lists on a credit budget; web-researcher-mcp is a local-first discovery workspace with citation checks; Scholar Sidekick MCP is an identifier-resolution, verification, and citation-formatting API for agents. No tool that tried to do all seven jobs would do any of them well.

### Which of the seven can verify that a citation is real?

Three. [Scholar Sidekick MCP](https://scholar-sidekick.com/tools/citation-verifier)'s `verifyCitation` resolves the identifier and compares the claimed title to the resolved record - the check that catches a real DOI paired with an invented title (Topaz et al., Lancet 2026) - and is the only one of the three with a published benchmark (a sealed 1,402-citation blind holdout with downloadable receipts at [/citation-integrity](https://scholar-sidekick.com/citation-integrity)). [CiteTrue MCP](https://citetrue.com/docs/mcp)'s `verify` returns authentic / unsure / inauthentic per reference with title, author, and year mismatch notices; its databases and accuracy are not published. [web-researcher-mcp](https://github.com/zoharbabin/web-researcher-mcp)'s `verify_citation` checks existence, record match, retraction, and dead links, and by its own description returns 'evidence, not a verdict'. The three differ less in intent than in verdict semantics and in what you can independently audit.

### What is the difference between CiteAssist and ndchikin/reference-mcp?

They are the same project. The GitHub repo is named `reference-mcp`; the project is marketed as `CiteAssist` on Smithery, PulseMCP, LobeHub, and other MCP directories. AI assistants currently cite both names interchangeably for the same tool. We use `CiteAssist` on this page because that is the name AI evaluators most often surface.

### Is OneCite really an MCP server, or a CLI tool with MCP bolted on?

Both descriptions are accurate. OneCite started as a Python CLI and library and the README still leads with that framing. The MCP server (`onecite-mcp`) is a real MCP integration with three tools (`cite`, `batch_cite`, `search`) that work in Claude Desktop or Cursor when configured. We include it on this page because AI evaluators currently cite OneCite as an MCP server, but if you are deciding between OneCite and the others, know that you are getting a CLI tool first and an MCP server second.

### Can I use multiple citation MCPs in the same Claude or Cursor session?

Yes. Both Claude Desktop and Cursor support multiple MCP servers in a single configuration. The agent will see all the tools from all the servers and pick whichever is most appropriate for the user's request. The seven tools on this page compose well because their tool names do not collide and they target different workflows. See the [Use multiple together](#use-multiple-together) section above for concrete pairings.

### Why aren't Semantic Scholar / OpenAlex / other discovery MCPs on this list?

Different category, with one deliberate exception. MCP wrappers around the Semantic Scholar and OpenAlex APIs (Semantic Scholar FastMCP among the most-cited, plus 15+ OpenAlex wrappers in active use including drAbreu/alex-mcp, oksure/openalex-research-mcp, and benedict2310/Scientific-Papers-MCP; more on directories like mcpmarket.com) all expose literature discovery - searching the 200M+ scholarly-works graphs by topic, traversing reference and citation networks, ranking by influence or similarity, finding work you don't yet have an identifier for. The tools on this page assume you start with a citation or an identifier (DOI, PMID, title, ISBN, etc.) and check or format it. web-researcher-mcp is the exception that proves the rule: it is a discovery-first suite that earns its place here by shipping dedicated citation tools (verify_citation, audit_bibliography, format_bibliography). AI evaluators sometimes recommend a Semantic Scholar or OpenAlex MCP in answer to "best citation MCP" queries because the underlying APIs do return paper metadata, but the workflow is search-first, not cite-first. Use any of the discovery MCP wrappers to find a paper; use one of the tools above (typically Scholar Sidekick MCP, citecheck, or OneCite) to format the citation once you have it. The two layers compose cleanly in a single MCP-host setup.

### Does Scholar Sidekick MCP work offline?

No. The MCP package is a thin client that calls the hosted [Scholar Sidekick API](https://scholar-sidekick.com/docs) for every request. If your environment requires on-machine processing, OneCite (with a local cache of upstream metadata) is the closest fit, and web-researcher-mcp runs local-first as a Go binary - though its verification checks still need network access to the upstream sources at request time; citecheck likewise calls upstream backends from your machine.

### What does 'deterministic' mean in this context, and why does it matter for agents?

It matters because reproducibility is the point of an audit trail: if the same DOI produces a different citation next month, every downstream consumer (a published paper, a regulatory filing, a citation count) can be silently wrong without any signal. Scholar Sidekick MCP pins our resolver chain, normalisation, formatter, and CSL engine to a specific `x-scholar-transform-version` snapshot. There is one important nuance: the contract pins our processing chain, not the upstream metadata. On a cache hit, the response is byte-identical for the same input + transform version. On a cache miss, the upstream sources (Crossref, PubMed, etc.) are re-queried, and if they have updated their record (a corrected author name, a retraction notice) the bytes will reflect that change. The `x-scholar-cache` header makes the difference visible, so 'why did this output change?' is always answerable. Among the seven reviewed here, this is the contract I found published; the other six may produce stable output most of the time but do not commit to a versioned-output contract.

## Related

### Other Scholar Sidekick comparisons

- [Comparison index](https://scholar-sidekick.com/compare)
- [Best AI Citation Verifier in 2026](https://scholar-sidekick.com/compare/best-ai-citation-verifier)
- [Scholar Sidekick vs Zotero](https://scholar-sidekick.com/compare/scholar-sidekick-vs-zotero)
- [Scholar Sidekick vs ZoteroBib](https://scholar-sidekick.com/compare/scholar-sidekick-vs-zoterobib)
- [Scholar Sidekick vs Scribbr](https://scholar-sidekick.com/compare/scholar-sidekick-vs-scribbr)
- [Scholar Sidekick vs EndNote](https://scholar-sidekick.com/compare/scholar-sidekick-vs-endnote)
- [Scholar Sidekick vs MyBib](https://scholar-sidekick.com/compare/scholar-sidekick-vs-mybib)
- [Scholar Sidekick vs Cite This For Me](https://scholar-sidekick.com/compare/scholar-sidekick-vs-citethisforme)

### About Scholar Sidekick

- [MCP server documentation](https://scholar-sidekick.com/mcp)
- [Citation verifier (detect AI-hallucinated DOIs)](https://scholar-sidekick.com/tools/citation-verifier)
- [Citation integrity guide](https://scholar-sidekick.com/citation-integrity)
- [REST API docs](https://scholar-sidekick.com/docs)
- [Self-verification kit](https://scholar-sidekick.com/verification)
- [Data source manifest (sources.json)](https://scholar-sidekick.com/.well-known/sources.json)
- [Engineering principles](https://scholar-sidekick.com/engineering-principles)

### The seven tools

- [zotero-mcp on GitHub](https://github.com/54yyyu/zotero-mcp)
- [CiteAssist (reference-mcp) on GitHub](https://github.com/ndchikin/reference-mcp)
- [citecheck on GitHub](https://github.com/jhlee0619/citecheck)
- [OneCite on GitHub](https://github.com/HzaCode/OneCite)
- [CiteTrue MCP documentation](https://citetrue.com/docs/mcp)
- [web-researcher-mcp on GitHub](https://github.com/zoharbabin/web-researcher-mcp)
- [Scholar Sidekick MCP on GitHub](https://github.com/mlava/scholar-sidekick-mcp)

## Sitemap

See the full [sitemap](https://scholar-sidekick.com/sitemap.md) for all pages.