KU
Finance

Kukapay MCP Server for Crypto Data Aggregation

Explore Kukapay's MCP server for comprehensive crypto, blockchain, and Web3 data aggregation, analysis, and services.

View on GitHub
Quick Install
npx -y @kukapay/kukapay-mcp-servers

Overview

Kukapay MCP Server is an open-source Model Context Protocol (MCP) server designed to centralize crypto, blockchain, and Web3 data for use by applications, analytics pipelines, and language models. It gathers and normalizes information from exchanges, on-chain nodes, indexers, and third‑party APIs, then exposes that data through a consistent API surface so downstream services and LLM-driven agents can query the same canonical context.

By implementing an MCP pattern, the server acts as a bridge between raw data sources and higher-level reasoning or automation tools. This makes it useful for building portfolio trackers, compliance tooling, trading signals, or LLM tools that need up-to-date blockchain context without coupling to multiple provider SDKs. The project is maintained on GitHub at https://github.com/kukapay/kukapay-mcp-servers.

Features

  • Aggregation of price feeds, on-chain events, and wallet balances from multiple sources
  • Normalized data models for transactions, addresses, assets, and chains
  • Plugin/adapter architecture to add new indexers, exchanges or RPC nodes
  • HTTP API (REST) and optional WebSocket/gRPC endpoints for real-time updates
  • Configuration via environment variables and config files for deployment flexibility
  • Built-in caching and rate‑limit handling for upstream providers
  • Metrics and observability hooks (Prometheus endpoints, logs)
  • Authentication and role-based access controls for multi-tenant deployments

Installation / Configuration

Clone the repository and run with Docker (recommended for development and production parity):

git clone https://github.com/kukapay/kukapay-mcp-servers.git
cd kukapay-mcp-servers
# Build the Docker image (if provided)
docker build -t kukapay-mcp-server .
# Run with example env file
docker run --env-file .env -p 8080:8080 kukapay-mcp-server

Example .env (edit before starting):

# .env
NODE_ENV=production
PORT=8080

# Upstream providers
ETHEREUM_RPC=https://mainnet.infura.io/v3/YOUR_KEY
ALTERNATE_RPC=https://rpc.example.com

# API & auth
API_KEY=changeme
[email protected]

# Cache and observability
CACHE_TTL_SECONDS=60
PROMETHEUS_ENABLED=true

If the project includes a Node/npm stack, the typical local development commands look like:

# install deps
npm install

# run in development mode with hot reload
npm run dev

# run tests
npm test

Configuration file example (yaml/json) for adapters and rate limits:

adapters:
  ethereum:
    rpc: ${ETHEREUM_RPC}
    confirmations: 12
  coinapi:
    key: ${COINAPI_KEY}
rateLimits:
  default: 1000 # calls per minute
  perProvider:
    coinapi: 60

Available Tools / Resources

The MCP server exposes a set of data-oriented tools and endpoints that can be used by applications and model agents. Typical resources include:

  • /health — service health and readiness checks
  • /metrics — Prometheus metrics
  • /api/v1/prices — latest spot prices and aggregated feeds
  • /api/v1/historical — time-series price and volume data
  • /api/v1/address/{address} — normalized wallet balance and token holdings
  • /api/v1/tx/{txhash} — decoded transaction details and enriched metadata
  • /api/v1/tools — discoverable list of tools and their input/output schemas

Example curl (fetch price):

curl -H "Authorization: Bearer $API_KEY" \
  "http://localhost:8080/api/v1/prices?symbol=ETH&vs=USD"

Note: exact endpoint paths may vary — consult the repository’s OpenAPI/README for the canonical API surface.

Use Cases

  • Portfolio aggregator: Periodically query /api/v1/address/{address} to assemble multi-chain balances, convert token amounts to USD with /api/v1/prices, and present unified portfolio valuations across custodial and non-custodial holdings.

  • Compliance & AML monitoring: Stream new transactions via WebSocket or poll /api/v1/tx/{txhash} to detect high-risk patterns. Combine on-chain enrichment with third-party sanctions/risk lists to flag suspicious activity.

  • DeFi analytics: Use /api/v1/historical to pull price time-series and on-chain event logs to compute TVL (Total Value Locked), impermanent loss estimates, or protocol revenue metrics.

  • LLM tool/context provider: Attach the MCP server as a context provider for an LLM — allow the model to call tool endpoints like “get_balance” or “get_tx” to retrieve structured blockchain facts the model can reason over, improving accuracy of answers involving real-time crypto state.

  • Trading signals & alerting: Aggregate multiple price feeds and on-chain indicators (large transfers, exchange inflows) and feed them into alerting rules or a signals engine.

Deployment & Best Practices

  • Secure API keys and RPC credentials via a secret manager or environment variables; avoid committing keys to source control.
  • Use provider-specific rate limits and exponential backoff to avoid throttling; enable local caching where possible.
  • Monitor metrics and set up alerting for upstream failures (e.g., RPC node outages).
  • When exposing the service to LLMs, enforce strict input/output schemas and RBAC to prevent data leakage.

For full implementation details, configuration options, and adapter documentation, refer to the project repository at: https://github.com/kukapay/kukapay-mcp-servers.

Tags:finance