Skip to main content
Glama
Awesome Paper MCP

Awesome Paper MCP

Awesome Paper MCP — Unified Academic Paper Search

One MCP server that unifies 9 upstream paper-search MCP servers into a single endpoint. Point any MCP-capable agent at it and get search, full-text reading, citation graphs, peer-review data and a research pipeline from 40+ academic sources — arXiv, Semantic Scholar, Google Scholar, OpenReview, OpenAlex, DBLP, PubMed, bioRxiv, medRxiv, Crossref, CORE, HAL, Europe PMC, SSRN, Zenodo, CiteSeerX, DOAJ, BASE, OpenAIRE, PMC, ACM, IACR, WoS, Scopus, IEEE, plus conference listings for NeurIPS / ICML / ICLR / IJCAI / CVPR / ECCV / AAAI / PMLR.

14 backends · 148 upstream tools · 1 config entry.


Why a gateway instead of installing 9 servers

Each upstream project pins its own dependency versions (arxiv 2.x vs 4.x, bibtexparser 1.x vs 2.x, mcp 0.9 vs 1.30, fastmcp 3.x vs 4.x). Installing them into one interpreter breaks them. This gateway therefore runs each upstream server as a separate child process on a private stdio pipe and speaks MCP to it, so no two projects ever share an interpreter.

 agent ──stdio/http──▶ paper-mcp gateway ──┬─▶ arxiv (19 tools)
                                          ├─▶ multisearch (71 tools)
                                          ├─▶ resp (20 tools)
                                          ├─▶ openreview (11 tools)
                                          ├─▶ openreview_classic (5 tools)
                                          ├─▶ scholar (9 tools)
                                          ├─▶ google_scholar (3 tools)
                                          ├─▶ papers_helper (4 tools)
                                          └─▶ 6 × sercantas research pipeline (6 tools)

Related MCP server: Research MCP

Install

One command from a fresh clone (needs uv, git, node ≥ 18, npm):

git clone https://github.com/<you>/awesome-paper-mcp.git
cd awesome-paper-mcp
bash scripts/setup.sh

The script creates the Python 3.12 venv, installs the pinned dependency set (requirements-lock.txt), clones the 9 upstream repos at the exact commits this gateway was tested against, links them into the same venv with --no-deps (that is what lets their incompatible pins coexist), installs the Node modules for the sercantas pipeline, installs the gateway itself, and finishes with an MCP handshake smoke test. It is safe to re-run.

cd awesome-paper-mcp
uv venv --python 3.12 .venv
export VIRTUAL_ENV=$PWD/.venv PATH=$PWD/.venv/bin:$PATH

uv pip install -r requirements-lock.txt           # pinned shared dependency set
git clone <upstream-url> sources/<dir> && git -C sources/<dir> checkout <sha>   # ×9, see scripts/setup.sh
for d in blazickjp-arxiv-mcp-server openags-paper-search-mcp monk1337-resp_mcp \
         OpenCodice-Research-openreview-mcp anyakors-openreview-mcp-server-equivalent \
         silung-scholar-search-mcp elpaca-ai_papers_helper; do
  uv pip install -e "sources/$d" --no-deps        # pins cannot fight each other
done
( cd sources/sercantas-Academic-Research-MCP-Suite && npm install --no-audit --no-fund )
uv pip install -e . --no-deps                     # gateway -> .venv/bin/paper-mcp

JackKuo666-Google-Scholar-MCP-Server is deliberately not installed: it imports a sibling module by bare name, so the gateway launches it as a script instead.


Connect your agent

Replace /path/to/awesome-paper-mcp with your checkout everywhere below. If your client supports a cwd field, the python -m unified_mcp form works; if it does not (e.g. MiniMax Code), point command at the console script /path/to/awesome-paper-mcp/.venv/bin/paper-mcp with no args — the gateway resolves its own paths from the script location.

Claude Code / Claude Desktop

{
  "mcpServers": {
    "paper-mcp": {
      "command": "/path/to/awesome-paper-mcp/.venv/bin/python",
      "args": ["-m", "unified_mcp"],
      "cwd": "/path/to/awesome-paper-mcp"
    }
  }
}

