Datai MCP Server

Datai Network

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:

Your user connects their wallet.
Your agent uses get_all_defi_positions to fetch their DeFi strategy.
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:

Open Cursor and go to Settings (gear icon in the top right)
Click on "MCP" in the left sidebar
Click "Add new global MCP server"
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:

Open Claude Desktop and go to Settings
Click on "Developer" in the left sidebar
Click the "Edit Config" Button
Add the configuration to the claude_desktop_config.json file
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

Clone the repository:

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

cd datai-fastmcp-server

Install dependencies:

npm install

Build the project:

npm run build

Configure your MCP client with the local configuration shown above
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

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:

All code follows TypeScript best practices
Comprehensive error handling is implemented
Input validation is present for all tools
Logging is FastMCP compliant
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