Indigo MCP

MCP server for Indigo Protocol — exposes Indigo iAsset data, prices, and CDP/loan analytics to LLM agents via the Model Context Protocol.

⚡ Quick Start — Full Cardano DeFi Stack

MCP Servers (75 tools)

# 1. Install & Setup Indigo MCP (69 tools)
npm install -g @indigoprotocol/indigo-mcp
npx @indigoprotocol/indigo-mcp setup

# 2. Install & Setup Cardano MCP (6 wallet tools)
npm install -g @indigoprotocol/cardano-mcp
npx @indigoprotocol/cardano-mcp setup

AI Skills (13 skills) — Optional

# 3. Install Indigo Skills
npx @indigoprotocol/indigo-skills

# 4. Install Cardano Skills
npx @indigoprotocol/cardano-skills

╔═══════════════════════════════════════════════════════════════╗
║                                                               ║
║   ██╗███╗   ██╗██████╗ ██╗ ██████╗  ██████╗                   ║
║   ██║████╗  ██║██╔══██╗██║██╔════╝ ██╔═══██╗                  ║
║   ██║██╔██╗ ██║██║  ██║██║██║  ███╗██║   ██║                  ║
║   ██║██║╚██╗██║██║  ██║██║██║   ██║██║   ██║                  ║
║   ██║██║ ╚████║██████╔╝██║╚██████╔╝╚██████╔╝                  ║
║   ╚═╝╚═╝  ╚═══╝╚═════╝ ╚═╝ ╚═════╝  ╚═════╝                   ║
║                                                               ║
║   ███╗   ███╗ ██████╗██████╗                                  ║
║   ████╗ ████║██╔════╝██╔══██╗                                 ║
║   ██╔████╔██║██║     ██████╔╝                                 ║
║   ██║╚██╔╝██║██║     ██╔═══╝                                  ║
║   ██║ ╚═╝ ██║╚██████╗██║                                      ║
║   ╚═╝     ╚═╝ ╚═════╝╚═╝                                      ║
║                                                               ║
║   75 tools • 13 skills for Cardano DeFi                       ║
║                                                               ║
╚═══════════════════════════════════════════════════════════════╝

The setup commands auto-configure Claude Desktop, Claude Code, Cursor, or Windsurf. No manual config editing needed.

Features

• Real-time iAsset prices (iUSD, iBTC, iETH, iSOL, iEUR, iJPY)
• ADA and INDY token price feeds
• CDP/loan browsing with pagination and filtering
• Owner lookup by payment key hash or bech32 address
• CDP health analysis with collateral ratio and liquidation risk status
• Stability pool state and account queries
• INDY staking positions and manager state
• Protocol analytics: TVL, APR rewards, DEX yields, aggregated stats
• Governance: protocol parameters, polls, temperature checks
• Redemption order book and queue aggregation
• DEX proxy: Steelswap swaps, Iris liquidity pools, Blockfrost balances
• CDP liquidation, redemption, freeze, and merge operations
• Leveraged CDP opening via ROB positions
• ROB (Redemption Order Book) position management
• Oracle interest rate feeding and initialization
• Stability pool request processing and cancellation
• Staking reward distribution
• Collector UTXOs, IPFS storage and retrieval

Hosted deployment

A hosted deployment is available on Fronteir AI.

Quick Start

Automatic Setup (Recommended)

Run the interactive setup to automatically configure your MCP client:

npx @indigoprotocol/indigo-mcp setup

This will:

1. Ask which client you're using (Claude Desktop, Claude Code, Cursor, Windsurf)
2. Prompt for your Blockfrost API key
3. Automatically update your config file

Manual Installation

Install globally:

npm install -g @indigoprotocol/indigo-mcp

Or run directly with npx (no install needed):

npx @indigoprotocol/indigo-mcp

Docker

The image builds the server from source — no prior pnpm build needed, and no dependency on any external build step:

docker build -t indigo-mcp .
docker run -p 3000:3000 -e BLOCKFROST_API_KEY=your-key indigo-mcp

It runs the HTTP transport on port 3000 (MCP_TRANSPORT=http is baked in), which is what the Fly deployment uses.

HTTP Transport (Remote)

The server supports HTTP transport for remote/hosted deployments:

MCP_TRANSPORT=http PORT=3000 npx @indigoprotocol/indigo-mcp

