UN
Finance

Uniswap New Liquidity Pools MCP Server

Track newly created Uniswap liquidity pools across nine blockchains with this MCP server to spot opportunities and receive instant alerts.

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

Overview

This MCP server monitors newly created Uniswap-style liquidity pools across multiple EVM-compatible blockchains and exposes those events in a machine-friendly way for LLMs and external systems. It listens for factory contract events (new pair/pool creation), enriches each event with chain and token metadata, and publishes alerts in real time via webhooks and the Model Context Protocol (MCP) tool interface.

Tracking newly created pools is useful for traders, market makers, data analysts and automated agents that want to spot listing opportunities, front-run liquidity additions, monitor tokens for compliance, or feed streaming dashboards. By packaging the monitor as an MCP-compatible server, the tool can be discovered and invoked by LLMs and agent frameworks to fetch recent pools, query pool details, or subscribe to alerts.

Features

  • Real-time detection of newly created Uniswap-style pools across multiple EVM chains
  • Support for configurable RPC providers per chain
  • MCP manifest and tool endpoints so LLMs can discover and invoke the server
  • Webhook delivery for instant notifications to your services (Discord, Slack, trading bot)
  • Optional persistence (database) and start-from-block configuration to avoid reprocessing
  • Simple configuration via environment variables or Docker

Installation / Configuration

Requirements: Node.js (16+), Docker (optional), RPC provider endpoints (Alchemy/Infura/Other)

  1. Clone and install
git clone https://github.com/kukapay/uniswap-poolspy-mcp.git
cd uniswap-poolspy-mcp
npm install
  1. Configuration via environment variables

Create a .env file. The example below shows the common variables used by the server. Adjust chain RPC URLs, webhook endpoint, and database settings as needed.

# Server
PORT=8080

# Chains (example names; server accepts EVM-compatible chain keys)
CHAINS=ethereum,polygon,arbitrum,optimism,binance

# Per-chain RPC endpoints (pattern: RPC_URL_<CHAIN_UPPER>)
RPC_URL_ETHEREUM=wss://eth-mainnet.alchemyapi.io/v2/your-key
RPC_URL_POLYGON=wss://polygon-mainnet.g.alchemy.com/v2/your-key
RPC_URL_ARBITRUM=wss://arb-mainnet.infura.io/ws/v3/your-key

# Optional: start block per chain to limit historical scanning
START_BLOCK_ETHEREUM=17000000

# Webhook for alerts (POST JSON payload)
ALERT_WEBHOOK=https://hooks.example.com/new-pool

# Optional database (for dedupe / persistence)
DATABASE_URL=postgres://user:pass@db:5432/pools
  1. Run locally
npm run build
node dist/index.js
# or for development
npm run dev
  1. Docker

Build and run with environment variables:

docker build -t uniswap-poolspy-mcp .
docker run -e PORT=8080 \
  -e CHAINS=ethereum,polygon \
  -e RPC_URL_ETHEREUM=wss://... \
  -e RPC_URL_POLYGON=wss://... \
  -e ALERT_WEBHOOK=https://hooks.example.com/new-pool \
  uniswap-poolspy-mcp:latest

Available Resources

  • GitHub repository: https://github.com/kukapay/uniswap-poolspy-mcp
  • MCP manifest endpoint (discoverable by agents): GET /mcp/manifest
  • Health and metrics:
    • GET /health — basic liveness check
    • GET /metrics — Prometheus-style metrics (if enabled)
  • Example webhook payload (POST JSON to your ALERT_WEBHOOK):
{
  "chain": "ethereum",
  "blockNumber": 17012000,
  "timestamp": 1680000000,
  "factory": "0x5C69bEe701ef814a2B6a3EDD4B1652CB9cc5aA6f",
  "pool": "0xAbCd...1234",
  "token0": {
    "address": "0xTokenA...",
    "symbol": "TKA",
    "decimals": 18
  },
  "token1": {
    "address": "0xTokenB...",
    "symbol": "TKB",
    "decimals": 18
  },
  "txHash": "0x9876...abcd"
}

Use Cases

  • Spot new listings for trading strategies
    • A trading bot subscribes to the webhook and executes a pre-flight check when a new pool appears on Arbitrum for a monitored token address. The bot queries the pool contract for initial liquidity and slippage before placing a trade.
  • LLM-driven research and alerts
    • An LLM agent discovers the MCP manifest, invokes the tool to fetch the most recent pools across Polygon, and summarizes which tokens have non-zero initial liquidity and verified token metadata.
  • Compliance and monitoring
    • A compliance pipeline ingests new-pool events to check token addresses against sanctions lists and risk databases, flagging suspicious newly created pools for manual review.
  • Arbitrage and market making
    • Market-making systems use the stream to identify newly created pools that could offer exploitable price differences across chains or DEXes, triggering liquidity provisioning strategies.

Notes and Best Practices

  • Use websocket (WSS) RPC endpoints where possible to reduce latency for real-time notifications.
  • Configure start block per chain when connecting for the first time to avoid scanning entire chain history.
  • Implement idempotency on your webhook consumer since network retries can deliver duplicate events.
  • If integrating with LLMs, fetch the MCP manifest (GET /mcp/manifest) so agents can understand available tools and parameters before invoking them.

For code-level details and advanced configuration, consult the repository source and the included examples in the examples/ directory.

Tags:finance