Datai MCP Server

Datai MCP lets your AI agent understand a wallet’s DeFi, token, and NFT holdings in seconds.

Whether you're building with Eliza OS, Cursor, or any local agent stack — simply plug in a wallet address, and the MCP server delivers clean, real-time context powered by the Datai API.

Perfect for AI agents, LLM plugins, and devs needing agentic access to wallet data.

Datai MCP is a TypeScript-based MCP server that enables seamless interaction with a wallet's portfolio data through AI-powered interfaces, powered by the same API behind Datai Network's analytics engine.

Features

• 8 Comprehensive DeFi Tools: Complete coverage of a wallet's DeFi positions and token balance analysis
• Multi-Chain Support: Ethereum, Arbitrum, Polygon, Avalanche, BSC, Base, Optimism, and more to come
• Multi-Protocol Support – Hundreds of DeFi protocols
• Fast Setup – Just plug in your wallet address, and the MCP delivers fresh on-chain data
• Built for AI Devs – Integrates with any MCP-ready agent framework (Eliza, Cursor, Claude)
• Real-Time Data – Powered by Datai’s API wallet data pipeline
• Debug-Friendly – Truncated responses for dev testing and memory-safe exploration
• Error Handling: Comprehensive error management and validation
• Performance Monitoring: Request timing and execution tracking

Example Use Case: Building an AI Wallet Copilot

You're creating an AI agent that helps users understand their crypto portfolio. With Datai MCP:

1. Your user connects their wallet.
2. Your agent uses get_all_defi_positions to fetch their DeFi strategy.
3. The agent summarizes key holdings, flags risk exposure, and recommends actions.

All without you needing to build a blockchain indexer.

Tools Available

Retrieve a wallet's portfolio data using the following tools:

Tool	Description	Parameters
get_all_defi_positions	Get all DeFi positions across all supported chains	wallet
get_defi_by_chain	Get DeFi positions for a specific blockchain	wallet, chain
get_defi_multi_chains	Get DeFi positions across multiple chains	wallet, chains[]
get_defi_by_protocol	Get DeFi positions for a specific protocol	wallet, protocol
get_defi_balances_by_chain	Get DeFi protocol balances by chain	wallet, chain
get_overall_balance_all_c	Get overall balance across all chains	wallet
get_overall_balance_by_chain	Get overall balance for a specific chain	wallet, chain
get_wallet_balances_by_chain	Get token balances for a specific chain	wallet, chain

Tip: Use get_all_defi_positions for a full portfolio scan, or chain/protocol-specific tools for targeted prompts.

Supported Chains

• eth - Ethereum
• arb - Arbitrum
• matic - Polygon
• avax - Avalanche
• bsc - Binance Smart Chain
• base - Base
• op - Optimism
• And more to come... access Datai's supported chains list

Supported Protocols

• Uniswap (V2, V3, V4)
• Aave (V2, V3)
• Compound
• Balancer
• SushiSwap
• Curve
• MakerDAO
• And many more... access Datai's supported protocols list

Integration with Cursor

To connect to the MCP server from Cursor:

1. Open Cursor and go to Settings (gear icon in the top right)
2. Click on "MCP" in the left sidebar
3. Click "Add new global MCP server"
4. Enter the following configuration:

Local Development Configuration

{
  "mcpServers": {
    "datai-fastmcp-server-local": {
      "command": "node",
      "args": ["/path/to/your/datai-mcp/dist/index.js"],
      "env": {
        "DATAI_API_KEY": "your_api_key_here",
        "DATAI_LIMIT": "1",
        "DATAI_DEBUG_TRUNCATE": "true",
        "DATAI_CONNECTION_TIMEOUT": "130000",
        "DATAI_RESPONSE_TIMEOUT": "90000",
        "PORT": "3099",
        "DEBUG": "true",
        "NODE_ENV": "production",
        "MCP_DISABLE_PINGS": "true"
      }
    }
  }
}

Production Configuration (NPX - Coming Soon)

{
  "mcpServers": {
    "datai-fastmcp-server": {
      "command": "npx",
      "args": ["-y", "datai-mcp-server@1.0.3"],
      "env": {
        "DATAI_API_KEY": "your_api_key_here",
        "DATAI_LIMIT": "1",
        "DATAI_DEBUG_TRUNCATE": "true",
        "DATAI_CONNECTION_TIMEOUT": "130000",
        "DATAI_RESPONSE_TIMEOUT": "90000",
        "PORT": "3099",
        "DEBUG": "true",
        "NODE_ENV": "production",
        "MCP_DISABLE_PINGS": "true"
      }
    }
  }
}

Environment Variables