This starts an HTTP server with:

• POST /mcp — MCP endpoint (Streamable HTTP with SSE)
• GET /health — Health check

Each client gets its own session: initialize returns an Mcp-Session-Id that subsequent requests must send back. A client that restarts can simply initialize again — existing sessions are unaffected and the server does not need restarting. Bind address and port come from HOST and PORT (MCP_PORT is accepted as an alias for PORT).

Configuration

Note: BLOCKFROST_API_KEY is required for write operations (transaction building). Read-only tools work without it. Get a free key at blockfrost.io.

Claude Desktop

Add to ~/Library/Application Support/Claude/claude_desktop_config.json (macOS) or %APPDATA%\Claude\claude_desktop_config.json (Windows):

# macOS
nano ~/Library/Application\ Support/Claude/claude_desktop_config.json

# Windows (PowerShell)
notepad "$env:APPDATA\Claude\claude_desktop_config.json"

Standard config:

{
  "mcpServers": {
    "indigo": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "INDEXER_URL": "https://analytics.indigoprotocol.io/api",
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id"
      }
    }
  }
}

For nvm users (multiple Node versions):

If you use nvm and have multiple Node versions, you may need to specify the full path and set PATH explicitly:

{
  "mcpServers": {
    "indigo": {
      "command": "/Users/YOUR_USERNAME/.nvm/versions/node/v22.22.0/bin/npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "PATH": "/Users/YOUR_USERNAME/.nvm/versions/node/v22.22.0/bin:/usr/local/bin:/usr/bin:/bin",
        "INDEXER_URL": "https://analytics.indigoprotocol.io/api",
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id"
      }
    }
  }
}

Note: Replace YOUR_USERNAME and Node version with your actual values. Find your Node path with which npx.

Claude Code (CLI)

Add to ~/.claude/settings.json or .claude/settings.json in your project:

nano ~/.claude/settings.json

{
  "mcpServers": {
    "indigo": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "INDEXER_URL": "https://analytics.indigoprotocol.io/api",
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id"
      }
    }
  }
}

Cursor

Add to ~/.cursor/mcp.json (global) or .cursor/mcp.json (project-level):

{
  "mcpServers": {
    "indigo": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "INDEXER_URL": "https://analytics.indigoprotocol.io/api",
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id"
      }
    }
  }
}

Windsurf

Add to ~/.codeium/windsurf/mcp_config.json:

{
  "mcpServers": {
    "indigo": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "INDEXER_URL": "https://analytics.indigoprotocol.io/api",
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id"
      }
    }
  }
}

OpenClaw

Install Indigo skills for OpenClaw:

openclaw skills add IndigoProtocol/indigo-skills

Skills are automatically configured — start using Indigo tools immediately.

Combined with Cardano MCP

For full Cardano DeFi capabilities, use both Indigo MCP and Cardano MCP together:

{
  "mcpServers": {
    "indigo": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id"
      }
    },
    "cardano": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/cardano-mcp"],
      "env": {
        "SEED_PHRASE": "word1,word2,word3,...",
        "BLOCKFROST_PROJECT_ID": "your-blockfrost-project-id"
      }
    }
  }
}

Any MCP-Compatible Client

Run the server directly via stdio:

INDEXER_URL=https://analytics.indigoprotocol.io/api \
BLOCKFROST_API_KEY=your-blockfrost-project-id \
npx @indigoprotocol/indigo-mcp

Or install globally and reference the binary:

npm install -g @indigoprotocol/indigo-mcp
indigo-mcp

For any client that supports MCP over stdio, point it to the npx @indigoprotocol/indigo-mcp command with the environment variables above.

Available Tools

Asset Tools

CDP / Loan Tools

CDP Write Tools

Pyth-priced iAssets have a submission deadline. Every iAsset is currently priced through Pyth, and the on-chain feed validator only accepts a transaction for 280 seconds after the price update it embeds. Price-dependent write tools (open_cdp, withdraw_cdp, mint_cdp, redeem_cdp, freeze_cdp, leverage_cdp, redeem_rob) therefore return a summary.pyth block with the price, its timestamp and a submitBefore deadline. If signing takes longer than that — a hardware wallet, or a human approving in a browser — rebuild the transaction rather than submitting a stale one. A price update that has already expired is rejected at build time with a retry hint.

