MCP Server Compass: Discovery and Recommendations

Overview

MCP Server Compass is a lightweight discovery and recommendation service for MCP (Model Context Protocol) servers. It helps developers and operators find the best MCP server instances for a given workload by collecting server metadata, evaluating capabilities (latency, cost, model support, resources), and returning ranked recommendations. This reduces manual search and speeds integration of models and tools that depend on MCP endpoints.

Compass is useful when you operate or consume multiple MCP servers across regions, cloud providers, or providers with different hardware. By centralizing discovery and exposing a simple API, Compass makes it easy to select servers that meet constraints such as model compatibility, GPU availability, geographic proximity, or budget limits.

Features

• Server discovery: aggregate MCP server metadata from registries or manual registration
• Recommendation engine: score and rank servers based on customizable criteria (latency, cost, capabilities)
• Simple HTTP API: query with filters, get structured recommendations
• Containerized deployment: run Compass as a Docker container for easy integration
• Configurable policies: tune scoring weights, region preferences, and whitelists
• Health & metrics: basic health endpoints for monitoring and integration with observability tools

Installation / Configuration

Clone the repository and run from source or use the provided Docker image. The examples below are general-purpose; refer to the repository README for build details if you need language-specific build steps.

Clone and run locally (example):

git clone https://github.com/liuyoshio/mcp-compass.git
cd mcp-compass
# If there's a Makefile or build script:
make build
./mcp-compass --config ./config.yaml

Run with Docker:

# Pull a published image (replace with actual image name if available)
docker pull liuyoshio/mcp-compass:latest

# Run with environment configuration
docker run -d \
  -p 8080:8080 \
  -e MCP_REGISTRY_URL="https://registry.example.com" \
  -e RECOMMENDATION_WEIGHTS='{"latency":0.5,"cost":0.3,"capabilities":0.2}' \
  liuyoshio/mcp-compass:latest

Example minimal config (YAML):

server:
  bind: "0.0.0.0:8080"

registry:
  url: "https://registry.example.com"
  poll_interval_seconds: 60

recommendation:
  weights:
    latency: 0.5
    cost: 0.3
    capabilities: 0.2
  max_results: 5

Environment variables commonly used:

• MCP_REGISTRY_URL — URL of an MCP registry to discover servers
• RECOMMENDATION_WEIGHTS — JSON string controlling scoring weights
• PORT or SERVER_BIND — port or address to bind HTTP API

Available Resources

Compass exposes a small set of HTTP endpoints for discovery and recommendations. Typical endpoints include:

• GET /health — basic liveness/ readiness checks
• POST /discover — register or update server metadata (if using push model)
• GET /servers — list discovered servers with filters
• POST /recommend — request ranked recommendations for a given requirement

Example request to /recommend:

curl -X POST http://localhost:8080/recommend \
  -H "Content-Type: application/json" \
  -d '{
    "model": "gpt-4o",
    "region": "us-west",
    "max_cost_per_minute": 0.50,
    "require_gpu": true
  }'

Typical recommendation response (JSON):

{
  "query_id": "abc123",
  "results": [
    {
      "id": "mcp-01",
      "address": "https://mcp-01.example.com",
      "score": 0.92,
      "latency_ms": 28,
      "cost_per_min": 0.45,
      "capabilities": ["gpt-4o", "streaming", "batch"]
    }
  ]
}

Reference table: common request parameters and response fields

Use Cases

1. Selecting the lowest-latency server for interactive inference

   • Query /recommend with region and max acceptable latency; Compass returns ranked servers with measured latency values so your client can pick the top result.

2. Choosing a cost-effective GPU server for batch model fine-tuning

   • Set require_gpu=true and max_cost_per_minute to limit costly instances. Compass ranks GPU-enabled servers by cost and capability.

3. Multi-region failover and routing

   • Use /servers to fetch available servers in multiple regions. If a primary instance fails health checks, automatically fall back to the next recommended server.

4. Model compatibility filtering for heterogeneous fleets

   • Request recommendations for a specific model name; Compass filters out servers that lack compatible model runtimes or required features (streaming, batch transforms).

5. Continuous integration and canary testing

   • Integrate Compass into CI pipelines to direct test traffic to targeted MCP instances (e.g., canaries in a staging region) based on configured policies.

Getting Started Tips

• Start by registering a small set of MCP servers and verify /health and /servers responses.
• Tune recommendation weights to match your SLA priorities (latency vs cost).
• Use containerized deployment for consistent staging and production environments.
• Monitor the registry and poll intervals so discovery reflects current fleet state.

For the latest source, issues, and contribution guidelines, see the project repository: https://github.com/liuyoshio/mcp-compass.