EVM MCP Server
The EVM MCP Server enables seamless interaction with 30+ EVM-compatible blockchains (including Ethereum, Polygon, Arbitrum, Optimism), providing comprehensive blockchain services for AI agents through a unified interface.
Key capabilities:
Blockchain Data Access: Read blockchain state, query chain information, retrieve transaction details, resolve ENS names to addresses
Token Management: Handle ERC20 tokens (metadata, balances, transfers, approvals), interact with NFTs (ERC721) and multi-tokens (ERC1155), check ownership and balances
Smart Contract Interactions: Read contract state via view/pure functions, write to contracts with transaction signing, verify if an address is a contract
Transaction Support: Transfer native tokens (ETH, MATIC), estimate gas costs, sign and send transactions securely
Utility Functions: Derive Ethereum addresses from private keys, access blockchain data via MCP Resource URIs
Supports running the MCP server with Bun runtime, enabling faster execution and modern JavaScript features.
Provides comprehensive blockchain services including reading state, transferring tokens, querying balances, and interacting with smart contracts on the Ethereum mainnet.
Supports interaction with the Fantom blockchain, including native token transfers, balance checking, and smart contract operations.
Compatible with Node.js 18.0.0+ as an alternative runtime environment for the MCP server.
Enables interaction with the Optimism L2 network, including reading blockchain state, transferring tokens, and smart contract interactions.
Provides services for the Polygon network and Polygon zkEVM, supporting token transfers, smart contract interaction, and blockchain data access.
Built with TypeScript 5.0+, providing type safety and modern language features for development and extension of the server capabilities.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@EVM MCP Server check vitalik.eth's ETH balance on mainnet"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
EVM MCP Server
A comprehensive Model Context Protocol (MCP) server that provides blockchain services across 60+ EVM-compatible networks. This server enables AI agents to interact with Ethereum, Optimism, Arbitrum, Base, Polygon, and many other EVM chains with a unified interface through 22 tools and 10 AI-guided prompts.
📋 Contents
Related MCP server: EVM MCP Server
🔭 Overview
The MCP EVM Server leverages the Model Context Protocol to provide blockchain services to AI agents. It supports a wide range of services including:
Reading blockchain state (balances, transactions, blocks, etc.)
Interacting with smart contracts with automatic ABI fetching from block explorers
Transferring tokens (native, ERC20, ERC721, ERC1155)
Querying token metadata and balances
Chain-specific services across 60+ EVM networks (34 mainnets + 26 testnets)
ENS name resolution for all address parameters (use human-readable names like 'vitalik.eth' instead of addresses)
AI-friendly prompts that guide agents through complex workflows
All services are exposed through a consistent interface of MCP tools, resources, and prompts, making it easy for AI agents to discover and use blockchain functionality. Every tool that accepts Ethereum addresses also supports ENS names, automatically resolving them to addresses behind the scenes. The server includes intelligent ABI fetching, eliminating the need to know contract ABIs in advance.
✨ Features
Blockchain Data Access
Multi-chain support for 60+ EVM-compatible networks (34 mainnets + 26 testnets)
Chain information including blockNumber, chainId, and RPCs
Block data access by number, hash, or latest
Transaction details and receipts with decoded logs
Address balances for native tokens and all token standards
ENS resolution for human-readable Ethereum addresses (use 'vitalik.eth' instead of '0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045')
Token services
ERC20 Tokens
Get token metadata (name, symbol, decimals, supply)
Check token balances
Transfer tokens between addresses
Approve spending allowances
NFTs (ERC721)
Get collection and token metadata
Verify token ownership
Transfer NFTs between addresses
Retrieve token URIs and count holdings
Multi-tokens (ERC1155)
Get token balances and metadata
Transfer tokens with quantity
Access token URIs
Smart Contract Interactions
Read contract state through view/pure functions
Write to contracts - Execute any state-changing function with automatic ABI fetching
Contract verification to distinguish from EOAs
Event logs retrieval and filtering
Automatic ABI fetching from Etherscan v2 API across all 60+ networks (no need to know ABIs in advance)
ABI parsing and validation with function discovery
Comprehensive Transaction Support
Flexible Wallet Support - Configure with Private Key or Mnemonic (BIP-39) with HD path support
Native token transfers across all supported networks
Gas estimation for transaction planning
Transaction status and receipt information
Error handling with descriptive messages
Message Signing Capabilities
Personal Message Signing - Sign arbitrary messages for authentication and verification
EIP-712 Typed Data Signing - Sign structured data for gasless transactions and meta-transactions
SIWE Support - Enable Sign-In With Ethereum authentication flows
Permit Signatures - Create off-chain approvals for gasless token operations
Meta-Transaction Support - Sign transaction data for relay services and gasless transfers
AI-Guided Workflows (Prompts)
Transaction preparation - Guidance for planning and executing transfers
Wallet analysis - Tools for analyzing wallet activity and holdings
Smart contract exploration - Interactive ABI fetching and contract analysis
Contract interaction - Safe execution of write operations on smart contracts
Network information - Learning about EVM networks and comparisons
Approval auditing - Reviewing and managing token approvals
Error diagnosis - Troubleshooting transaction failures
🌐 Supported Networks
Mainnets
Ethereum (ETH)
Optimism (OP)
Arbitrum (ARB)
Arbitrum Nova
Base
Polygon (MATIC)
Polygon zkEVM
Avalanche (AVAX)
Binance Smart Chain (BSC)
zkSync Era
Linea
Celo
Gnosis (xDai)
Fantom (FTM)
Filecoin (FIL)
Moonbeam
Moonriver
Cronos
Scroll
Mantle
Manta
Blast
Fraxtal
Mode
Metis
Kroma
Zora
Aurora
Canto
Flow
Lumia
Testnets
Sepolia
Optimism Sepolia
Arbitrum Sepolia
Base Sepolia
Polygon Amoy
Avalanche Fuji
BSC Testnet
zkSync Sepolia
Linea Sepolia
Scroll Sepolia
Mantle Sepolia
Manta Sepolia
Blast Sepolia
Fraxtal Testnet
Mode Testnet
Metis Sepolia
Kroma Sepolia
Zora Sepolia
Celo Alfajores
Goerli
Holesky
Flow Testnet
Filecoin Calibration
Lumia Testnet
🛠️ Prerequisites
Bun 1.0.0 or higher (recommended)
Node.js 20.0.0 or higher (if not using Bun)
Optional: Etherscan API key for ABI fetching
📦 Installation
# Clone the repository
git clone https://github.com/mcpdotdirect/evm-mcp-server.git
cd evm-mcp-server
# Install dependencies with Bun
bun install
# Or with npm
npm install⚙️ Configuration
Environment Variables
The server uses the following environment variables. For write operations and ABI fetching, you must configure these variables:
Wallet Configuration (For Write Operations)
You can configure your wallet using either a private key or a mnemonic phrase:
Option 1: Private Key
export EVM_PRIVATE_KEY="0x..." # Your private key in hex format (with or without 0x prefix)Option 2: Mnemonic Phrase (Recommended for HD Wallets)
export EVM_MNEMONIC="word1 word2 word3 ... word12" # Your 12 or 24 word BIP-39 mnemonic
export EVM_ACCOUNT_INDEX="0" # Optional: Account index for HD wallet derivation (default: 0)The mnemonic option supports hierarchical deterministic (HD) wallet derivation:
Uses BIP-39 standard mnemonic phrases (12 or 24 words)
Supports BIP-44 derivation path:
m/44'/60'/0'/0/{accountIndex}EVM_ACCOUNT_INDEXallows you to derive different accounts from the same mnemonicDefault account index is 0 (first account)
Wallet is used for:
Transferring native tokens (
transfer_nativetool)Transferring ERC20 tokens (
transfer_erc20tool)Approving token spending (
approve_token_spendingtool)Writing to smart contracts (
write_contracttool)Signing messages for authentication (
sign_messagetool)Signing structured data for gasless transactions (
sign_typed_datatool)
⚠️ Security:
Never commit your private key or mnemonic to version control
Use environment variables or a secure key management system
Store mnemonics securely - they provide access to all derived accounts
Consider using different account indices for different purposes
API Keys (For ABI Fetching)
export ETHERSCAN_API_KEY="your-api-key-here"This API key is optional but required for:
Automatic ABI fetching from block explorers (
get_contract_abitool)Auto-fetching ABIs when reading contracts (
read_contracttool withabiJsonparameter)The
fetch_and_analyze_abiprompt
Get your free API key from:
Etherscan - For Ethereum and compatible chains
The same key works across all 60+ EVM networks via the Etherscan v2 API
Server Configuration
The server uses the following default configuration:
Default Chain ID: 1 (Ethereum Mainnet)
Server Port: 3001
Server Host: 0.0.0.0 (accessible from any network interface)
These values are hardcoded in the application. If you need to modify them, you can edit the following files:
For chain configuration:
src/core/chains.tsFor server configuration:
src/server/http-server.ts
🚀 Usage
Using npx (No Installation Required)
You can run the MCP EVM Server directly without installation using npx:
# Run the server in stdio mode (for CLI tools)
npx @mcpdotdirect/evm-mcp-server
# Run the server in HTTP mode (for web applications)
npx @mcpdotdirect/evm-mcp-server --httpRunning the Server Locally
Start the server using stdio (for embedding in CLI tools):
# Start the stdio server
bun start
# Development mode with auto-reload
bun devOr start the HTTP server with SSE for web applications:
# Start the HTTP server
bun start:http
# Development mode with auto-reload
bun dev:httpConnecting to the Server
Connect to this MCP server using any MCP-compatible client. For testing and debugging, you can use the MCP Inspector.
Connecting from Cursor
To connect to the MCP server from Cursor:
Open Cursor and go to Settings (gear icon in the bottom left)
Click on "Features" in the left sidebar
Scroll down to "MCP Servers" section
Click "Add new MCP server"
Enter the following details:
Server name:
evm-mcp-serverType:
commandCommand:
npx @mcpdotdirect/evm-mcp-server
Click "Save"
Once connected, you can use the MCP server's capabilities directly within Cursor. The server will appear in the MCP Servers list and can be enabled/disabled as needed.
Using mcp.json with Cursor
For a more portable configuration that you can share with your team or use across projects, you can create an .cursor/mcp.json file in your project's root directory:
{
"mcpServers": {
"evm-mcp-server": {
"command": "npx",
"args": ["-y", "@mcpdotdirect/evm-mcp-server"]
},
"evm-mcp-http": {
"command": "npx",
"args": ["-y", "@mcpdotdirect/evm-mcp-server", "--http"]
}
}
}Place this file in your project's .cursor directory (create it if it doesn't exist), and Cursor will automatically detect and use these MCP server configurations when working in that project. This approach makes it easy to:
Share MCP configurations with your team
Version control your MCP setup
Use different server configurations for different projects
Example: HTTP Mode with SSE
If you're developing a web application and want to connect to the HTTP server with Server-Sent Events (SSE), you can use this configuration:
{
"mcpServers": {
"evm-mcp-sse": {
"url": "http://localhost:3001/sse"
}
}
}This connects directly to the HTTP server's SSE endpoint, which is useful for:
Web applications that need to connect to the MCP server from the browser
Environments where running local commands isn't ideal
Sharing a single MCP server instance among multiple users or applications
To use this configuration:
Create a
.cursordirectory in your project root if it doesn't existSave the above JSON as
mcp.jsonin the.cursordirectoryRestart Cursor or open your project
Cursor will detect the configuration and offer to enable the server(s)
Example: Using the MCP Server in Cursor
After configuring the MCP server with mcp.json, you can easily use it in Cursor. Here's an example workflow:
Create a new JavaScript/TypeScript file in your project:
// blockchain-example.js
async function main() {
try {
// Get ETH balance for an address using ENS
console.log("Getting ETH balance for vitalik.eth...");
// When using with Cursor, you can simply ask Cursor to:
// "Check the ETH balance of vitalik.eth on mainnet"
// Or "Transfer 0.1 ETH from my wallet to vitalik.eth"
// Cursor will use the MCP server to execute these operations
// without requiring any additional code from you
// This is the power of the MCP integration - your AI assistant
// can directly interact with blockchain data and operations
} catch (error) {
console.error("Error:", error.message);
}
}
main();With the file open in Cursor, you can ask Cursor to:
"Check the current ETH balance of vitalik.eth"
"Look up the price of USDC on Ethereum"
"Show me the latest block on Optimism"
"Check if 0x1234... is a contract address"
Cursor will use the MCP server to execute these operations and return the results directly in your conversation.
The MCP server handles all the blockchain communication while allowing Cursor to understand and execute blockchain-related tasks through natural language.
Connecting using Claude CLI
If you're using Claude CLI, you can connect to the MCP server with just two commands:
# Add the MCP server
claude mcp add evm-mcp-server npx @mcpdotdirect/evm-mcp-server
# Start Claude with the MCP server enabled
claudeExample: Getting a Token Balance with ENS
// Example of using the MCP client to check a token balance using ENS
const mcp = new McpClient("http://localhost:3000");
const result = await mcp.invokeTool("get-token-balance", {
tokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC on Ethereum
ownerAddress: "vitalik.eth", // ENS name instead of address
network: "ethereum",
});
console.log(result);
// {
// tokenAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48",
// owner: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
// network: "ethereum",
// raw: "1000000000",
// formatted: "1000",
// symbol: "USDC",
// decimals: 6
// }Example: Resolving an ENS Name
// Example of using the MCP client to resolve an ENS name to an address
const mcp = new McpClient("http://localhost:3000");
const result = await mcp.invokeTool("resolve-ens", {
ensName: "vitalik.eth",
network: "ethereum",
});
console.log(result);
// {
// ensName: "vitalik.eth",
// normalizedName: "vitalik.eth",
// resolvedAddress: "0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045",
// network: "ethereum"
// }Example: Batch Multiple Calls with Multicall
// Example of using multicall to batch multiple contract reads in a single RPC call
const mcp = new McpClient("http://localhost:3000");
const result = await mcp.invokeTool("multicall", {
network: "ethereum",
calls: [
{
contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
functionName: "balanceOf",
args: ["0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045"],
},
{
contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
functionName: "symbol",
},
{
contractAddress: "0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48", // USDC
functionName: "decimals",
},
],
});
console.log(result);
// {
// network: "ethereum",
// totalCalls: 3,
// successfulCalls: 3,
// failedCalls: 0,
// results: [
// { contractAddress: "0xA0b...", functionName: "balanceOf", result: "1000000000", status: "success" },
// { contractAddress: "0xA0b...", functionName: "symbol", result: "USDC", status: "success" },
// { contractAddress: "0xA0b...", functionName: "decimals", result: "6", status: "success" }
// ]
// }📚 API Reference
Tools
The server provides 25 focused MCP tools for agents. All tools that accept address parameters support both Ethereum addresses and ENS names.
Wallet Information
Tool Name | Description | Key Parameters |
| Get the address of the configured wallet (from EVM_PRIVATE_KEY) | none |
Network Information
Tool Name | Description | Key Parameters |
| Get network information |
|
| List all supported EVM networks | none |
| Get current gas prices on a network |
|
ENS Services
Tool Name | Description | Key Parameters |
| Resolve ENS name to address |
|
| Reverse lookup address to ENS name |
|
Block & Transaction Information
Tool Name | Description | Key Parameters |
| Get block data |
|
| Get latest block data |
|
| Get transaction details |
|
| Get transaction receipt with logs |
|
| Wait for transaction confirmation |
|
Balance & Token Information
Tool Name | Description | Key Parameters |
| Get native token balance |
|
| Check ERC20 token balance |
|
| Check token spending allowance |
|
Smart Contract Interactions
Tool Name | Description | Key Parameters |
| Fetch contract ABI from block explorer (60+ networks) |
|
| Read smart contract state (auto-fetches ABI if needed) |
|
| Execute state-changing functions (auto-fetches ABI if needed) |
|
| Batch multiple read calls into a single RPC request (uses Multicall3) |
|
Token Transfers
Tool Name | Description | Key Parameters |
| Send native tokens (ETH, etc.) |
|
| Transfer ERC20 tokens |
|
| Approve token allowances |
|
NFT Services
Tool Name | Description | Key Parameters |
| Get NFT (ERC721) metadata |
|
| Check ERC1155 balance |
|
Message Signing
Tool Name | Description | Key Parameters |
| Sign arbitrary messages for authentication and verification (SIWE, off-chain signatures) |
|
| Sign EIP-712 structured data for gasless transactions, permits, and meta-transactions |
|
Resources
The server exposes blockchain data through the following MCP resource URIs. All resource URIs that accept addresses also support ENS names, which are automatically resolved to addresses.
Blockchain Resources
Resource URI Pattern | Description |
| Chain information for a specific network |
| Ethereum mainnet chain information |
| Block data by number |
| Latest block data |
| Native token balance |
| Transaction details |
| Transaction receipt with logs |
Token Resources
Resource URI Pattern | Description |
| ERC20 token information |
| ERC20 token balance |
| NFT (ERC721) token information |
| NFT ownership verification |
| ERC1155 token URI |
| ERC1155 token balance |
🔒 Security Considerations
Private keys are used only for transaction signing and are never stored by the server
Consider implementing additional authentication mechanisms for production use
Use HTTPS for the HTTP server in production environments
Implement rate limiting to prevent abuse
For high-value services, consider adding confirmation steps
📁 Project Structure
mcp-evm-server/
├── src/
│ ├── index.ts # Main stdio server entry point
│ ├── server/ # Server-related files
│ │ ├── http-server.ts # HTTP server with SSE
│ │ └── server.ts # General server setup
│ ├── core/
│ │ ├── chains.ts # Chain definitions and utilities
│ │ ├── resources.ts # MCP resources implementation
│ │ ├── tools.ts # MCP tools implementation
│ │ ├── prompts.ts # MCP prompts implementation
│ │ └── services/ # Core blockchain services
│ │ ├── index.ts # Operation exports
│ │ ├── balance.ts # Balance services
│ │ ├── transfer.ts # Token transfer services
│ │ ├── utils.ts # Utility functions
│ │ ├── tokens.ts # Token metadata services
│ │ ├── contracts.ts # Contract interactions
│ │ ├── transactions.ts # Transaction services
│ │ └── blocks.ts # Block services
│ │ └── clients.ts # RPC client utilities
├── package.json
├── tsconfig.json
└── README.md🛠️ Development
To modify or extend the server:
Add new services in the appropriate file under
src/core/services/Register new tools in
src/core/tools.tsRegister new resources in
src/core/resources.tsAdd new network support in
src/core/chains.tsTo change server configuration, edit the hardcoded values in
src/server/http-server.ts
📄 License
This project is licensed under the terms of the MIT License.
Available Tools
28 toolsapprove_token_spendingA
Approve another address (like a DeFi protocol or exchange) to spend your ERC20 tokens. This is often required before interacting with DeFi protocols.
Inputs: amount (required), privateKey (required), spenderAddress (required), tokenAddress (required), +1 more.
check_nft_ownershipB
Check if an address owns a specific NFT
Inputs: ownerAddress (required), tokenAddress (required), tokenId (required), network.
estimate_gasC
Estimate the gas cost for a transaction
Inputs: to (required), data, network, value.
get_address_from_private_keyB
Get the EVM address derived from a private key
Inputs: privateKey (required).
get_balanceA
Get the native token balance (ETH, MATIC, etc.) for an address
Inputs: address (required), network.
get_block_by_numberC
Get a block by its block number
Inputs: blockNumber (required), network.
get_chain_infoB
Get information about an EVM network
Inputs: network.
get_erc1155_balanceB
Get the balance of a specific ERC1155 token ID owned by an address. ERC1155 allows multiple tokens of the same ID, so the balance can be greater than 1.
Inputs: ownerAddress (required), tokenAddress (required), tokenId (required), network.
get_erc1155_token_uriB
Get the metadata URI for an ERC1155 token (multi-token standard used for both fungible and non-fungible tokens). The URI typically points to JSON metadata about the token.
Inputs: tokenAddress (required), tokenId (required), network.
get_erc20_balanceC
Get the ERC20 token balance of an Ethereum address
Inputs: address (required), tokenAddress (required), network.
get_latest_blockC
Get the latest block from the EVM
Inputs: network.
get_nft_balanceA
Get the total number of NFTs owned by an address from a specific collection. This returns the count of NFTs, not individual token IDs.
Inputs: ownerAddress (required), tokenAddress (required), network.
get_nft_infoA
Get detailed information about a specific NFT (ERC721 token), including collection name, symbol, token URI, and current owner if available.
Inputs: tokenAddress (required), tokenId (required), network.
get_supported_networksB
Get a list of supported EVM networks
Inputs: no named parameters.
get_token_balanceC
Get the balance of an ERC20 token for an address
Inputs: ownerAddress (required), tokenAddress (required), network.
get_token_balance_erc20B
Get ERC20 token balance for an address
Inputs: address (required), tokenAddress (required), network.
get_token_infoA
Get comprehensive information about an ERC20 token including name, symbol, decimals, total supply, and other metadata. Use this to analyze any token on EVM chains.
Inputs: tokenAddress (required), network.
get_transactionA
Get detailed information about a specific transaction by its hash. Includes sender, recipient, value, data, and more.
Inputs: txHash (required), network.
get_transaction_receiptC
Get a transaction receipt by its hash
Inputs: txHash (required), network.
is_contractB
Check if an address is a smart contract or an externally owned account (EOA)
Inputs: address (required), network.
read_contractA
Read data from a smart contract by calling a view/pure function. This doesn't modify blockchain state and doesn't require gas or signing.
Inputs: abi (required), contractAddress (required), functionName (required), args, +1 more.
resolve_ensB
Resolve an ENS name to an Ethereum address
Inputs: ensName (required), network.
transfer_erc1155B
Transfer ERC1155 tokens to another address. ERC1155 is a multi-token standard that can represent both fungible and non-fungible tokens in a single contract.
Inputs: amount (required), privateKey (required), toAddress (required), tokenAddress (required), +2 more.
transfer_erc20C
Transfer ERC20 tokens to another address
Inputs: amount (required), privateKey (required), toAddress (required), tokenAddress (required), +1 more.
transfer_ethB
Transfer native tokens (ETH, MATIC, etc.) to an address
Inputs: amount (required), privateKey (required), to (required), network.
transfer_nftA
Transfer an NFT (ERC721 token) from one address to another. Requires the private key of the current owner for signing the transaction.
Inputs: privateKey (required), toAddress (required), tokenAddress (required), tokenId (required), +1 more.
transfer_tokenC
Transfer ERC20 tokens to an address
Inputs: amount (required), privateKey (required), toAddress (required), tokenAddress (required), +1 more.
write_contractA
Write data to a smart contract by calling a state-changing function. This modifies blockchain state and requires gas payment and transaction signing.
Inputs: abi (required), args (required), contractAddress (required), functionName (required), +2 more.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 28 tools
The tool set has clear distinctions for most operations, but there are notable overlaps that could cause confusion. For example, get_token_balance and get_erc20_balance appear to serve the same purpose, and transfer_erc20 and transfer_token are redundant. However, descriptions help clarify specific use cases, such as differentiating between ERC20, ERC721, and ERC1155 token types.
Most tools follow a consistent verb_noun pattern (e.g., get_balance, transfer_erc20, read_contract), making them predictable and readable. Minor deviations exist, such as check_nft_ownership and is_contract, which use different verb styles but still fit the overall naming convention without causing significant confusion.
With 28 tools, the count feels heavy for an EVM server, as many tools could be consolidated or generalized. While the domain is broad, the high number may overwhelm agents and lead to inefficiency. A more streamlined set of 15-20 tools would better balance coverage and usability.
The tool surface provides comprehensive coverage for EVM operations, including token interactions, contract reads/writes, and blockchain queries. Minor gaps exist, such as missing tools for advanced DeFi operations or event listening, but core workflows like transfers, balances, and contract interactions are well-covered, allowing agents to handle most common tasks effectively.
Maintenance
Related MCP Connectors
MCP server connecting AI agents to non-custodial staking data across 130+ networks.
Provide AI agents and automation tools with contextual access to blockchain data including balance…
ChainRay provides multi-chain blockchain data and intelligence for AI agents through 79 MCP tools across 57 supported networks, covering gas, chain data, wallets, DeFi, market, security, monitoring, and verifiable proofs. MCP access is available at https://mcp.chainray.online/mcp; paid HTTP capabilities settle via x402 on Base.
MCP server connecting AI agents to 100+ apps (Gmail, Slack, Notion, GitHub) via one-click OAuth.
Related MCP Servers
- AlicenseDqualityDmaintenanceA Model Context Protocol server that gives LLMs the ability to interact with Ethereum networks, manage wallets, query blockchain data, and execute smart contract operations through a standardized interface.5414MIT
- AlicenseAqualityDmaintenanceA comprehensive server that enables AI agents to interact with multiple EVM-compatible blockchain networks through a unified interface, supporting ENS resolution, token operations, and smart contract interactions.25MIT
- -licenseNot gradedqualityNot gradedmaintenanceComprehensive Model Context Protocol server that enables AI agents to interact with 30+ Ethereum-compatible blockchain networks, supporting token transfers, smart contract interactions, and ENS name resolution through a unified interface.1-
- AlicenseBqualityDmaintenanceA Model Context Protocol server that allows LLMs to interact with blockchain through MetaMask, keeping private keys securely in your crypto wallet while enabling transactions and blockchain operations.2812MIT