CDP Mint/Burn Tools

CDP Liquidation & Redemption Tools

Leverage CDP Tools

Stability Pool Tools

Staking Tools

Stability Pool Request Tools

Staking Write Tools

Staking Reward Tools

Analytics & APR Tools

Governance Tools

Redemption & Order Book Tools

ROB Write Tools

DEX Proxy Tools

Collector & IPFS Tools

Interest Tools (v3)

Oracle / Pyth Tools (v3)

Stableswap Tools (v3)

Environment Variables

Example Queries

When connected to an LLM agent, you can ask natural language questions like:

• "What are the current prices of all Indigo iAssets?"
• "What is the price of iUSD right now?"
• "How much is ADA worth in USD?"
• "Show me all iETH CDPs"
• "What CDPs does this address own?" (paste a Cardano address)
• "Analyze the health of my CDPs" (with your address or payment key hash)
• "Are any of my positions at risk of liquidation?"
• "Show me the current stability pool state"
• "What are my stability pool deposits?" (with your address)
• "How much INDY am I staking?" (with your address)
• "What's the current TVL of Indigo?"
• "What APR can I earn on iUSD stability pool?"
• "What are the current governance protocol parameters?"
• "Show me the iUSD redemption queue"
• "Get a Steelswap estimate for swapping 100 ADA to iUSD"
• "What are the current DEX yields for iAsset pairs?"

Distribution

The server is published to three places, and they are not the same artifact.

The container image (Dockerfile) builds from source and is used by Fly and any other container host. It does not consume .smithery/ output — that path is Smithery-specific.

Cutting a release

1. Merge the version bump (package.json; SERVER_VERSION is read from it)
2. git tag vX.Y.Z && git push origin vX.Y.Z
3. CI publishes to npm, then to the MCP Registry (the registry verifies ownership via the package's mcpName field, so npm has to go first)
4. Verify against the registry, not the workflow: npm view @indigoprotocol/indigo-mcp version
5. fly deploy for the hosted HTTP endpoint, and pnpm smithery:publish for Smithery

Development

Prerequisites

• Node.js >= 20 (the bundled undici requires the File global, added in Node 20)
• npm

Setup

git clone https://github.com/IndigoProtocol/indigo-mcp.git
cd indigo-mcp
npm install
npm run dev      # run with tsx (hot reload)

Scripts

npm run build          # compile TypeScript
npm run start          # run compiled server
npm run dev            # run with tsx (hot reload)
npm run typecheck      # type-check without emitting
npm run lint           # eslint
npm run lint:fix       # eslint --fix
npm run format         # prettier
npm run format:check   # prettier --check
npm run test           # run tests
npm run test:watch     # run tests in watch mode

Project Structure

src/
├── index.ts                       # Server entry point (stdio transport)
├── payment.ts                     # x402 configuration: chain addresses + tool price tiers
├── payment-client.ts              # withAutoPayment: client-side auto-pay on 402 responses
├── types/
│   └── tx-types.ts                # UnsignedTxResult, TxSummary types
├── tools/
│   ├── index.ts                   # Tool registration hub
│   ├── asset-tools.ts             # 5 asset/price tools
│   ├── cdp-tools.ts               # 4 CDP/loan tools
│   ├── stability-pool-tools.ts    # 3 stability pool tools
│   ├── staking-tools.ts           # 4 INDY staking tools
│   ├── staking-write-tools.ts     # 3 INDY staking write tools
│   ├── staking-reward-tools.ts    # 1 staking reward distribution tool
│   ├── cdp-liquidation-tools.ts   # 4 CDP liquidation/redemption/freeze/merge tools
│   ├── leverage-cdp-tools.ts      # 1 leveraged CDP tool
│   ├── rob-write-tools.ts         # 5 ROB write tools

│   ├── sp-request-tools.ts        # 2 SP request processing tools
│   ├── analytics-tools.ts         # 5 analytics/APR tools
│   ├── governance-tools.ts        # 3 governance tools
│   ├── redemption-tools.ts        # 3 redemption/order book tools
│   ├── dex-tools.ts               # 4 DEX proxy tools
│   └── collector-tools.ts         # 3 collector/IPFS tools
├── resources/
│   └── index.ts                   # MCP resource definitions
├── tests/
│   ├── unit/
│   │   ├── tools/                 # Unit tests for each tool module
│   │   └── utils/                 # Unit tests for validators, address
│   └── integration/
│       └── indexer-client.test.ts # Integration test for HTTP client
└── utils/
    ├── index.ts                   # Re-exports
    ├── indexer-client.ts          # Axios client for Indigo analytics API
    ├── validators.ts              # Zod validators (AssetParam enum)
    ├── address.ts                 # Bech32 address → payment credential
    ├── lucid-provider.ts          # Lucid + Blockfrost singleton provider
    ├── sdk-config.ts              # SystemParams loader with cache
    └── tx-builder.ts              # Transaction builder → unsigned CBOR

Testing via stdin

The server communicates over stdio using JSON-RPC. You can test tools directly:

npm run build
echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"0.1.0"}}}' | node dist/index.js

