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.
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.
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.
import? → OneCite.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.
| 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,395-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. |
| 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) |
One capsule per tool: what it is, what it is for, and where it does not fit.
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). Tool counts, supported identifiers, output formats, and install instructions can change - verify against the linked repos and docs before integrating.
An MCP server that exposes your existing Zotero 7+ library to AI assistants - search, read, annotate, manage.
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.
Two MCP tools, one job: send a DOI, URL, or query; get a BibTeX entry back. Same project as ndchikin/reference-mcp.
CiteAssist is the smallest tool on this page. It exposes two MCP tools (get_citeas_data, get_scholar_data) that proxy through to the CiteAs 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", accepted at the SDProc workshop @ ACL 2024.
Scans a manuscript folder, finds broken references, validates them against multiple backends, rewrites in place.
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 (Lee, 2026; preprint, not peer-reviewed at time of writing) describing the system as a software paper.
A self-contained Python toolkit for citation management with multi-source validation; ships an MCP server as a secondary entry point.
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.
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 (@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.
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 (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.
An MCP server that wraps our public identifier-resolution and citation-formatting API, with versioned outputs and full provenance headers.
Scholar Sidekick MCP installs in one line - npx -y scholar-sidekick-mcp@latest - and exposes seven tools, including verifyCitation - one of three verification tools among the seven reviewed here, and the only one backed by a published, auditable benchmark (a sealed 1,395-citation blind holdout with downloadable JSON receipts at /citation-integrity). It catches the dominant fabrication pattern documented by Topaz et al. (Lancet 2026): a real, resolvable DOI paired with an invented title. The other tools are resolveIdentifier, formatCitation, exportCitation, checkRetraction, checkOpenAccess, 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 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.
ssk_ key from scholar-sidekick.com/account raises rate limits and enables the verifier's opt-in LLM screen; a RapidAPI key routes through the paid managed tiers, which scale to 500K requests/month.scholar-sidekick.com. If you require fully on-machine processing with no intermediate service, OneCite and citecheck are the better choices.x-scholar-cache header makes the difference visible. See /verification for the worked examples.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:
verifyCitation is the only one backed by a published, auditable benchmark - a sealed 1,395-citation blind holdout with downloadable JSON receipts at /citation-integrity and a 0.8% high-confidence false-accusation rate (Wilson 95% CI 0.4-1.4%) - 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.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.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.x-scholar-transform-version), request-id provenance, public .well-known/sources.json manifest, dedicated /verification page. I did not find an equivalent surface published on the other four, though the underlying tools can of course add one.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:
.tex/.md/.bib/.docx files. citecheck is purpose-built for that loop.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.)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.ssk_ key or a paid RapidAPI plan raises it).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 manifest. Declared resolver chain, fallback order per identifier type, allowlisted upstream hosts, and network-safety guarantees. Read what we do before integrating./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.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:
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.
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.
Three. Scholar Sidekick MCP'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,395-citation blind holdout with downloadable receipts at /citation-integrity). CiteTrue 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'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.
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.
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.
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 section above for concrete pairings.
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.
No. The MCP package is a thin client that calls the hosted Scholar Sidekick API 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.
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.
Read this comparison as markdown - for AI agents and offline reading.