11,000+ MCP Servers: How TormentNexus Built the Definitive Index for the Entire AI Tooling Ecosystem
TormentNexus now indexes over 11,000 MCP servers from Glama, Smithery, MCP.run, npm, and GitHub Topics — all searchable in a single query. Explore how one unified MCP server catalog is changing tool discovery for AI developers everywhere.
The Explosion Nobody Saw Coming
Two years ago, the Model Context Protocol was a curiosity — a specification with a handful of experimental implementations. Today, there are over 11,000 MCP servers published across the internet, each one a potential integration point for AI agents. The problem? They're scattered across five-plus platforms, inconsistent in documentation quality, and nearly impossible to evaluate without manually clicking through each source.
Glama alone hosts thousands of server listings. Smithery maintains its own curated registry. MCP.run provides a runtime environment with its own index. npm has become a distribution channel for TypeScript-based MCP servers. GitHub Topics has organically become one of the largest discovery surfaces through the mcp-server tag alone. If you're building an AI application and need a specific capability — say, a PostgreSQL connector with vector search support — you'd traditionally need to search across all of these platforms separately, cross-reference quality signals, and hope you didn't miss a better option buried in a different registry.
TormentNexus eliminates that fragmentation entirely. With our latest crawl and indexing pass, we've unified 11,247 unique MCP servers into a single, filterable, searchable catalog. One search bar. Every source. Real metadata.
Touring the Sources: Where the 11K Servers Actually Live
Understanding the landscape means understanding where servers are published. Here's the current breakdown of our index, as of the latest snapshot:
| Source Platform | Indexed Servers | Primary Language | Update Frequency |
|---|---|---|---|
| Glama | 3,412 | Multi-language | Daily |
| Smithery | 2,891 | Multi-language | Daily |
| GitHub Topics | 2,634 | Multi-language | Every 6 hours |
| npm Registry | 1,508 | TypeScript/JavaScript | Near real-time |
| MCP.run | 802 | Multi-language | Daily |
Each platform has its own metadata schema, versioning conventions, and quality signals. Glama provides structured capability tags. Smithery offers install commands and runtime compatibility data. npm exposes version history, download counts, and dependency trees. GitHub provides stars, issues, and commit activity. MCP.run focuses on sandboxed execution metadata.
The critical insight: no single source tells the full story. A server with 500 GitHub stars but no npm downloads might be experimental. A heavily-downloaded npm package with zero stars might be an internal tool accidentally published publicly. A Glama listing with rich capability tags but no source repository might be closed-source. TormentNexus merges these signals into a unified trust and quality profile for every server in the catalog.
Unified Search: One Query Across Every Registry
The core value proposition is straightforward but powerful: type what you need, get results from everywhere. Here's what a search for "postgres" returns across our unified MCP server catalog:
Search: "postgres"
Results: 47 servers across 4 sources
Top Results:
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
1. @modelcontextprotocol/server-postgres
Source: npm + Glama + GitHub
Stars: 1,247 | Weekly Downloads: 12,891
Capabilities: query, schema-inspection, migrations
Status: Official Reference Implementation
2. postgres-mcp-server
Source: Smithery + GitHub
Stars: 312 | Verified: ✓
Capabilities: read-only queries, connection pooling
Runtime: Docker, stdio
3. mcp-postgres-vector
Source: Glama + npm
Stars: 89 | Downloads: 1,204/week
Capabilities: pgvector integration, similarity search, embeddings
Status: Active Development
4. supabase-mcp-bridge
Source: GitHub Topics
Stars: 201 | Forks: 34
Capabilities: Supabase-specific, auth, edge functions
Status: Community Maintained
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━Compare this to the alternative: manually searching npm for mcp postgres, then Glama's search, then Smithery's, then GitHub's topic page — four separate interfaces, four different result formats, no way to meaningfully compare cross-platform signals. TormentNexus does the cross-referencing for you, deduplicating entries that appear in multiple registries while preserving source-specific metadata.
You can also filter by capability tags. Need an MCP server that supports both query and schema-inspection? Use the advanced filter syntax:
https://tormentnexus.site/search?q=postgres&capabilities=query,schema-inspection&minStars=10&source=allThis returns only the 8 servers that meet all three criteria — capability match, minimum community validation, available across any source. The full filter API supports language, runtime (stdio, SSE, Docker), license, lastUpdated, and installCommand presence.
Beyond Search: Evaluation Signals That Matter
Finding MCP servers is table stakes. Evaluating them is where TormentNexus provides asymmetric value. For every server in the 11K+ catalog, we compute and surface a composite score based on:
Cross-platform presence. A server published on npm and Glama and GitHub has redundant discoverability, which correlates with maintenance effort. We weight multi-source servers higher.
Update recency. We track the last publish date across all indexed sources. An MCP server last updated 14 months ago is likely abandoned. One updated last Tuesday is actively maintained. We flag servers with no update in 90+ days.
Dependency health. For npm-published MCP servers, we analyze the dependency tree. A server pulling in 47 transitive dependencies — three of which are unmaintained — carries more operational risk than one with 6 dependencies that are all actively maintained.
Installation friction. Does the server provide a one-line npx command? A Docker image? Or just a Git repo with a partial README and no install instructions? We score installation complexity and surface it directly in search results.
Here's an example of the evaluation card for a mid-tier MCP server:
┌─────────────────────────────────────────────────┐
│ @tormentnexus/server-redis │
│ │
│ Sources: npm ✓ Glama ✓ GitHub ✓ │
│ Stars: 89 │
│ Downloads: 3,401/week │
│ Last Update: 4 days ago │
│ License: MIT │
│ Runtime: stdio, SSE │
│ │
│ Install: │
│ npx -y @tormentnexus/server-redis │
│ │
│ Capabilities: │
│ • key-value operations │
│ • pub/sub channels │
│ • streams │
│ • module loading │
│ │
│ Trust Score: 8.2/10 │
│ Maintenance: Active ✓ │
│ Dep Health: 22 deps, all maintained │
│ Install Score: One-liner ✓ │
└─────────────────────────────────────────────────┘This kind of structured evaluation across 11,000+ servers is impossible to replicate manually. It's the difference between spending an afternoon comparing tools and spending a quarter building an internal registry that's already outdated by the time it ships.
For Platform Builders: MCP Server Catalog as Infrastructure
If you're building an AI agent framework, an IDE plugin, or any tool that needs to connect MCP servers dynamically, maintaining your own registry is a losing game. The MCP ecosystem moves too fast. New servers ship daily. Existing servers update, deprecate, fork, and merge constantly.
TormentNexus exposes a structured API for the entire catalog. You can query by capability, language, runtime, source platform, or any combination thereof. The response includes everything you need to programmatically integrate tool discovery into your own application:
GET /api/v1/servers?capabilities=filesystem,search&language=python&minTrustScore=7
Response:
{
"total": 23,
"servers": [
{
"id": "tn-28471",
"name": "filesystem-mcp-python",
"sources": ["npm", "github", "smithery"],
"installCommand": "pip install filesystem-mcp-server",
"capabilities": ["filesystem:read", "filesystem:write", "search"],
"trustScore": 8.7,
"lastUpdated": "2025-01-10T14:22:00Z",
"runtime": ["stdio"],
"license": "MIT"
}
]
}This turns tool discovery from a search problem into an API call. Your agent can dynamically discover, evaluate, and install MCP servers at runtime based on user intent — without hardcoding a server list that goes stale in a week.
The State of the MCP Ecosystem in Numbers
Eleven thousand servers is a milestone, but the trajectory is more interesting than the current count. Here's what our indexing data reveals about the MCP ecosystem's growth patterns:
Growth rate: The catalog grew 340% in the last 6 months. At the current trajectory, we'll cross 25,000 indexed servers by Q3 2025. The GitHub Topics source is the fastest-growing, up 520% since June, largely driven by developer experimentation with MCP as a general-purpose integration protocol.
Language distribution: TypeScript/JavaScript dominates at 62% (primarily via npm), Python holds 29% (via PyPI and GitHub), and the remaining 9% spans Rust, Go, C#, and other languages. The Python share is growing faster month-over-month, driven by the LangChain and LlamaIndex communities standardizing on MCP.
Capability clustering: The most common capability combinations are filesystem + search (1,847 servers), database + query (1,203 servers), and api + authentication (987 servers). The rarest but fastest-growing category: multi-modal + memory, which grew from 12 servers to 89 servers in three months.
Abandonment rate: Roughly 14% of indexed servers show no update activity in 90+ days. TormentNexus flags these with a "Stale" badge, protecting you from building integrations against servers that may not work with current MCP protocol versions.
Tool discovery in the MCP ecosystem has evolved from "search GitHub and hope for the best" to a mature, filterable, programmatically-accessible catalog of 11,000+ servers — all unified in one place. The era of checking five different registries to find a single connector is over.
Search 11,000+ MCP servers across every major registry — Glama, Smithery, MCP.run, npm, and GitHub — in a single query at <a href="https://tormentnexus.site
Originally published at tormentnexus.site
Top comments (0)