Cursor (~/.cursor/mcp.json)

{
  "mcpServers": {
    "paper-mcp": {
      "command": "/path/to/awesome-paper-mcp/.venv/bin/python",
      "args": ["-m", "unified_mcp"],
      "cwd": "/path/to/awesome-paper-mcp"
    }
  }
}

MiniMax Code (~/.minimax/mcp.json or project .mcp.json)

MiniMax Code's MCP settings have no cwd field, so use the console script:

{
  "mcpServers": {
    "paper-mcp": {
      "command": "/path/to/awesome-paper-mcp/.venv/bin/paper-mcp",
      "args": []
    }
  }
}

HTTP transport (shared / remote)

.venv/bin/python -m unified_mcp --http --host 127.0.0.1 --port 8765
{
  "mcpServers": {
    "paper-mcp": { "type": "http", "url": "http://127.0.0.1:8765/mcp" }
  }
}

Generic stdio (Gemini CLI, Cline, Windsurf, Zed, OpenCode, …)

{
  "mcpServers": {
    "paper-mcp": {
      "command": "python",
      "args": ["-m", "unified_mcp"],
      "cwd": "/path/to/awesome-paper-mcp"
    }
  }
}

The 14 backends

Backend

Source repo

Tools

What it is for

arxiv

blazickjp/arxiv-mcp-server

19

arXiv search, PDF download, full-text reading, outlines, LaTeX source, citation graph, topic alerts

multisearch

openags/paper-search-mcp

71

40+ sources in one server: PubMed, bioRxiv, medRxiv, Semantic Scholar, Crossref, OpenAlex, DBLP, HAL, CORE, DOAJ, Zenodo, SSRN, WoS, Scopus, IEEE, …

resp

monk1337/resp_mcp

20

SERP-free multi-source search + conference listings (NeurIPS/IJCAI/CVPR/ECCV/AAAI/PMLR)

openreview

OpenCodice-Research/openreview-mcp

11

Reviews, meta-reviews, rebuttals, decisions for NeurIPS/ICLR/ACL ARR/COLM/TMLR

openreview_classic

anyakors/openreview-mcp-server

5

Bulk conference listing + JSON/PDF full-text export

scholar

silung/scholar-search-mcp

9

Semantic Scholar details, citations, references, authors, recommendations

google_scholar

JackKuo666/Google-Scholar-MCP-Server

3

Google Scholar keyword/advanced search + author profiles

papers_helper

elpaca/ai_papers_helper

4

Local FTS5/BM25 paper library, TOC extraction, in-PDF grep

research_initiator

sercantas/Academic-Research-MCP-Suite

1

Refine a question into a testable hypothesis

data_wrangler

sercantas

1

Clean and prepare datasets

code_generator

sercantas

1

Generate Python/R/JS analysis scripts

code_executor

sercantas

1

Execute analysis scripts, capture output

research_writer

sercantas

1

Compose APA / ASA / generic reports

research_orchestrator

sercantas

1

Coordinate the whole pipeline

Note on anyakors/openreview-mcp-server — that URL returns 401 to git clone and 404 to the GitHub tarball API, so it could not be fetched. Its published content is byte-identical to stepp1/openreview-mcp-server (same tools, same README), which is what openreview_classic runs. If the original becomes reachable, replace sources/anyakors-openreview-mcp-server-equivalent.


How to use it

1. Discover what is available

list_sources()

Returns every backend, its status (ready / needs_config / unavailable), the env vars it is missing, and its full tool list.

2. Search across many sources at once

search_papers(query="mixture of experts routing", max_results=10)

Fans out to arxiv, multisearch, resp and google_scholar in parallel and merges the results. Pass sources=["scholar","openreview"] to narrow it.

3. Get one paper by id

get_paper(paper_id="2401.04088")     # arXiv id
get_paper(paper_id="10.1145/xxx")    # DOI

Auto-detects the id shape and tries the backends that can resolve it.

4. Read full text

get_paper_text(paper_id="2401.04088", source="arxiv", max_chars=20000)

arxiv handles arXiv ids, multisearch handles arXiv/PubMed/bioRxiv/medRxiv/ Crossref/OpenAlex, openreview_classic exports OpenReview PDFs.

