Free · CC-BY-4.0

MCP Servers Catalog

Name: MCP Servers Catalog
Creator: AutomateLab
License: https://creativecommons.org/licenses/by/4.0/

2,223 Model Context Protocol servers as one queryable table. Every entry on the curated awesome-mcp-servers list, parsed into 49 normalized categories with language, deployment scope, OS, and officiality columns. The list is for scrolling; this MCP servers catalog is for code. Refreshed monthly.

View on HuggingFace Source on GitHub Kaggle mirror

What you get

One flat table, one row per MCP server. The upstream README's emoji flags become real columns you can filter on, so "all cloud-scoped TypeScript servers in the Databases category" is a one-liner instead of a scroll through 3,000 README lines.

2,223 MCP servers cataloged

49 normalized categories

127 vendor-official servers

857 servers with a Glama quality badge

By language: TypeScript 1,126 · Python 787 · Go 137 · Rust 58 · Java 23 · C# 17. By scope: cloud 1,263 · local 1,137 · embedded 16 (a server can carry more than one). Top categories: Developer Tools (327), Finance & Fintech (273), Knowledge & Memory (159), Search & Data Extraction (140), Security (124), Databases (105).

What each record contains

servers.json / servers.parquet - one row per server (2,223 rows), deduplicated on repository URL.

Field	Type	Notes
`name`	string	The `owner/repo` identifier from the list entry (e.g. `punkpeye/fastmcp`).
`url`	string	Repository URL. Dedup key: URL collisions keep the first occurrence.
`source_host`	string	`github` for 2,211 of 2,223 rows; the rest are `gitlab`, `npm`, or `other`.
`category`	string	One of 49 categories, taken from the section header the entry sits under (Databases, Security, Finance & Fintech, ...).
`description`	string	The entry's one-line description, with badge markup and flag emoji stripped.
`languages`	string[]	Implementation language(s) parsed from the list's emoji legend: `typescript`, `python`, `go`, `rust`, `java`, `csharp`, `c_cpp`, `ruby`.
`scopes`	string[]	Deployment scope: `cloud`, `local`, `embedded`. Multi-valued.
`operating_systems`	string[]	`macos`, `windows`, `linux` - only where the entry declares them.
`is_official`	boolean	True when the entry carries the list's official-implementation flag (127 servers).
`has_glama_badge`	boolean	True when the entry embeds a glama.ai quality-score badge (857 servers). `glama_server_path` holds the badge path.
`npm_install`	string	The install one-liner where the description contains one (e.g. `npx some-server`). Present on 82 rows.

What makes it different

Machine-readable, not browsable

Existing MCP directories (the awesome list itself, glama.ai, mcp.so) are built for humans. This is the same landscape as a flat, Parquet-native table an agent or a researcher can load in one line and filter, rank, or embed - no scraping, no HTML parsing.

Flags become columns

The upstream list encodes language, scope, and OS as emoji on each line. The extractor normalizes them into typed columns, so "Python servers that run locally on Windows" is a filter expression, not a visual scan.

Honest derived work

This catalog is parsed from the punkpeye/awesome-mcp-servers community list - the curation is theirs, and every row links back to the original project. Our additions are the structure: the extraction script, the normalized schema, and the monthly refresh.

Deterministic monthly refresh

The extraction script is idempotent: same README in, byte-identical output. Each monthly re-run diffs cleanly against the last, so the change history reflects real ecosystem movement - new servers, removals, recategorizations - not parser noise.

Pairs with runtime data

This catalog tells you what each server claims to be. Its companion, the MCP Servers Tool Catalog, tells you what 922 of them actually expose at runtime - real tool names and input schemas captured over stdio. Listing data and runtime data, joinable on repository.

How extraction works

The whole pipeline is one script - extract.py in the GitHub repo. On each run it:

