NO
OfficialFinance

Nodit MCP Server: Multi-Chain RPC and Data APIs

Access the Nodit MCP server for multi-chain RPC nodes and data APIs to integrate reliable blockchain data.

View on GitHub
Quick Install
npx -y @noditlabs/nodit-mcp-server

Overview

Nodit MCP Server is a multi-chain RPC and data API gateway designed to simplify access to blockchain node infrastructure. It aggregates and proxies JSON-RPC endpoints (HTTP and WebSocket), provides REST-style data APIs for blocks/transactions/accounts, and exposes health/metrics endpoints so backend systems can rely on a single, configurable endpoint for multiple chains and providers.

This server is useful when you need consistent, production-ready access to blockchain data across multiple networks (Ethereum and other EVM chains, or custom chains). It supports endpoint aggregation, provider failover, basic caching, rate limiting, and API key control so wallets, traders, explorers, and analytics systems can interact with blockchain data reliably without building provider orchestration from scratch.

Features

  • Multi-chain support (configurable providers per chain)
  • Unified JSON-RPC proxy (HTTP and WebSocket)
  • REST data APIs for common queries (blocks, transactions, logs, balances)
  • Provider failover and load balancing
  • Caching for frequent reads and response deduplication
  • API key authentication and per-key rate limits
  • Health checks and Prometheus-compatible metrics
  • Logging and configurable log level for diagnostics
  • Runs in Docker for easy deployment

Installation / Configuration

Clone the repository and run via Docker or docker-compose. A container image is provided on Docker Hub (image name used below is an example — check the GitHub repo for the official image tag).

  1. Clone the repo (optional if you use the image directly):
git clone https://github.com/noditlabs/nodit-mcp-server.git
cd nodit-mcp-server
  1. Example .env file (example keys — replace with real values):
NODE_ENV=production
PORT=8080
API_KEY_SECRET=your_api_key_secret_here
REDIS_URL=redis://redis:6379/0
LOG_LEVEL=info
CACHE_TTL_SECONDS=10
RATE_LIMIT_PER_MIN=120
  1. Example docker-compose.yml
version: "3.8"
services:
  mcp:
    image: noditlabs/nodit-mcp-server:latest
    ports:
      - "8080:8080"
    env_file:
      - .env
    depends_on:
      - redis
  redis:
    image: redis:7
    command: ["redis-server", "--appendonly", "no"]

Start:

docker-compose up -d
  1. Chain/provider configuration

Nodit MCP Server is typically configured by a JSON or YAML file that maps chain IDs to one or more provider URLs. Example snippet (format may vary — check repo docs):

{
  "chains": {
    "ethereum": {
      "chainId": 1,
      "providers": [
        "https://mainnet.infura.io/v3/INFURA_KEY",
        "https://eth-mainnet.alchemyapi.io/v2/ALCHEMY_KEY"
      ]
    },
    "polygon": {
      "chainId": 137,
      "providers": [
        "https://polygon-rpc.com",
        "https://rpc-mainnet.maticvigil.com"
      ]
    }
  }
}

Reload or restart the service after updating the chain configuration.

Available Resources

  • GitHub repo and source: https://github.com/noditlabs/nodit-mcp-server
  • REST endpoints (examples): /v1/blocks, /v1/txs, /v1/accounts/:address
  • RPC proxy endpoints: /rpc/:chain (HTTP POST for JSON-RPC), /ws/:chain (WebSocket proxy)
  • Health and metrics: /health, /metrics (Prometheus)
  • Logs: emitted to stdout/stderr; configurable LOG_LEVEL
  • Caching backend: Redis (optional) for request/result caching and rate-limiting state

Endpoint behavior and exact paths are documented in the repo README and API reference — consult the Github link above for up-to-date API details.

Use Cases

  • Wallet backend: Use Nodit MCP Server as the single RPC endpoint for a wallet application. Configure providers for each chain and let the server handle failover, caching, and rate-limiting so the wallet gets consistent block and balance data.

Example JSON-RPC request (HTTP):

curl -X POST https://mcp.example.com/rpc/ethereum \
  -H "Content-Type: application/json" \
  -H "x-api-key: YOUR_KEY" \
  -d '{"jsonrpc":"2.0","id":1,"method":"eth_blockNumber","params":[]}'
  • Trading bot or execution engine: Query confirmations, mempool data, and logs. The server reduces complexity by exposing both RPC and REST endpoints, with caching for hot reads (e.g., latest block).

Example REST request for latest block:

curl https://mcp.example.com/v1/blocks/latest -H "x-api-key: YOUR_KEY"

  • Analytics and dashboards: Ingest block/tx streams via REST pagination or WebSocket events. The metrics endpoint integrates with Prometheus for monitoring ingestion lag and provider health.

  • High-availability RPC façade: Route requests across multiple provider backends, automatically switching if a provider becomes slow or unhealthy. This avoids building provider orchestration in each consumer.

Tips for Developers

  • Use API keys for production traffic and configure per-key rate limits.
  • Enable Redis for caching and rate limit persistence; without Redis limits and cache are best-effort in-memory only.
  • Monitor /metrics in Prometheus to track provider latency, success rates, and cache effectiveness.
  • Keep provider credentials (Infura/Alchemy keys) out of source control; store them in environment variables or a secrets manager.

For full API details, configuration options, and advanced deployment examples, see the project repository: https://github.com/noditlabs/nodit-mcp-server.

Tags:finance