5. Call any specific upstream tool

call_source_tool(backend="arxiv", tool="get_paper_latex", arguments={"paper_id":"2401.04088"})

Or, after list_sources() has mounted them, call the namespaced form directly:

arxiv__get_paper_latex(arguments={"paper_id": "2401.04088"})
multisearch__search_pubmed(arguments={"query": "CRISPR off-target", "max_results": 10})
openreview__openreview_get_reviews(arguments={"submission_id": "abc123"})
resp__search_neurips(arguments={"keyword": "diffusion", "year": 2024})

Namespaced tools take their arguments as a single arguments object and forward it verbatim, so every upstream parameter is available. Their descriptions list each parameter, its type and whether it is required.

6. Run the research pipeline

run_research_pipeline(question="does test-time compute scaling help reasoning?", output_style="APA")

Credentials

Everything works with no credentials at all. These only unlock more:

Env var

Backend

Effect

SEMANTIC_SCHOLAR_API_KEY

scholar, multisearch, resp

Removes Semantic Scholar 429 rate limits

PAPER_SEARCH_MCP_UNPAYWALL_EMAIL

multisearch

Enables Unpaywall open-access PDF fallback

PAPER_SEARCH_MCP_CORE_API_KEY

multisearch

CORE full-text search

PAPER_SEARCH_MCP_IEEE_API_KEY

multisearch

IEEE Xplore metadata

OPENREVIEW_USERNAME / OPENREVIEW_PASSWORD

openreview, openreview_classic

Non-anonymous OpenReview queries

MINERU_API_KEY

papers_helper

PDF → markdown parsing

Set them in the env block of your MCP config, e.g.:

{
  "mcpServers": {
    "paper-mcp": {
      "command": "/path/to/awesome-paper-mcp/.venv/bin/python",
      "args": ["-m", "unified_mcp"],
      "cwd": "/path/to/awesome-paper-mcp",
      "env": {
        "SEMANTIC_SCHOLAR_API_KEY": "...",
        "PAPER_SEARCH_MCP_UNPAYWALL_EMAIL": "you@example.com"
      }
    }
  }
}

Layout

awesome-paper-mcp/
├── unified_mcp/                 # the gateway (the only code in this repo)
│   ├── server.py                # FastMCP gateway + smart tools + namespace mount
│   └── backends/
│       ├── registry.py          # the 14 backend definitions
│       └── proxy.py             # raw JSON-RPC stdio bridge to each child
├── scripts/setup.sh             # one-command bootstrap (clones + installs everything)
├── requirements-lock.txt        # pinned shared dependency set (144 packages)
├── mcp-configs.json             # ready-to-paste configs for 10 MCP clients
├── pyproject.toml               # console script: paper-mcp
├── sources/                     # 9 upstream repos — fetched by setup.sh, not committed
├── .venv/                       # Python 3.12 environment — created by setup.sh
└── README.md

The upstream projects are not vendored: sources/ is git-ignored and populated by scripts/setup.sh at the commits recorded in that script, so they keep their own history, licenses and update cadence.

Design notes

Why raw JSON-RPC instead of mcp.client.stdio? The installed mcp 1.30.0 client deadlocks inside stdio_client + ClientSession.initialize() on this platform (an anyio 4.15 task-group / cancel-scope interaction). All upstream servers answer correctly to raw newline-delimited JSON-RPC over stdio, which was verified against every backend first, so backends/proxy.py speaks the protocol directly. If a future mcp release fixes the client, swapping in the official client is a drop-in change confined to proxy.py.

Why lazy startup? A backend is only spawned when first used, so one slow or broken source never delays the handshake or blocks the others. --no-lazy warms everything at boot instead.

Proxy handling. If the host exports an http_proxy pointing at a loopback port that is not listening, the child processes detect it and fall back to a direct connection instead of failing every request with ProxyError.

License

MIT for the gateway code in unified_mcp/ and everything else in this repository. The upstream projects under sources/ are downloaded at install time and keep their own licenses — nothing here redistributes them.

Available Tools

6 tools
call_source_toolA

Call any tool from any backend by name.