Variable	Description	Default	Required
DATAI_API_KEY	Your Datai API key	-	✅ Yes
DATAI_LIMIT	API response limit (1-100)	10	No
DATAI_DEBUG_TRUNCATE	Enable data truncation for debugging	false	No
DATAI_CONNECTION_TIMEOUT	Connection timeout in ms	130000	No
DATAI_RESPONSE_TIMEOUT	Response timeout in ms	90000	No
DEBUG	Enable debug logging	false	No
PORT	Server port	3099	No

Debug Mode

When DATAI_DEBUG_TRUNCATE is set to "true", the server will intelligently truncate API responses to prevent memory issues during development and testing. This provides:

• Minimal Output: Reduces 1000+ line responses to ~15 lines
• Structure Preservation: Shows data types, array lengths, object keys
• Sample Data: First few items/values for verification
• Clear Status: Indicates when truncation is active

Example truncated output:

{
  "__debug_truncated": true,
  "__summary": {
    "type": "array",
    "length": 25,
    "item_types": ["object"],
    "first_item_keys": ["chain", "name", "commonName", "logo", "site"]
  },
  "__sample_data": {
    "chain": "eth",
    "name": "uniswap3",
    "commonName": "Uniswap V3"
  },
  "__message": "✅ Tool working - data truncated for debugging"
}

Integration with Claude Desktop

To connect to the MCP server from Claude Desktop:

1. Open Claude Desktop and go to Settings
2. Click on "Developer" in the left sidebar
3. Click the "Edit Config" Button
4. Add the configuration to the claude_desktop_config.json file
5. Save the file and restart Claude Desktop

Local Development

Prerequisites

• Node.js v18 or higher
• npm or yarn
• Datai API key - sign up here to obtain your API key, email address required

Quick Start

1. Clone the repository:

git clone https://github.com/Datai-Network/datai-fastmcp-server.git

cd datai-fastmcp-server

2. Install dependencies:

npm install

3. Build the project:

npm run build

4. Configure your MCP client with the local configuration shown above

5. Start using the tools in your MCP-compatible client!

Available Scripts

• npm run build: Build the TypeScript project
• npm run dev: Build and watch for changes
• npm run test: Run test suite (coming soon)

API Integration

This server integrates with the Datai API to provide real-time wallet portfolio data:

• Base URL: https://api-v1.mymerlin.io
• Authentication: API key-based
• Rate Limiting: Configurable via DATAI_LIMIT
• Timeout Handling: Configurable connection and response timeouts
• Error Handling: Comprehensive error transformation and logging

Sign up here to obtain your Datai API Key, email address required.

Security Considerations

• API Key Protection: Never commit API keys to version control
• Environment Variables: Use secure environment variable management
• Input Validation: All inputs are validated using Zod schemas
• Error Sanitization: Sensitive information is filtered from error messages
• Timeout Protection: Prevents hanging requests with configurable timeouts

Important Note on Response Size and Agent Compatibility

The Datai MCP is designed to enrich AI agents with real-time wallet portfolio data (token balances, DeFi positions). However, certain wallets can generate very large responses, especially when:

• Holding dozens or hundreds of tokens
• Engaging with multiple DeFi protocols
• Using many chains simultaneously

Potential Issues for AI Agents

As of this version, responses are not summarized. The full dataset is returned by default, unless truncated. This may lead to issues in agent environments, such as:

• Exceeding LLM context limits (resulting in cut-off or ignored data)
• Slower performance or longer reasoning time
• Memory or token quota overruns in hosted environments
• Confusing or degraded agent behavior due to input overload

Recommendations

Until summarization and modular querying are available, we recommend:

• Using lightweight wallets for testing and debugging
• Manually filtering or summarizing MCP responses before injecting into your agent
• Keeping response size in mind when designing prompts or managing memory
• Opening an issue or contacting us if you'd like early access to summary endpoints

We are actively improving the agent compatibility layer - including modular endpoints and data summarization options in upcoming releases.

Contributing

We welcome contributions! Please ensure:

1. All code follows TypeScript best practices
2. Comprehensive error handling is implemented
3. Input validation is present for all tools
4. Logging is FastMCP compliant
5. Tests are included for new features

License

This project is licensed under the MIT License - see the LICENSE file for details.

About Datai

Datai is building the agentic data layer for Web3. We provide high-quality, real-time data pipelines powering agents, AI copilots, and smart protocols. The Datai MCP is one step in our journey to make wallet data accessible, actionable, and agent-ready.

Explore more: https://datai.network

Feedback or Support?

We’re building this for the agent dev community and highly appreciate your input:

• Create an issue in the GitHub repository
• Check the documentation for common solutions
• Review the debug output when DATAI_DEBUG_TRUNCATE=true