Wong2 Curated MCP Server Directory

Overview

Wong2’s Curated MCP Server Directory is a community-maintained index of Model Context Protocol (MCP) servers. It collects server metadata — endpoints, transport types, regions, and community notes — so developers can discover reliable MCP instances to connect their agents, bots, or tools. Because entries are curated via GitHub pull requests, the directory emphasizes verifiable information and community moderation.

For developers new to MCP or to the server ecosystem, the directory reduces friction when choosing a server: instead of chasing forum posts or ad-hoc lists, you get a single canonical place that lists active servers and their capabilities. The repository also provides examples of the expected metadata schema and a straightforward contribution workflow for adding or updating listings.

Features

• Curated list of MCP servers with community review
• Standardized metadata per server (URL, transport, region, tags, status)
• GitHub-based contribution workflow (PRs + issues)
• Health/status and “last checked” fields where available
• Example entries and templates to help you add your own server
• Machine-friendly formats (JSON/YAML examples) to integrate into tools

Installation / Configuration

You don’t “install” the directory — you clone it or fetch its data and use the metadata to connect to servers. Typical workflows:

Clone the repository locally

git clone https://github.com/wong2/awesome-mcp-servers.git
cd awesome-mcp-servers

Fetch a machine-readable index via GitHub API (useful for scripts)

# Get the repository contents (example: listing a directory called 'servers')
curl -s https://api.github.com/repos/wong2/awesome-mcp-servers/contents/servers \
  | jq '.[] | {name: .name, download_url: .download_url}'

Add or update a server entry (contribute via PR)

1. Create a JSON or YAML file in the recommended directory (e.g., servers/ or data/).
2. Follow the repo’s metadata schema (example below).
3. Open a Pull Request with a short description and test ping to the endpoint.

Example server metadata (JSON)

{
  "name": "example-mcp",
  "url": "wss://mcp.example.org/ws",
  "transport": "websocket",
  "region": "eu-central-1",
  "protocols": ["mcp-1.0"],
  "tags": ["public", "low-latency"],
  "contact": "[email protected]",
  "notes": "Supports multi-agent rooms; rate limits apply"
}

Example server metadata (YAML)

name: example-mcp
url: wss://mcp.example.org/ws
transport: websocket
region: eu-central-1
protocols:
  - mcp-1.0
tags:
  - public
  - low-latency
contact: [email protected]
notes: Supports multi-agent rooms; rate limits apply

Connecting to a WebSocket MCP server (simple Python example)

# Requires: pip install websockets asyncio
import asyncio
import websockets

async def main():
    url = "wss://mcp.example.org/ws"
    async with websockets.connect(url) as ws:
        # Example join / handshake message (protocol-specific)
        await ws.send('{"type":"hello","client":"my-client"}')
        resp = await ws.recv()
        print("Response:", resp)

asyncio.run(main())

Note: The exact handshake and message formats depend on the MCP implementation exposed by the target server. Consult the server’s metadata and contact fields for protocol specifics.

Available Resources

• GitHub repository (primary): https://github.com/wong2/awesome-mcp-servers
• Contribution guidelines and PR template (in the repo)
• Example entries showing common transport types (websocket, http)
• Health-check and test scripts (community-contributed; check the repo)
• Contact info per server entry for server-specific docs and API schemas

Typical server metadata fields (reference table)

Use Cases

• Discover a low-latency server in your region: filter entries by region tag and transport to find a nearby WebSocket MCP for real-time agent coordination.
• Integrate a discovered server into your bot: use the JSON/YAML metadata to auto-configure your client, then follow the server’s contact details for protocol-specific handshakes.
• Add your team’s MCP instance to the ecosystem: create a metadata file, open a PR with uptime/health info, and let others find and test your server.
• QA and testing: fetch the repo programmatically to run automated integration tests against a curated list of public MCP endpoints.
• Community building: find servers that advertise public rooms, join communities, and discover multi-agent implementations or shared-context services.

If you’re new to MCP or server selection, start by cloning the repository, inspecting example entries, and using the metadata to trial a connection in a controlled environment. For adding servers, follow the repo’s contribution workflow so other developers can benefit from your listing.