Alexandria MCP
Allows searching and retrieving academic papers from arXiv, a repository of preprints in physics, mathematics, computer science, and related fields.
Enables retrieval of documentation for the Fastify web framework.
Provides access to Islamicate texts from the OpenITI collection hosted on GitHub.
Allows searching and accessing book metadata and full text from Google Books.
Enables searching of the NASA Astrophysics Data System (ADS) for astronomy, astrophysics, and physics literature.
Powers natural language search routing using OpenAI's GPT-4o-mini model to determine which sources to query.
Allows searching over 200 million academic papers with AI-powered recommendations and citation graphs.
Provides vector storage for ingesting and retrieving full-text content via a Supabase database.
Enables searching of digitized newspapers, books, and other collections from the National Library of Australia.
Allows searching and retrieving research outputs from CERN's open repository with higher rate limits.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Alexandria MCP find recent papers on transformer models"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Alexandria
A Model Context Protocol (MCP) server for querying, reading, and ingesting texts from 152 public digital libraries. Works with any MCP-compatible client (Claude Desktop, Cursor, VS Code Copilot, etc.).
Tools
Tool | Description |
| List all 152 sources with descriptions and full-text capabilities |
| Natural language search — routes your query to the best sources, searches in parallel, returns unified deduplicated results |
| Search a specific source by title, author, or keywords |
| Fetch full text or metadata for an item (200k char limit) |
| Dry run: chunk and score text quality without writing anything |
| Chunk → embed → store in your vector database. Idempotent. |
| Get similar papers via Semantic Scholar's recommendation engine (up to 500) |
| Ask a question and get a synthesized answer with inline |
| Recursive multi-round research: generates queries, answers each, extracts learnings, and writes a final cited report over every source found |
| Report per-source health ( |
| List the works an item cites ( |
library_ask is the primary entry point. library_search is for targeted queries against a known source. library_index / library_ingest are for building a vector knowledge base from retrieved texts. library_answer and library_research synthesize a cited answer or report instead of returning raw results. library_health_check tells you whether a source is worth calling before you call it. library_citations walks the citation graph around an item and can export it as a bibliography.
library_ask, library_search, library_answer, library_research, library_health_check, and library_citations take a response_format: "concise" | "detailed" parameter (default concise); concise trims results and citations to the high-signal fields (title, source, id, year, hasFullText, url; answer/report + citations; name, cluster, status), detailed returns the full payload, including routing reasons, relevance scores, per-stage diagnostics, and per-source error rate/latency/quota usage. In detailed mode, library_search also attaches a resource_link content item for each full-text result, pointing at that item's library://doc/{source}/{id} resource (see below): a client with resource support can read the full text directly instead of a second library_read call.
Related MCP server: Academic MCP
Prompts
Three ready-made research workflows, surfaced by MCP clients as slash commands (Claude Code's /alexandria:<name>, VS Code's /alexandria.prompt). Each returns a single message naming the tools to call, in order. It does not call any tool itself.
Prompt | Description |
| Survey a topic across sources and produce a cited report |
| Check one claim against the library and report whether it is supported |
| Check that a list of references (one per line) resolves to real, findable items |
Resources
library://doc/{source}/{id} reads the same text library_read(id, source) returns (including the open-access fallback below), addressed by the source/id pair library_search or library_ask returned. Clients that support MCP resources (Claude Code's @srv:uri, VS Code's Add Context) can pull an item's full text directly.
Sources (152)
152 sources across 19 clusters (36 hidden pending a key or config not present in this deployment). Full per-source detail, including auth env vars and last-verified dates, is generated in docs/sources.md.
Cluster | Sources | Hidden |
academic | 22 | 3 |
ai_research | 3 | 0 |
archives | 4 | 2 |
culture | 8 | 3 |
developer | 17 | 5 |
economics | 11 | 3 |
geopolitical | 3 | 3 |
government | 7 | 3 |
law | 4 | 1 |
literature | 16 | 2 |
markets | 2 | 1 |
news_global | 5 | 2 |
news_regional | 15 | 0 |
real_estate | 2 | 2 |
science | 8 | 2 |
security | 14 | 0 |
standards | 3 | 0 |
video | 1 | 1 |
web | 7 | 3 |
Total | 152 | 36 |
Credentials
Most tools query external library APIs directly and need no credentials at all. The two optional dependencies are scoped to specific tools:
OpenAI, optional (platform.openai.com)
Required by two tools only:
library_ask: usesgpt-4o-minito route your natural language query to the right sources and generate optimized per-source search terms. Without this key, uselibrary_searchto query sources directly.library_ingest: usestext-embedding-3-smallto embed chunked text before writing to the vector store.
library_list_sources, library_search, library_read, library_index, and library_recommend all work without an OpenAI key.
Pointing roles at a gateway instead of OpenAI directly
Every LLM/embedding call (routing in library_ask, embeddings in library_ingest) goes through a small per-role provider table (src/utils/providers.ts, THE-318) instead of talking to OpenAI's SDK directly. There are five roles: router, synth, research, embeddings, rerank. Each is resolved from env in this order:
ALEXANDRIA_<ROLE>_BASE_URL,ALEXANDRIA_<ROLE>_API_KEY,ALEXANDRIA_<ROLE>_MODEL(per-role overrides;<ROLE>is the role name upper-cased, e.g.ALEXANDRIA_ROUTER_BASE_URL)ALEXANDRIA_BASE_URL,ALEXANDRIA_API_KEY(shared defaults across every role)OPENAI_API_KEY, withbaseURLdefaulted tohttps://api.openai.com/v1
With only OPENAI_API_KEY set, every role resolves through step 3, which is exactly today's behavior (gpt-4o-mini for router/synth against api.openai.com, text-embedding-3-small for embeddings).
To route every role through a LiteLLM gateway instead:
ALEXANDRIA_BASE_URL=http://100.78.123.100:4001/v1
ALEXANDRIA_API_KEY=sk-litellm-...To route through Cloudflare AI Gateway (its OpenAI-compatible endpoint):
ALEXANDRIA_BASE_URL=https://gateway.ai.cloudflare.com/v1/<account_id>/<gateway_id>/openai
ALEXANDRIA_API_KEY=<your OpenAI key, forwarded through the gateway>Or point just one role at a gateway while the rest stay on OpenAI directly, e.g. ALEXANDRIA_ROUTER_BASE_URL + ALEXANDRIA_ROUTER_API_KEY for routing only.
See docs/cloudflare.md for the fuller Cloudflare integration guide: AI Gateway's newer unified endpoint, Workers AI for the embeddings/rerank roles, Tunnel + Access for a private /mcp, WAF rate limiting for a public one, R2 as an optional cache store, the Browser Run fetch tier below, and why Alexandria stays a hybrid (Node core, Cloudflare services) rather than a full Workers port.
When ALEXANDRIA_<ROLE>_BASE_URL/ALEXANDRIA_BASE_URL is set and OPENAI_API_KEY is also present, OPENAI_API_KEY is wired up as a one-shot fallback: a network error or 5xx from the gateway falls through to a direct OpenAI call once before the request fails. chatJSON (used by routing) always validates the model's response against a zod schema and retries once, on the same backend, with the validation error appended to the prompt, which helps when a gateway is proxying a smaller or local model that doesn't reliably follow the JSON contract on the first try. It requests response_format: json_object only against api.openai.com, or when ALEXANDRIA_<ROLE>_JSON_MODE=1 confirms the gateway/model supports it; otherwise it asks for JSON in the prompt instead.
Supabase — optional (supabase.com)
Required by one tool only:
library_ingest— writes chunked, embedded text into a pgvector table for semantic search. Without this, retrieved texts stay in-context and are not persisted anywhere.
Everything else — searching, reading, browsing, getting recommendations — queries external sources in real time and needs no database.
Source-specific keys
Some sources require their own API key. These are free registrations. Sources without a key listed here work without any credentials.
Env Var | Source(s) | Get It |
|
| |
|
| |
|
| api.data.gov/signup. Does not cover |
|
| Google Cloud Console → APIs & Services → Books API |
|
| |
|
| |
|
| |
|
| apis.europeana.eu — test key immediate, personal ~1 week |
| required by | github.com/settings/tokens, public repo read scope. |
|
| |
|
| dev.springernature.com — same registration, two keys |
|
| zenodo.org/account/settings/applications/tokens/new — optional, increases rate limits |
|
| api.data.gov/signup. Its own key, separate from |
|
| semanticscholar.org/product/api — optional, increases rate limits |
|
| trove.nla.gov.au/about/create-something/using-api — ~1 week approval |
|
| console.cloud.google.com — enable YouTube Data API v3; search only, transcripts need no key |
Privacy Policy
Alexandria has no telemetry of its own: it runs on infrastructure you control, and nothing about your queries, results, or credentials is sent to the Alexandria project.
Queries go to the upstream public library sources the agent selects for a given request, using each source's own public API under that source's own terms.
library_ask,library_answer,library_research, andlibrary_ingest, when an OpenAI (or OpenAI-compatible gateway) key is configured, also send your query text and retrieved excerpts to the LLM and embeddings provider the operator set up. See docs/cloudflare.md for the Cloudflare AI Gateway routing path and docs/fetch-tier-runtime.md for how outbound fetches to library sources are guarded.Nothing is stored by the project itself. The operator's own
data/directory holds local caches (state DB, per-process read cache) on the machine running the server, and nowhere else.
Full text: PRIVACY.md.
Setup
git clone https://github.com/The-40-Thieves/alexandria-mcp
cd alexandria-mcp
npm install
npm run buildCopy .env.example to .env. Minimum configuration to run with no credentials (search and read only):
TRANSPORT=stdioTo enable library_ask:
TRANSPORT=stdio
OPENAI_API_KEY=sk-...To enable library_ingest:
TRANSPORT=stdio
OPENAI_API_KEY=sk-...
SUPABASE_URL=https://your-project.supabase.co
SUPABASE_SERVICE_ROLE_KEY=eyJ...Supabase Schema
Required only if using library_ingest:
create table if not exists knowledge_chunks (
id bigserial primary key,
content text not null,
embedding vector(1536),
mcp_name text,
metadata jsonb,
created_at timestamptz default now()
);
create table if not exists source_docs (
id bigserial primary key,
source_url text not null,
mcp_name text not null,
title text,
source text,
chunk_count int,
indexed_at timestamptz,
unique (source_url, mcp_name)
);
create index if not exists knowledge_chunks_embedding_hnsw_idx
on knowledge_chunks using hnsw (embedding vector_cosine_ops);If you set this schema up before Task 12, you had an ivfflat index instead
(knowledge_chunks_embedding_idx) - docs/sql/match_chunks.sql drops it and
creates the hnsw one shown above, since HNSW builds incrementally and needs
no lists tuning constant as the table grows. If corpus-as-cache hits seem to
be missing results a plain <=> scan would have found, raise the query-time
hnsw.ef_search session setting (default 40) at the cost of a slower query -
see the commented recommendation in docs/sql/match_chunks.sql.
Corpus as cache
library_answer can also read straight from knowledge_chunks - previously
ingested text, already embedded - as one more ranked list next to the live
per-source search, skipping the network entirely for a hit it already has
the full text for. This only ever serves chunks from a source whose registry
freshness is static or daily (never realtime), and only above
ALEXANDRIA_CORPUS_MIN_SIM cosine similarity (default 0.92).
It needs one more piece of schema beyond the table above: run
docs/sql/match_chunks.sql in the Supabase SQL editor. It defines
match_knowledge_chunks(), the nearest-neighbor search function
SupabaseVectorStoreProvider.query() calls via .rpc(), and the hnsw
index above. This file was written against the current pgvector/supabase-js
docs but has not been run against a live database - verify it against your
own project before relying on it.
Claude Code (npx)
claude mcp add --env OPENAI_API_KEY=sk-... alexandria -- npx -y @the-40-thieves/alexandria-mcpSearch and read work with no environment variables at all; the --env flag
above is only needed to enable library_ask, library_answer,
library_research, and library_ingest. See Credentials
for the full list of optional keys.
Claude Desktop (stdio)
Minimum config (search and read only), using the published package via npx:
{
"mcpServers": {
"library": {
"command": "npx",
"args": ["-y", "@the-40-thieves/alexandria-mcp"],
"env": {
"TRANSPORT": "stdio"
}
}
}
}With library_ask and library_ingest enabled:
{
"mcpServers": {
"library": {
"command": "npx",
"args": ["-y", "@the-40-thieves/alexandria-mcp"],
"env": {
"TRANSPORT": "stdio",
"OPENAI_API_KEY": "sk-...",
"SUPABASE_URL": "https://your-project.supabase.co",
"SUPABASE_SERVICE_ROLE_KEY": "eyJ..."
}
}
}
}From a local checkout instead of the published package, replace command/
args with "command": "node", "args": ["/path/to/alexandria-mcp/dist/index.js"].
Railway (HTTP)
HTTP mode is off by default. Set TRANSPORT=http to serve Streamable HTTP on
/mcp instead of speaking stdio, and PORT to choose the listen port
(default 3000; Railway sets PORT for you). Every request gets its own MCP
server and transport, so the endpoint is stateless and safe to run behind a
load balancer.
Env Var | Values | Default |
|
|
|
| any port number, HTTP mode only |
|
/mcp (only) is guarded: DNS-rebinding-safe Host/Origin validation
(ALEXANDRIA_ALLOWED_ORIGINS, a comma-separated hostname list - loopback
is always allowed regardless) and a per-client-IP rate limit
(ALEXANDRIA_HTTP_RATE_LIMIT, default 60/minute, 429 with a JSON-RPC
error body once exceeded). See docs/fetch-tier-runtime.md for the
details and src/httpGuards.ts for the implementation.
Set ALEXANDRIA_ALLOWED_ORIGINS on any deployment reachable by a
hostname other than loopback. With it unset, Host-header validation is
off and the server logs one warning at startup saying so: a deployment's
Host header is its own hostname, which cannot be in an allowlist that does
not exist, so enforcing the check without one would 403 every request.
Setting it is what turns DNS-rebinding protection on. The Origin check is
unconditional either way, so a browser request carrying an Origin outside
the list is always rejected.
POST /mcp requires content-type: application/json (anything else is
415) and a body no larger than 100 KiB (413, connection closed).
Behind a reverse proxy or PaaS edge (Cloudflare Tunnel, Railway's own edge,
...) the rate limiter's per-client key defaults to req.socket.remoteAddress,
which is the proxy's address for every caller, not the caller's - set
ALEXANDRIA_TRUSTED_PROXY=1 to key on CF-Connecting-IP (falling back to
the rightmost X-Forwarded-For entry, the one appended by the last hop;
the leftmost entry is whatever the original caller sent) instead. Only set this once /mcp is
reachable exclusively through a proxy you trust to set those headers
honestly - see docs/cloudflare.md's Tunnel and Access section.
Serves both eras of the MCP protocol on the same /mcp endpoint:
createMcpHandler(factory, { legacy: 'stateless' }) (@modelcontextprotocol/server,
adapted to node:http by toNodeHandler() from @modelcontextprotocol/node)
answers a 2026-07-28 server/discover probe or per-request envelope on the
modern path, and falls back to the same stateless idiom the pre-2026 SDK used
for a 2025-era initialize handshake. One createServer() factory backs
both. stdio uses the connection-pinned serveStdio(factory) from
@modelcontextprotocol/server/stdio, which selects the era from the
connection's opening exchange. Note: the 2025-era fallback path answers over
text/event-stream (SSE) rather than a bare JSON body, since the SDK exposes
no equivalent to v1's enableJsonResponse for that path. Any MCP client
built on a Streamable HTTP transport (the SDK's own StreamableHTTPClientTransport
included) already parses either format transparently.
Set those (plus any source keys) in the Railway dashboard and deploy:
railway upLocally the same thing is:
TRANSPORT=http PORT=3000 npm startRegister in Claude Desktop:
{
"mcpServers": {
"library": {
"url": "https://your-service.up.railway.app/mcp"
}
}
}Health check: GET /health returns { status: "ok", version: "11.0.0", sources: { total: 152, visible: 116, hidden: 36, calls: 0, errors: 0 }, byKind: { rest: 118, hub: 0, rss: 22, mcp: 6, scrape: 6 }, quota: { day: "2026-09-02", reserved: 0, sources: 0, backend: "state" }, cache: { entries: 0 }, tools: 11 }.
Metrics: GET /metrics returns per-source counters (calls, errors, timeouts, cacheHits, quotaRejections, latencyMsTotal) and per-tool counters (invocations, llmCalls) as JSON, e.g. { "sources": { "arxiv": { "calls": 12, "errors": 0, "timeouts": 0, "cacheHits": 3, "quotaRejections": 0, "latencyMsTotal": 4210 } }, "tools": { "library_ask": { "invocations": 5, "llmCalls": 5 } } }. Only sources/tools actually called since the process started appear.
Install in other clients
All of these run the published package via npx; search and read work with
no environment variables, and --env/env block additions enable
library_ask, library_answer, library_research, and library_ingest the
same way the Claude Code and Claude Desktop sections above do.
GitHub Copilot - .vscode/mcp.json:
{
"servers": {
"alexandria": {
"command": "npx",
"args": ["-y", "@the-40-thieves/alexandria-mcp"]
}
}
}Windsurf - mcp_config.json:
{
"mcpServers": {
"alexandria": {
"command": "npx",
"args": ["-y", "@the-40-thieves/alexandria-mcp"]
}
}
}Codex CLI:
codex mcp add alexandria -- npx -y @the-40-thieves/alexandria-mcpOpenCode - opencode.json:
{
"mcp": {
"alexandria": {
"type": "local",
"command": ["npx", "-y", "@the-40-thieves/alexandria-mcp"]
}
}
}Amazon Q - ~/.aws/amazonq/mcp.json (global) or q mcp add:
{
"mcpServers": {
"alexandria": {
"command": "npx",
"args": ["-y", "@the-40-thieves/alexandria-mcp"]
}
}
}Kiro - .kiro/settings/mcp.json:
{
"mcpServers": {
"alexandria": {
"command": "npx",
"args": ["-y", "@the-40-thieves/alexandria-mcp"]
}
}
}Gemini CLI:
gemini extensions install https://github.com/The-40-Thieves/alexandria-mcpContinue - add to the mcpServers array in your Continue config:
{
"name": "alexandria",
"command": "npx",
"args": ["-y", "@the-40-thieves/alexandria-mcp"]
}Adding Custom Providers
The pipeline is provider-agnostic. To add a new embedding model or vector store:
Implement
EmbeddingProviderorVectorStoreProviderfromsrc/types.tsAdd your implementation to
src/pipeline/providers/Register it in
src/pipeline/providers/index.tsSet
EMBEDDING_PROVIDERorVECTOR_STORE_PROVIDERin your env
// Example: Ollama embedding provider
import type { EmbeddingProvider } from '../../types.js';
export class OllamaEmbeddingProvider implements EmbeddingProvider {
readonly dimensions = 768;
async embed(texts: string[]): Promise<number[][]> {
// your implementation
}
}Available Tools
11 toolslibrary_answerAnswer With Cited SourcesARead-only
Ask a question in plain English and get a synthesized answer with inline [n] citations, fused across sources with reciprocal rank fusion. Use this instead of library_ask when you want a cited answer rather than raw results. Every factual sentence is cited or dropped; an uncited or all-dropped answer is flagged in warnings[]. Requires OPENAI_API_KEY (or ALEXANDRIA_SYNTH_API_KEY). Set response_format: "detailed" for the full result set, routing, citation grades, and resolvability.
Inputs: query (required), read_top, max_sources, response_format, +1 more. Returns: answer, results, routing, warnings, +1 more
library_askNatural Language Library SearchARead-only
Ask for content in plain English; automatically selects the best sources from all 152 libraries, generates optimized per-source queries, and searches in parallel. Use this as the default entry point for any natural-language request. Use library_search instead when you already know which source to query. Requires OPENAI_API_KEY (already set for embeddings). Set response_format: "detailed" for routing reasons and per-stage diagnostics.
Inputs: query (required), max_sources, response_format, results_per_source. Returns: query, errors, intent, stage1, +5 more
library_citationsGet References or Citations (with Bibliography Export)ARead-onlyIdempotent
List the works a scholarly item cites (direction: "references") or the works that cite it (direction: "citations"), resolved through OpenAlex's citation graph with OpenCitations as a fallback when OpenAlex has no record. Accepts an id/source from library_search or library_ask, or a bare DOI/arXiv id. Set format: "bibtex" | "ris" | "apa" to also return a formatted bibliography string; BibTeX prefers Crossref's own citation when a DOI is resolvable, for the first 20 results only (a paced, one-at-a-time doi.org lookup per item), with later results using a locally generated entry instead. Set response_format: "detailed" for full result fields.
Inputs: id (required), source (required), direction (required), limit, +2 more. Returns: seed, results, direction, formatted
library_health_checkCheck Source HealthARead-onlyIdempotent
Report per-source health: 'ok', 'degraded', 'down', 'key_missing', or 'unknown', merging this process's live error rate and latency with the last off-process probe run. The probe layer reads eval/probe-latest.json, which published installs do not ship, so on a published install a source's status stays 'unknown' until this process itself calls it. Use before relying on a source that has been erroring, or to check whether a key is configured. Optionally filter by source or cluster. Set response_format: "detailed" for error rate, latency, and quota usage.
Inputs: source, cluster, response_format. Returns: probeAt, sources, generatedAt
library_indexPreview Chunking (Dry Run)ARead-onlyIdempotent
Dry run: fetch text, chunk semantically, score OCR quality. No writes. Full-text sources only.
Inputs: id (required), source (required). Returns: title, source, sourceId, totalChunks, +5 more
library_ingestIngest Into Vector DatabaseAIdempotent
Chunk, embed, and store a text. Idempotent. Full-text sources only. Requires OPENAI_API_KEY + SUPABASE_URL + SUPABASE_SERVICE_ROLE_KEY.
Inputs: id (required), source (required). Returns: title, source, sourceId, chunksDropped, +2 more
library_list_sourcesList Available Library SourcesARead-onlyIdempotent
List all 152 library sources (count computed from the live registry at startup) with descriptions and capabilities.
Inputs: no named parameters. Returns: sources
library_readRead Full Text or MetadataARead-onlyIdempotent
Fetch text from a library source. Full-text sources return cleaned text (truncated at 200k chars). Metadata sources return item details and an external URL.
Inputs: id (required), source (required). Returns: doi, note, text, year, +10 more
library_recommendGet Similar Papers (Semantic Scholar)ARead-onlyIdempotent
Get papers similar to a given paper using Semantic Scholar's recommendation engine. Pass a paperId from a semanticscholar search result. Returns up to 500 similar papers.
Inputs: id (required), limit. Returns: results
library_researchRecursive Cited ResearchARead-only
Deep research on a topic: outlines 3 to 7 coverage objectives, generates search queries, answers each with library_answer, extracts learnings and follow-up questions, then recurses with half the breadth. Stops once every objective is covered by a learning, at the given depth, at the time budget, or once a round finds no new sources. Requires OPENAI_API_KEY (or ALEXANDRIA_RESEARCH_API_KEY / ALEXANDRIA_SYNTH_API_KEY). Set response_format: "detailed" for the per-round breakdown, elapsed time, citation grades, resolvability, and the objectives/coverage outline.
Inputs: query (required), depth, breadth, max_minutes, +1 more. Returns: report, rounds, coverage, warnings, +3 more
library_searchSearch Library SourceARead-onlyIdempotent
Search a specific library source by name. Use library_ask instead for natural language queries across multiple sources.
Sources marked [full text] support library_read and library_ingest. Sources marked [metadata] return discovery info and external URLs only.
Inputs: query (required), source (required), limit, response_format. Returns: results
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 11 tools
Each tool targets a distinct operation—listing, health, natural-language search, specific search, read, dry-run indexing, ingest, recommend, answer, deep research, citations. Overlaps like ask vs. answer are clearly differentiated by descriptions.
All tools follow the library_<verb> pattern with consistent snake_case naming. Verbs are clear and predictable (list, search, read, ingest, etc.), with minor noun-based exceptions like 'health_check' and 'citations' that still fit the pattern.
11 tools is well within the ideal 3-15 range and each serves a distinct purpose, covering the full lifecycle from discovery to ingestion to synthesis without redundancy.
The tool set covers discovery (list_sources), health (health_check), search (ask, search), retrieval (read), ingestion (index, ingest), recommendation, synthesis (answer, research), and citations. No obvious gaps exist for a library server's expected operations.
Maintenance
Related MCP Connectors
Search a billion+ documents — papers, books, code, legal cases, forums, Wikipedia, and more.
Federated search of books and papers, BibTeX/RIS citations, open-access retrieval and reading.
Academic literature search, retrieval, and private library management on top of OpenAlex.
Research papers from OpenAlex, Crossref, arXiv and PubMed in one search, merged by DOI.
Related MCP Servers
- AlicenseBqualityBmaintenanceEnables searching and downloading academic papers from 14 platforms including arXiv, PubMed, Google Scholar, Web of Science, Springer, and Sci-Hub with unified data format and intelligent rate limiting.21250 npm191MIT
- AlicenseAqualityDmaintenanceEnables users to search, download, and read academic papers from multiple platforms including arXiv, PubMed, bioRxiv, Google Scholar, Semantic Scholar, and CrossRef through a unified interface.347MIT
- AlicenseAqualityDmaintenanceSearch across a billion+ documents including academic papers, books, code, legal cases, forums, and Wikipedia. Provides search and detail tools for various content types.236 npm24 PyPIMIT
- AlicenseAqualityDmaintenanceSearches and retrieves academic papers from open access sources like arXiv, Semantic Scholar, and PubMed, with full text access via arXiv PDFs, PubMed Central, and Unpaywall.2MIT