Reads the awesome-mcp-servers README - local path or fetched from GitHub.
Walks the Server Implementations section, tracking ### category headers as it goes. Those headers become the 49 category values.
Parses each list entry - splits the link, strips Glama badge markup, and decodes the emoji flags region into language, scope, and OS metadata.
Deduplicates on URL, keeping the first occurrence of any collision.
Emits both formats - servers.json (UTF-8 JSON array) and servers.parquet (Snappy-compressed columnar).

Refreshed monthly in sync with the upstream list. Latest extraction: 2,223 servers. Because the script is deterministic, any snapshot can be reproduced from the corresponding upstream README revision.

Three ways to access it

HuggingFace datasets API

pip install datasets
from datasets import load_dataset

ds = load_dataset("automatelab/mcp-servers-catalog", split="train")

# every official database server
db = ds.filter(lambda r: r["category"] == "Databases" and r["is_official"])
print(len(db), "official database MCP servers")

Parquet + pandas

pip install pandas pyarrow
import pandas as pd

df = pd.read_parquet("servers.parquet")

# category leaderboard
print(df.groupby("category").size().sort_values(ascending=False).head(10))

DuckDB SQL

SELECT category, COUNT(*) AS servers
FROM read_parquet('servers.parquet')
WHERE list_contains(languages, 'python')
GROUP BY category
ORDER BY servers DESC
LIMIT 10;

Dataset card and files: HuggingFace or the Kaggle mirror. Extraction source: AutomateLab-tech/mcp-servers-catalog on GitHub.

FAQ

What is the MCP Servers Catalog dataset?

A machine-readable catalog of 2,223 Model Context Protocol (MCP) servers across 49 categories. Each row carries the server's name, repository URL, category, description, implementation language, deployment scope (cloud, local, or embedded), supported operating systems, an official flag, a Glama quality-badge flag, and an npm install hint where one exists. It ships as one flat table in JSON and Parquet, so an agent or a researcher can load and filter it in one line.

How many MCP servers are there?

This catalog counts 2,223 MCP servers listed on the curated awesome-mcp-servers community list as of the latest monthly extraction. That is a lower bound for the ecosystem: it covers servers the community list has accepted, not every MCP server ever published to npm or PyPI. By language: 1,126 TypeScript, 787 Python, 137 Go, 58 Rust. By scope: 1,263 cloud, 1,137 local, 16 embedded (a server can carry more than one scope).

Where does the data come from?

From the punkpeye/awesome-mcp-servers community list, the largest curated directory of MCP server implementations. The catalog is a derived work: our extraction script parses the list's README into structured rows, normalizing the emoji flags each entry carries into real language, scope, and OS columns. Upstream server listings remain the community's work; our additions (the catalog format, the extraction script, and this page) are CC-BY-4.0.

How is this different from browsing awesome-mcp-servers or glama.ai directly?

Those surfaces are for humans: a README you scroll and a website you click. This catalog is for code. The same information becomes a flat table you can filter, join, rank, or embed - "all cloud-scoped TypeScript servers in the Databases category" is one pandas line instead of a manual scroll through 3,000 README lines. If you want runtime behavior instead of listings (actual tool names and input schemas), see our companion dataset, the MCP Servers Tool Catalog.

How often is the catalog refreshed?

Monthly, in sync with the upstream awesome-mcp-servers list. The extraction script is deterministic and idempotent: re-running it on the same README produces byte-identical output, so each monthly diff reflects real upstream change - new servers, removed servers, recategorizations - not extraction noise.

How do I load the MCP Servers Catalog in Python?

Via the HuggingFace datasets library: from datasets import load_dataset; ds = load_dataset('automatelab/mcp-servers-catalog', split='train'). Or read the Parquet directly with pandas: df = pd.read_parquet('servers.parquet'). DuckDB works too: SELECT category, COUNT(*) FROM read_parquet('servers.parquet') GROUP BY category ORDER BY 2 DESC.

Picking the right MCP server for your agent?

We use this catalog and its runtime companion to choose MCP servers for production agent pipelines at AutomateLab. If you want that selection - and the wiring, credentials, and monitoring around it - done for your stack, we can scope and build it.

Get in touch