Token Metrics MCP Server: Real-Time Crypto Market Data

Overview

The Token Metrics MCP (Model Context Protocol) Server provides programmatic access to real-time crypto market data, quantitative trading signals, price predictions, and analytics. It acts as a streaming and request/response gateway that aggregates market feeds, model outputs, and derived analytics into a stable API surface suitable for trading systems, dashboards, research notebooks, and alerting pipelines.

For developers, the MCP server is useful because it standardizes how model context and market state are delivered: streaming updates for low-latency clients, REST endpoints for ad-hoc queries, and structured payloads for easy consumption by downstream systems. This reduces engineering time spent integrating disparate data sources and lets teams focus on strategy, backtesting, and execution.

Features

• Real-time market price feeds and historical price queries
• Model-driven price predictions and probability distributions
• Trading signals (entry/exit, conviction scores, time horizon)
• WebSocket streaming for low-latency updates
• REST API for snapshot and historical requests
• API key authentication and configurable rate limiting
• Dockerized deployment and environment-driven configuration
• SDK examples in Python and JavaScript (client snippets)

Installation / Configuration

Quick-start using Docker (recommended for development):

# Clone the repo
git clone https://github.com/token-metrics/mcp.git
cd mcp

# Build and run with Docker Compose
docker compose up --build

Environment variables (example .env):

# .env
MCP_API_KEY=your_api_key_here
MCP_PORT=8080
MCP_RATE_LIMIT=100
MCP_DB_URL=postgres://user:pass@db:5432/mcp
MCP_LOG_LEVEL=info

Run locally with Node (if the project uses Node/TypeScript):

# Install dependencies
npm install

# Build (if TypeScript)
npm run build

# Start server
npm start

Configuration file example (YAML):

server:
  port: 8080
  logLevel: info
auth:
  apiKey: ${MCP_API_KEY}
sources:
  exchanges:
    - binance
    - coinbase
models:
  predictionWindow: 24h

Available Tools / Resources

• REST API endpoints for snapshots and historical queries
• WebSocket streaming endpoint for market updates, model outputs, and signals
• Postman collection (recommended for exploratory testing)
• Client SDK snippets (Python, JavaScript)
• Example Jupyter notebooks demonstrating streaming ingestion and backtesting
• Docker Compose for local environment orchestration
• API documentation (hosted or in-repo OpenAPI/Swagger spec)

Example local resources table:

Example API Usage

REST snapshot: current price and prediction

curl -H "Authorization: Bearer $MCP_API_KEY" \
  "http://localhost:8080/v1/price?symbol=BTC-USD"

WebSocket streaming (JavaScript):

const ws = new WebSocket('ws://localhost:8080/ws/stream?api_key=YOUR_KEY');

ws.onmessage = (evt) => {
  const msg = JSON.parse(evt.data);
  // example msg: {type: 'price', symbol: 'BTC-USD', price: 47600, ts: 123456789}
  console.log(msg);
};

Python example (requests):

import requests

headers = {"Authorization": "Bearer " + "YOUR_API_KEY"}
resp = requests.get("http://localhost:8080/v1/predictions?symbol=ETH-USD", headers=headers)
print(resp.json())

Use Cases

• Trading bot: subscribe to the WebSocket feed for prices and trading signals, apply execution logic, and send orders to an exchange API when model conviction exceeds thresholds.
• Dashboard and monitoring: pull REST snapshots for multiple symbols on a schedule to populate a real-time dashboard with predictions, signal status, and risk metrics.
• Research & backtesting: download historical model outputs and signals to run backtests and evaluate strategy performance over defined windows.
• Alerting and automation: create alerting rules that trigger when a model’s probability distribution crosses a risk threshold or when high-conviction signals occur.
• Portfolio analytics: ingest predictions and expected returns for assets into portfolio optimization pipelines to rebalance holdings.

Best Practices

• Use WebSocket for low-latency needs; REST for periodic snapshots or historical queries.
• Cache relatively static data (market metadata, symbol lists) and only stream time-series and model outputs.
• Respect rate limits and use API keys scoped per environment (dev/staging/production).
• Validate incoming model outputs in downstream systems (e.g., smoothing, sanity checks) before automated execution.

For full API details, examples, and deployment options, consult the repository at https://github.com/token-metrics/mcp and the included OpenAPI documentation.