OpenAlex.org MCP Server for ML-Powered Author Disambiguation

Overview

This MCP server provides a programmatic bridge between the OpenAlex scholarly dataset and machine-learning systems that need rich, structured context about researchers, their publications, and affiliations. It implements the Model Context Protocol (MCP) pattern: lightweight HTTP endpoints that return curated, pre-processed context objects (author profiles, work records, citation neighborhoods, etc.) that ML models and downstream services can request at inference time to improve tasks such as author disambiguation, entity linking, and profile generation.

By centralizing OpenAlex-derived content and serving it in a consistent, queryable format, the server reduces the work required to maintain up‑to‑date context stores, to precompute embeddings or indices, and to format complex bibliographic graphs for model consumption. Teams building research discovery, bibliometrics, or disambiguation pipelines can call this service to fetch contextual evidence rather than embedding the entire OpenAlex dataset into the model prompt.

Features

• Exposes MCP-style HTTP API for requesting structured context objects.
• Prepares and serves enriched author profiles derived from OpenAlex works and affiliations.
• Search-capable endpoints to find candidate authors, works, and institutions.
• File-storage support for storing raw OpenAlex snapshots and derived artifacts.
• Incremental update workflows to refresh profiles when OpenAlex updates.
• Optional embeddings/vector index integration for fast similarity search.
• Configurable schema and rate limits suitable for production and experimentation.
• Docker support and simple local development setup.

Installation / Configuration

Minimum requirements:

• Docker (recommended) or Python 3.9+
• OpenAlex dump or access to OpenAlex API for initial import
• Optional: Postgres or other supported DB for larger installations

Quick start with Docker Compose:

git clone https://github.com/drAbreu/alex-mcp.git
cd alex-mcp

# copy example env and adjust as needed
cp .env.example .env

# bring up the service
docker compose up --build -d

Run locally (Python venv):

python -m venv .venv
source .venv/bin/activate
pip install -r requirements.txt

# configure via config.yml or environment variables
export MCP_DATABASE_URL=postgresql://user:pass@localhost/alex
export OPENALEX_SNAPSHOT_PATH=/data/openalex
python -m alex_mcp.server --config config.yml

Example configuration (config.yml):

server:
  host: 0.0.0.0
  port: 8080

storage:
  type: postgres
  url: ${MCP_DATABASE_URL}

openalex:
  snapshot_path: /data/openalex
  incremental_updates: true

search:
  vector_index: optional
  max_results: 20

API keys and authentication can be enabled by setting environment variables or integrating with a reverse proxy. See the repo’s docs for production deployment patterns.

Available Resources

• GitHub repository: https://github.com/drAbreu/alex-mcp
• OpenAlex data: https://openalex.org/ (snapshots and API)
• MCP pattern/spec: use MCP endpoints to fetch model context objects (documented in repo)
• Example Postman collection and sample queries included in the repo (look under /examples)
• Optional vector-store examples showing integration with FAISS or Milvus

API endpoints (typical):

Responses are JSON objects designed to be compact and immediately usable as model context.

Use Cases

• Author disambiguation in ingestion pipelines:

  • When ingesting a new paper metadata record, call /mcp/search/authors with name and affiliation hints to get candidate author profiles and supporting works. Feed these profiles to an ML classifier or an LLM prompt to pick the correct canonical author ID.

• Prompt enrichment for LLM-based profile synthesis:

  • Request /mcp/author/{id} to retrieve a curated list of publications, coauthors, and common keywords. Provide that context to an LLM to generate a concise researcher biography or summary.

• Researcher profile pages:

  • Use the server as a backend to assemble profiles that combine OpenAlex raw fields with pre-filtered evidence (top publications, recent affiliations, citation counts) so the UI can render pages without expensive joins or queries against the raw dump.

• Similarity search and candidate generation:

  • Integrate the optional vector index to find nearest-neighbor author or work candidates by title embeddings, then use MCP payloads to vet candidates deterministically.

• Continuous updates and monitoring:

  • Configure incremental updates so the MCP server periodically ingests OpenAlex changes and recalculates profile aggregates; the /mcp/update endpoint allows on-demand refresh for critical records.

Troubleshooting & Tips

• Start small: begin with a subset of OpenAlex (e.g., specific institutions or years) to validate disambiguation flows before indexing the whole dataset.
• Monitor storage/backups for snapshot downloads—OpenAlex snapshots are large.
• If you use an external vector store, ensure the embedding pipeline and versioning are consistent with the index to avoid drift.
• Use the health endpoint and logs to track ingest progress and to verify MCP response latency for model usage.

For full API reference, example scripts, and deployment guidance, see the repository README and the docs folder in the project repository.