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.
EVM MCP Server
A comprehensive Model Context Protocol (MCP) server that provides blockchain services across multiple 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.
📋 Contents
🔭 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
Transferring tokens (native, ERC20, ERC721, ERC1155)
Querying token metadata and balances
Chain-specific services across 30+ EVM networks
ENS name resolution for all address parameters (use human-readable names like 'vitalik.eth' instead of addresses)
All services are exposed through a consistent interface of MCP tools and resources, 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.
✨ Features
Blockchain Data Access
Multi-chain support for 30+ EVM-compatible networks
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 services with private key signing
Contract verification to distinguish from EOAs
Event logs retrieval and filtering
Comprehensive Transaction Support
Native token transfers across all supported networks
Gas estimation for transaction planning
Transaction status and receipt information
Error handling with descriptive messages
🌐 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
Lumia Testnet
🛠️ Prerequisites
Bun 1.0.0 or higher
Node.js 18.0.0 or higher (if not using Bun)
📦 Installation
⚙️ 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.ts
For 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:
Running the Server Locally
Start the server using stdio (for embedding in CLI tools):
Or start the HTTP server with SSE for web applications:
Connecting 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-server
Type:
command
Command:
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:
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:
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
.cursor
directory in your project root if it doesn't existSave the above JSON as
mcp.json
in the.cursor
directoryRestart 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:
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:
Example: Getting a Token Balance with ENS
Example: Resolving an ENS Name
📚 API Reference
Tools
The server provides the following MCP tools for agents. All tools that accept address parameters support both Ethereum addresses and ENS names.
Token services
Tool Name | Description | Key Parameters |
| Get ERC20 token metadata |
(address/ENS),
|
| Check ERC20 token balance |
(address/ENS),
(address/ENS),
|
| Transfer ERC20 tokens |
,
(address/ENS),
(address/ENS),
,
|
| Approve token allowances |
,
(address/ENS),
(address/ENS),
,
|
| Get NFT metadata |
(address/ENS),
,
|
| Verify NFT ownership |
(address/ENS),
,
(address/ENS),
|
| Transfer an NFT |
,
(address/ENS),
,
(address/ENS),
|
| Count NFTs owned |
(address/ENS),
(address/ENS),
|
| Get ERC1155 metadata |
(address/ENS),
,
|
| Check ERC1155 balance |
(address/ENS),
,
(address/ENS),
|
| Transfer ERC1155 tokens |
,
(address/ENS),
,
,
(address/ENS),
|
Blockchain services
Tool Name | Description | Key Parameters |
| Get network information |
|
| Get native token balance |
(address/ENS),
|
| Send native tokens |
,
(address/ENS),
,
|
| Get transaction details |
,
|
| Read smart contract state |
(address/ENS),
,
,
,
|
| Write to smart contract |
(address/ENS),
,
,
,
,
|
| Check if address is a contract |
(address/ENS),
|
| Resolve ENS name to address |
,
|
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
🛠️ 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.ts
Register new resources in
src/core/resources.ts
Add new network support in
src/core/chains.ts
To 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.
remote-capable server
The server can be hosted and run remotely because it primarily relies on remote services or has no dependency on the local environment.
Tools
A Model Context Protocol server that enables AI agents to interact with 30+ Ethereum-compatible blockchain networks, providing services like token transfers, contract interactions, and ENS resolution through a unified interface.
- 📋 Contents
- 🔭 Overview
- ✨ Features
- 🌐 Supported Networks
- 🛠️ Prerequisites
- 📦 Installation
- ⚙️ Server Configuration
- 🚀 Usage
- 📚 API Reference
- 🔒 Security Considerations
- 📁 Project Structure
- 🛠️ Development
- 📄 License
Related Resources
Related MCP Servers
- AsecurityAlicenseAqualityA 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.Last updated -45138MIT License
- -securityFlicense-qualityA Model Context Protocol server that enables AI agents to interact with the Flow blockchain through RPC calls, supporting account balances, script execution, transactions, domain resolution, and contract interactions.
- -security-license-qualityComprehensive 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.Last updated -1MIT License
- AsecurityAlicenseAqualityA comprehensive Model Context Protocol server that enables AI agents to interact with Starknet blockchain, query data, manage wallets, and work with smart contracts.Last updated -25104MIT License