This is the escape hatch for backend-specific features that have no cross-source wrapper (e.g. openreview reviews, arxiv LaTeX source, resp conference listings). Use list_sources() to discover tool names.

Args: backend: Backend name from list_sources(). tool: Tool name as listed by list_sources(). arguments: Tool arguments as a JSON object.

Inputs: tool (required), backend (required), arguments. Returns: result

get_paperA

Fetch metadata / abstract for one paper by its id.

Args: paper_id: arXiv id (2401.04088), DOI (10.1234/xyz), OpenReview forum id, or a Semantic Scholar paper id. source: Force a specific backend. Omit to auto-detect.

Inputs: paper_id (required), source. Returns: result

get_paper_textA

Download a paper and return its readable text.

Args: paper_id: arXiv id, DOI, or backend-specific id. source: Backend to use. arxiv (default) supports arXiv ids; multisearch supports arXiv/PubMed/bioRxiv/medRxiv/Crossref/OpenAlex/...; openreview_classic exports OpenReview PDFs. max_chars: Truncate the returned text to this many characters.

Inputs: paper_id (required), source, max_chars. Returns: result

list_sourcesA

List every paper source available through this server, with its capabilities, tool names and any missing credentials.

Call this first to decide which backend to use.

Inputs: no named parameters. Returns: result

run_research_pipelineB

Run the full academic research pipeline on a research question.

Stages: refine the question into a hypothesis, generate analysis code, execute it, then compose a structured report. Uses the sercantas Academic-Research-MCP-Suite backends.

Args: question: A vague or broad research question. output_style: APA, ASA or generic.

Inputs: question (required), output_style. Returns: result

search_papersA

Search for papers across one or many sources at once.

Default sources are the ones that need no credentials: arxiv, multisearch (Semantic Scholar / Crossref / OpenAlex / DBLP / PubMed ...), resp and google_scholar.

Args: query: Keywords or a paper title. sources: Backend names from list_sources(). Omit for the default set. max_results: Results per source. year_from: Only papers from this year onwards (where supported).

Inputs: query (required), sources, year_from, max_results. Returns: result

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

Loading tool schema changelog…

    TDQS

    A3.9/5.0

    Scored across 6 tools

    Disambiguation4/5

    The core wrappers (list_sources, search_papers, get_paper, get_paper_text) target clearly distinct steps, and the metadata-vs-full-text split is explicitly documented. However, call_source_tool is a generic escape hatch that can perform the same operations as every wrapper, so an agent could plausibly misselect it instead of search_papers or get_paper without reading carefully.

    Naming Consistency5/5

    All six tools use snake_case with a leading verb (list_, search_, get_, call_, run_), giving a predictable verb_noun pattern throughout. The paired get_paper / get_paper_text naming even signals their relationship clearly.

    Tool Count5/5

    Six tools is lean for a multi-backend aggregation server and each has a distinct role: discovery, search, metadata, full text, escape hatch, and pipeline. Nothing feels redundant or padded.

    Completeness5/5

    The surface covers the full lifecycle: discover backends, search across them, fetch metadata, retrieve full text, and reach any backend-specific feature (reviews, LaTeX, conference listings) via call_source_tool. Citation-graph traversal is not a dedicated wrapper but is reachable through the escape hatch, so there are no real dead ends.

    Maintenance

    ActivityMaintained
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • F
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to search across multiple academic databases (PubMed, arXiv, bioRxiv, medRxiv, Semantic Scholar) through a unified interface. Supports advanced filtering, metadata retrieval, PDF downloads, and comprehensive research workflows with citation analysis.
      5
      -
    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables LLMs to search, analyze, and summarize academic research papers in real-time from arXiv, Semantic Scholar, and PubMed. Provides automatic deduplication, citation analysis, and BibTeX generation across multiple research databases.
      22 npm
      MIT
    • F
      license
      Not graded
      quality
      C
      maintenance
      Enables searching for academic papers and preprints across multiple platforms including Semantic Scholar, arXiv, PubMed, and CrossRef. It provides access to research records, DOI lookups, and journal metadata through a unified interface deployed on Cloudflare Workers.
      2
      -