x402 Payment Gating

Indigo MCP optionally gates tools behind per-call micropayments using the x402 protocol. Payment is disabled by default — set at least one wallet address to enable it.

How it works

Payment uses the split execution model — the same architecture as openMM-MCP:

1. A tool is called (no payment header needed from the caller)
2. The gate intercepts and contacts the settlement worker (mcp.openmm.io by default)
3. Worker responds 402 with EIP-3009 requirements (amount, recipient, chain)
4. Gate signs locally using X402_PRIVATE_KEY — the key never leaves this process
5. Gate retries with the signed payment → worker verifies on-chain, issues a JWT
6. Gate verifies JWT locally, executes the original tool handler
7. Settlement tx hash is injected into the tool response

This keeps process isolation clean: indigo-mcp never holds the recipient wallet — only the payer key. Verification and settlement are handled by the openmm.io proxy.

• Read tools (get_tvl, get_asset_price, …) cost $0.001 USDC per call
• Analysis tools (analyze_cdp_health) cost $0.005 USDC per call
• Write tools (open_cdp, mint_cdp, …) cost $0.01 USDC per call

Environment variables

Split execution flow

When X402_PRIVATE_KEY is set, every paid tool call is handled transparently:

1. Gate contacts PAYMENT_SERVER (https://mcp.openmm.io by default)
2. Signs EIP-3009 locally — the private key never leaves this process
3. Proxy verifies on-chain, issues a short-lived JWT
4. Gate verifies JWT, executes tool, injects settlement tx hash into response

If X402_PRIVATE_KEY is not set the gate is disabled and all tools execute without payment.

# Minimal: just set the payer key (proxy defaults to mcp.openmm.io)
X402_PRIVATE_KEY=0xYourPayerPrivateKey npx @indigoprotocol/indigo-mcp

# Self-hosted proxy
X402_PRIVATE_KEY=0xYourPayerPrivateKey \
PAYMENT_SERVER=https://your-own-proxy \
npx @indigoprotocol/indigo-mcp

Local development

# 1. Copy example env
cp .env.example .env
# Edit .env and set X402_PRIVATE_KEY to a funded Base Sepolia wallet

# 2. Start the HTTP server
MCP_TRANSPORT=http PORT=3000 npm run dev

# 3. Run the payment e2e tests
X402_TESTNET=true npm test -- x402-payment

MCP client config with x402

Add the env block to whichever MCP config file your client uses:

Claude Code (~/.claude/settings.json):

{
  "mcpServers": {
    "indigo": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "INDEXER_URL": "https://analytics.indigoprotocol.io/api",
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id",
        "X402_PRIVATE_KEY": "0xYourPayerPrivateKey",
        "X402_TESTNET": "true"
      }
    }
  }
}

Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json):

{
  "mcpServers": {
    "indigo": {
      "command": "npx",
      "args": ["-y", "@indigoprotocol/indigo-mcp"],
      "env": {
        "INDEXER_URL": "https://analytics.indigoprotocol.io/api",
        "BLOCKFROST_API_KEY": "your-blockfrost-project-id",
        "X402_PRIVATE_KEY": "0xYourPayerPrivateKey",
        "X402_TESTNET": "true"
      }
    }
  }
}

Cursor / Windsurf — same env block applies to ~/.cursor/mcp.json or ~/.codeium/windsurf/mcp_config.json.

Set X402_TESTNET to false (or omit it) for Base mainnet.

License

ISC