What can @alchemy/mcp-server do?

blockchain-native rpc method exposure via mcp protocol, alchemy-specific enhanced rpc methods (enhanced apis), mcp tool schema auto-generation from alchemy method signatures, alchemy api key management and request signing, multi-chain rpc endpoint routing, transaction simulation and dry-run execution, webhook-based event streaming and indexing, contract abi parsing and function encoding

@alchemy/mcp-server

MCP ServerFree

MCP server for using Alchemy APIs

Open Source

/ 100

8 capabilities

Capabilities8 decomposed

blockchain-native rpc method exposure via mcp protocol

Medium confidence

Exposes Alchemy's blockchain RPC methods (eth_call, eth_sendTransaction, eth_getBalance, etc.) as standardized MCP tools that Claude and other MCP clients can invoke. Implements the Model Context Protocol specification to translate Alchemy API endpoints into a tool registry with JSON schema validation, enabling LLM agents to interact with blockchain state without direct HTTP knowledge.

Solves for

I want my Claude agent to read blockchain data like account balances and contract state without writing custom API wrappersI need to enable LLM-driven blockchain transactions through a standardized protocol instead of building custom integrationsI want to abstract away Alchemy API authentication and RPC method signatures so agents can focus on logic

Best for

AI agent developers building blockchain-aware applications

Teams integrating Claude with Web3 workflows

Builders prototyping LLM-driven DeFi or NFT applications

Requires

Alchemy API key with appropriate permissions

MCP-compatible client (Claude Desktop, or custom MCP host)

Node.js 16+ runtime

Limitations

Limited to Alchemy's supported RPC methods — custom contract ABIs require separate schema definition

No built-in transaction simulation or dry-run capability — agents must handle transaction validation externally

Synchronous RPC calls only — no streaming or subscription-based event listening

What makes it unique

Implements MCP as a first-class protocol bridge to Alchemy's RPC infrastructure, allowing Claude and other MCP clients to invoke blockchain methods with automatic schema validation and error handling, rather than requiring custom HTTP clients or SDK wrappers

vs alternatives

Provides standardized MCP tool exposure of Alchemy APIs, enabling Claude agents to access blockchain data without custom integration code, whereas direct Alchemy SDK usage requires manual tool definition and schema management

alchemy-specific enhanced rpc methods (enhanced apis)

Medium confidence

Exposes Alchemy's proprietary Enhanced APIs (alchemy_getTokenBalances, alchemy_getNFTs, alchemy_getAssetTransfers, etc.) as MCP tools with pre-configured schemas. These methods provide higher-level abstractions over raw Ethereum RPC, returning parsed and indexed blockchain data without requiring agents to manually decode contract ABIs or filter logs.

Solves for

I want my agent to fetch all NFTs owned by an address without manually querying ERC-721 contractsI need to retrieve token balances across multiple ERC-20 contracts in a single callI want to analyze asset transfer history for an address without parsing raw transaction logs

Best for

NFT and DeFi application builders using Claude agents

Teams building portfolio tracking or wallet analysis tools

Developers prototyping token discovery and asset management features

Requires

Alchemy API key with Enhanced API access enabled

Alchemy premium or growth tier subscription

MCP-compatible client

Limitations

Enhanced APIs only available on Alchemy's premium plans — free tier limited to standard RPC

Data freshness depends on Alchemy's indexing latency — typically 1-2 blocks behind chain head

No custom filtering at the MCP layer — agents must post-process results for complex queries

What makes it unique

Wraps Alchemy's proprietary Enhanced APIs (alchemy_* methods) as MCP tools with pre-built schemas, eliminating the need for agents to understand contract ABIs or log parsing — data arrives pre-indexed and decoded from Alchemy's infrastructure

vs alternatives

Provides higher-level blockchain data access than raw RPC methods, reducing agent complexity compared to using standard Ethereum RPC where agents must manually decode contract interactions and filter events

mcp tool schema auto-generation from alchemy method signatures

Medium confidence

Automatically generates MCP-compliant tool schemas (JSON Schema format) from Alchemy's RPC and Enhanced API method signatures, including parameter validation, type coercion, and error handling. Implements schema introspection to map Alchemy's API documentation into structured tool definitions that MCP clients can parse and present to LLMs with proper type hints and constraints.

Solves for

I want Claude to understand the exact parameters and return types for Alchemy methods without manual schema definitionI need type validation on blockchain parameters (addresses, hashes, block numbers) before sending to AlchemyI want error messages from Alchemy to be translated into human-readable guidance for the agent

Best for

MCP server developers building blockchain integrations

Teams automating tool definition maintenance

Builders reducing manual schema boilerplate

Requires

Alchemy API documentation or OpenAPI spec

Node.js 16+

JSON Schema validator library

Limitations

Schema generation limited to documented Alchemy methods — custom or beta endpoints require manual definition

Type coercion assumes standard Ethereum types (address, uint256, bytes32) — complex struct types may require custom handlers

No runtime validation of blockchain-specific constraints (e.g., address checksums, valid block ranges) — validation is schema-level only

What makes it unique

Implements automatic schema generation from Alchemy's API signatures, reducing manual tool definition work and ensuring schemas stay synchronized with API changes through introspection rather than static configuration

vs alternatives

Eliminates manual JSON Schema authoring for Alchemy tools compared to hand-written MCP server implementations, reducing maintenance burden and schema drift

alchemy api key management and request signing

Medium confidence

Handles secure storage and injection of Alchemy API keys into outbound RPC requests, implementing request signing and authentication headers required by Alchemy's endpoints. Manages API key lifecycle (rotation, expiration) and enforces rate-limiting headers to prevent quota exhaustion, abstracting authentication complexity from MCP clients.

Solves for

I want my MCP server to securely use my Alchemy API key without exposing it to the clientI need to rotate API keys without restarting the MCP serverI want to monitor and enforce rate limits to avoid exceeding my Alchemy quota

Best for

Production deployments of blockchain agents

Teams managing multiple Alchemy API keys across environments

Builders requiring audit trails of API usage

Requires

Alchemy API key (stored as environment variable or config)

Node.js 16+

Network access to Alchemy endpoints

Limitations

API key stored in environment variables or config files — no built-in key vault integration (AWS Secrets Manager, HashiCorp Vault)

Rate limiting enforced at MCP server level only — no cross-instance coordination for distributed deployments

No request caching — every MCP tool invocation results in a fresh Alchemy API call

What makes it unique

Centralizes Alchemy API key management within the MCP server, preventing key exposure to clients and enforcing rate limits at the server boundary rather than delegating to individual client implementations

vs alternatives

Provides server-side API key isolation compared to client-side SDK usage where each agent instance must manage its own authentication, reducing key exposure surface and enabling centralized quota enforcement

multi-chain rpc endpoint routing

Medium confidence

Routes MCP tool calls to the appropriate Alchemy RPC endpoint based on chain ID or network name (Ethereum mainnet, Polygon, Arbitrum, Optimism, etc.). Implements chain detection logic to automatically select the correct endpoint and validate that requested operations are supported on the target chain, enabling agents to work across multiple blockchains through a unified MCP interface.

Solves for

I want my agent to query data from Polygon without manually switching RPC endpointsI need to detect which chain a contract address belongs to and route the call correctlyI want to support multi-chain operations (e.g., compare token prices across Ethereum and Polygon) through a single MCP interface

Best for

Multi-chain DeFi and NFT application developers

Teams building cross-chain analytics or arbitrage agents

Builders supporting users across multiple blockchain ecosystems

Requires

Alchemy API keys for each supported chain

Chain ID or network name parameter in tool calls

Node.js 16+

Limitations

Chain routing limited to Alchemy's supported networks — no custom RPC endpoint configuration

No cross-chain atomic operations — agents must handle multi-chain transactions as separate calls

Chain detection relies on explicit chain ID parameter — no automatic chain inference from addresses

What makes it unique

Implements transparent multi-chain routing at the MCP server level, allowing agents to specify chain ID once and automatically receive responses from the correct Alchemy endpoint, rather than requiring separate tool definitions per chain

vs alternatives

Provides unified multi-chain access through a single MCP interface compared to maintaining separate RPC connections or tool definitions for each blockchain, reducing agent configuration complexity

transaction simulation and dry-run execution

Medium confidence

Leverages Alchemy's simulation APIs (eth_call, eth_simulateExecution) to execute transactions in a read-only sandbox before broadcasting to the network. Returns detailed execution traces including gas usage, state changes, and revert reasons, enabling agents to validate transaction logic and estimate costs without risking real assets or network fees.

Solves for

I want my agent to test a transaction before sending it to avoid wasting gas on failed transactionsI need to estimate gas costs for a complex smart contract interactionI want to understand why a transaction would fail before broadcasting it

Best for

DeFi agents executing complex transactions (swaps, liquidity provision, lending)

Teams building transaction builders or simulators

Developers prototyping smart contract interactions

Requires

Alchemy API key with simulation API access

Transaction object (to, data, value, from, gas)

Node.js 16+

Limitations

Simulation accuracy depends on contract state at simulation block — state may diverge by execution time

No support for multi-block simulations — agents cannot simulate time-dependent logic (e.g., staking rewards)

Simulation results do not account for mempool ordering or MEV — actual execution may differ

What makes it unique

Exposes Alchemy's transaction simulation APIs as MCP tools, enabling agents to validate and debug transactions before broadcasting, with detailed execution traces that inform decision-making without requiring custom simulation infrastructure

vs alternatives

Provides pre-execution validation through Alchemy's infrastructure compared to agents blindly broadcasting transactions or using generic eth_call without detailed trace information, reducing failed transaction costs

webhook-based event streaming and indexing

Medium confidence

Configures Alchemy Notify webhooks to stream blockchain events (transfers, contract interactions, state changes) to the MCP server, which indexes and caches events for agent queries. Implements event filtering, deduplication, and persistence, enabling agents to react to real-time blockchain activity without polling or maintaining their own event listeners.

Solves for

I want my agent to be notified when a specific wallet receives a transferI need to monitor contract events (e.g., Uniswap swaps) and trigger actions based on conditionsI want to build an event-driven agent that reacts to blockchain activity in real-time

Best for

Real-time blockchain monitoring and alerting agents

Teams building event-driven DeFi applications

Developers creating automated trading or arbitrage bots

Requires

Alchemy Notify subscription (paid feature)

Public URL for webhook endpoint (requires server to be internet-accessible)

Persistent storage backend (Redis, PostgreSQL, or similar)

Limitations

Webhook delivery is asynchronous and not guaranteed — events may be missed or delayed

Event indexing requires persistent storage — no built-in database, requires external state store (Redis, PostgreSQL)

Webhook configuration requires manual setup in Alchemy dashboard — no programmatic webhook management in MCP server

What makes it unique

Integrates Alchemy Notify webhooks with MCP to provide real-time event streaming and indexing, enabling agents to subscribe to blockchain events and react without polling, with event deduplication and persistence handled server-side

vs alternatives

Provides event-driven architecture compared to polling-based approaches where agents must repeatedly query for new events, reducing latency and API usage for real-time blockchain monitoring

contract abi parsing and function encoding

Medium confidence

Parses contract ABIs (Application Binary Interfaces) to automatically generate MCP tools for contract functions, handling parameter encoding, return value decoding, and error handling. Implements ethers.js or web3.js integration to convert human-readable function calls into encoded transaction data (calldata) and decode return values, enabling agents to interact with smart contracts without manual ABI knowledge.

Solves for

I want my agent to call a smart contract function without manually encoding parametersI need to decode contract return values into readable formatI want to generate MCP tools from a contract ABI automatically

Best for

DeFi and NFT application developers

Teams building contract interaction agents

Builders reducing manual calldata encoding complexity

Requires

Contract ABI (JSON format)

ethers.js or web3.js library

Node.js 16+

Limitations

ABI parsing assumes standard Solidity ABI format — non-standard or proxy contract ABIs may require manual handling

Complex types (nested structs, arrays of tuples) may not encode/decode correctly without custom handlers

No automatic function discovery — agents must provide ABI explicitly

What makes it unique

Automatically generates MCP tools from contract ABIs with built-in parameter encoding and return value decoding, eliminating manual calldata construction and allowing agents to interact with contracts using natural function calls

vs alternatives

Reduces agent complexity compared to manual ABI parsing and calldata encoding, providing type-safe contract interactions through auto-generated MCP tools

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Related Artifactssharing capabilities

Artifacts that share capabilities with @alchemy/mcp-server, ranked by overlap. Discovered automatically through the match graph.

MCP Server22

ALAPI

** - ALAPI MCP Tools,Call hundreds of API interfaces via MCP

schema-based mcp tool registration and discoverymcp protocol compliance and client communicationmulti-provider api gateway via mcp protocol

3 shared capabilities

MCP Server23

Openfort

** - Supercharge your AI assistant with plug-and-play access to authentication, project scaffolding, and smart wallet tooling.

multi-provider blockchain rpc abstractionmcp-based wallet authentication integration

2 shared capabilities

MCP Server24

Nebula-Block-Data/nebulablock-mcp-server

** integrates with the fastmcp library to expose the full range of NebulaBlock API functionalities as accessible tools

mcp-server-initialization-and-tool-registrationblockchain-data-query-via-mcp-tools

2 shared capabilities

Repository25

phoenix-ai

GenAI library for RAG , MCP and Agentic AI

mcp (model context protocol) server implementation and client integration

1 shared capability

MCP Server25

Armor Crypto MCP

** - MCP to interface with multiple blockchains, staking, DeFi, swap, bridging, wallet management, DCA, Limit Orders, Coin Lookup, Tracking and more.

mcp tool schema registration and ai agent binding

1 shared capability

MCP Server19

@grackle-ai/mcp

MCP (Model Context Protocol) server for Grackle — translates MCP tool calls to ConnectRPC

tool schema inference and mcp capability advertisement

1 shared capability

Best For

✓AI agent developers building blockchain-aware applications
✓Teams integrating Claude with Web3 workflows
✓Builders prototyping LLM-driven DeFi or NFT applications
✓NFT and DeFi application builders using Claude agents
✓Teams building portfolio tracking or wallet analysis tools
✓Developers prototyping token discovery and asset management features
✓MCP server developers building blockchain integrations
✓Teams automating tool definition maintenance

Known Limitations

⚠Limited to Alchemy's supported RPC methods — custom contract ABIs require separate schema definition
⚠No built-in transaction simulation or dry-run capability — agents must handle transaction validation externally
⚠Synchronous RPC calls only — no streaming or subscription-based event listening
⚠No rate-limiting or quota management at the MCP layer — relies on Alchemy account limits
⚠Enhanced APIs only available on Alchemy's premium plans — free tier limited to standard RPC
⚠Data freshness depends on Alchemy's indexing latency — typically 1-2 blocks behind chain head

Requirements

Alchemy API key with appropriate permissionsMCP-compatible client (Claude Desktop, or custom MCP host)Node.js 16+ runtimeNetwork access to Alchemy endpointsAlchemy API key with Enhanced API access enabledAlchemy premium or growth tier subscriptionMCP-compatible clientNode.js 16+

Input / Output

Accepts: JSON-formatted RPC parameters (addresses, transaction hashes, contract data), Blockchain identifiers (chain IDs, block numbers, transaction hashes), Ethereum addresses (checksummed or lowercase), Contract addresses, Block range parameters (fromBlock, toBlock), Alchemy API method signatures, Parameter metadata (types, required fields, constraints), API key string, Rate limit configuration (requests per second), Chain ID (integer: 1 for Ethereum, 137 for Polygon, etc.), Network name string (ethereum, polygon, arbitrum, optimism), Transaction objects (Ethereum transaction format), Block number for state snapshot (defaults to latest), Event filter configuration (contract address, event signature, address), Webhook payload from Alchemy (event data, transaction details), Contract ABI (JSON array of function/event definitions), Function name and parameters (human-readable format)

Produces: JSON RPC responses (account balances, transaction receipts, contract state), Structured blockchain data (block headers, transaction objects, logs), Parsed token balance objects with decimals and metadata, NFT metadata arrays with image URIs and attributes, Transfer history with decoded transaction details, JSON Schema objects for MCP tool definitions, Typed parameter validation rules, Error response schemas, Authenticated HTTP requests to Alchemy, Rate limit status and remaining quota, RPC responses from the selected chain endpoint, Chain metadata (network name, currency, block time), Execution trace with gas usage, State changes (storage updates, balance changes), Revert reason and error messages, Indexed event records with metadata, Event query results (filtered by address, contract, time range), Real-time event notifications to agents, Encoded calldata (hex string), Decoded return values (typed objects), MCP tool definitions for contract functions

UnfragileRank

Adoption15%(30% weight)

Quality17%(25% weight)

Ecosystem42%(25% weight)

Match Graph10%(15% weight)

Freshness75%(5% weight)

UnfragileRank is computed from adoption signals, documentation quality, ecosystem connectivity, match graph feedback, and freshness. No artifact can pay for a higher rank.

Type: MCP Server

8 capabilities

Visit @alchemy/mcp-server→

Package Details

npm

Registry

0.3.0

Version

Weekly Downloads

About

MCP server for using Alchemy APIs

Alternatives to @alchemy/mcp-server

IntelliCode50Extension

AI-assisted development

Compare →

GitHub Copilot Chat53Extension

AI chat features powered by Copilot

Compare →

GitHub Copilot52Extension

Your AI pair programmer

Compare →

Claude Code for VS Code52Extension

Claude Code for VS Code: Harness the power of Claude Code without leaving your IDE

Compare →

Are you the builder of @alchemy/mcp-server?

Claim this artifact to get a verified badge, access match analytics, see which intents users search for, and manage your listing.

Claim this artifact →Verification via email

Get the weekly brief

New tools, rising stars, and what's actually worth your time. No spam.

Data Sources

mcp registry

Looking for something else?

Search →

Capabilities8 decomposed

blockchain-native rpc method exposure via mcp protocol

Medium confidence

Solves for

Best for

AI agent developers building blockchain-aware applications

Teams integrating Claude with Web3 workflows

Builders prototyping LLM-driven DeFi or NFT applications

Requires

Alchemy API key with appropriate permissions

MCP-compatible client (Claude Desktop, or custom MCP host)

Node.js 16+ runtime

Limitations

Limited to Alchemy's supported RPC methods — custom contract ABIs require separate schema definition

No built-in transaction simulation or dry-run capability — agents must handle transaction validation externally

Synchronous RPC calls only — no streaming or subscription-based event listening

What makes it unique

vs alternatives

alchemy-specific enhanced rpc methods (enhanced apis)

Medium confidence

Solves for

Best for

NFT and DeFi application builders using Claude agents

Teams building portfolio tracking or wallet analysis tools

Developers prototyping token discovery and asset management features

Requires

Alchemy API key with Enhanced API access enabled

Alchemy premium or growth tier subscription

MCP-compatible client

Limitations

Enhanced APIs only available on Alchemy's premium plans — free tier limited to standard RPC

Data freshness depends on Alchemy's indexing latency — typically 1-2 blocks behind chain head

No custom filtering at the MCP layer — agents must post-process results for complex queries

What makes it unique

vs alternatives

mcp tool schema auto-generation from alchemy method signatures

Medium confidence

Solves for

Best for

MCP server developers building blockchain integrations

Teams automating tool definition maintenance

Builders reducing manual schema boilerplate

Requires

Alchemy API documentation or OpenAPI spec

Node.js 16+

JSON Schema validator library

Limitations

Schema generation limited to documented Alchemy methods — custom or beta endpoints require manual definition

Type coercion assumes standard Ethereum types (address, uint256, bytes32) — complex struct types may require custom handlers

No runtime validation of blockchain-specific constraints (e.g., address checksums, valid block ranges) — validation is schema-level only

What makes it unique

vs alternatives

Eliminates manual JSON Schema authoring for Alchemy tools compared to hand-written MCP server implementations, reducing maintenance burden and schema drift

alchemy api key management and request signing

Medium confidence

Solves for

Best for

Production deployments of blockchain agents

Teams managing multiple Alchemy API keys across environments

Builders requiring audit trails of API usage

Requires

Alchemy API key (stored as environment variable or config)

Node.js 16+

Network access to Alchemy endpoints

Limitations

API key stored in environment variables or config files — no built-in key vault integration (AWS Secrets Manager, HashiCorp Vault)

Rate limiting enforced at MCP server level only — no cross-instance coordination for distributed deployments

No request caching — every MCP tool invocation results in a fresh Alchemy API call

What makes it unique

vs alternatives

multi-chain rpc endpoint routing

Medium confidence

Solves for

Best for

Multi-chain DeFi and NFT application developers

Teams building cross-chain analytics or arbitrage agents

Builders supporting users across multiple blockchain ecosystems

Requires

Alchemy API keys for each supported chain

Chain ID or network name parameter in tool calls

Node.js 16+

Limitations

Chain routing limited to Alchemy's supported networks — no custom RPC endpoint configuration

No cross-chain atomic operations — agents must handle multi-chain transactions as separate calls

Chain detection relies on explicit chain ID parameter — no automatic chain inference from addresses

What makes it unique

vs alternatives

Provides unified multi-chain access through a single MCP interface compared to maintaining separate RPC connections or tool definitions for each blockchain, reducing agent configuration complexity

transaction simulation and dry-run execution

Medium confidence

Solves for

Best for

DeFi agents executing complex transactions (swaps, liquidity provision, lending)

Teams building transaction builders or simulators

Developers prototyping smart contract interactions

Requires

Alchemy API key with simulation API access

Transaction object (to, data, value, from, gas)

Node.js 16+

Limitations

Simulation accuracy depends on contract state at simulation block — state may diverge by execution time

No support for multi-block simulations — agents cannot simulate time-dependent logic (e.g., staking rewards)

Simulation results do not account for mempool ordering or MEV — actual execution may differ

What makes it unique

vs alternatives

webhook-based event streaming and indexing

Medium confidence

Solves for

Best for

Real-time blockchain monitoring and alerting agents

Teams building event-driven DeFi applications

Developers creating automated trading or arbitrage bots

Requires

Alchemy Notify subscription (paid feature)

Public URL for webhook endpoint (requires server to be internet-accessible)

Persistent storage backend (Redis, PostgreSQL, or similar)

Limitations

Webhook delivery is asynchronous and not guaranteed — events may be missed or delayed

Event indexing requires persistent storage — no built-in database, requires external state store (Redis, PostgreSQL)

Webhook configuration requires manual setup in Alchemy dashboard — no programmatic webhook management in MCP server

What makes it unique

vs alternatives

Provides event-driven architecture compared to polling-based approaches where agents must repeatedly query for new events, reducing latency and API usage for real-time blockchain monitoring

contract abi parsing and function encoding

Medium confidence

Solves for

Best for

DeFi and NFT application developers

Teams building contract interaction agents

Builders reducing manual calldata encoding complexity

Requires

Contract ABI (JSON format)

ethers.js or web3.js library

Node.js 16+

Limitations

ABI parsing assumes standard Solidity ABI format — non-standard or proxy contract ABIs may require manual handling

Complex types (nested structs, arrays of tuples) may not encode/decode correctly without custom handlers

No automatic function discovery — agents must provide ABI explicitly

What makes it unique

vs alternatives

Reduces agent complexity compared to manual ABI parsing and calldata encoding, providing type-safe contract interactions through auto-generated MCP tools

Capabilities are decomposed by AI analysis. Each maps to specific user intents and improves with match feedback.

Alternatives to @alchemy/mcp-server

IntelliCode50Extension

AI-assisted development

Compare →

GitHub Copilot Chat53Extension

AI chat features powered by Copilot

Compare →

GitHub Copilot52Extension

Your AI pair programmer

Compare →

Claude Code for VS Code52Extension

Claude Code for VS Code: Harness the power of Claude Code without leaving your IDE

Compare →

@alchemy/mcp-server

Capabilities8 decomposed

blockchain-native rpc method exposure via mcp protocol

alchemy-specific enhanced rpc methods (enhanced apis)

mcp tool schema auto-generation from alchemy method signatures

alchemy api key management and request signing

multi-chain rpc endpoint routing

transaction simulation and dry-run execution

webhook-based event streaming and indexing

contract abi parsing and function encoding

Related Artifactssharing capabilities

ALAPI

Openfort

Nebula-Block-Data/nebulablock-mcp-server

phoenix-ai

Armor Crypto MCP

@grackle-ai/mcp

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Package Details

About

Categories

Alternatives to @alchemy/mcp-server

Are you the builder of @alchemy/mcp-server?

Get the weekly brief

Data Sources

@alchemy/mcp-server

Capabilities8 decomposed

blockchain-native rpc method exposure via mcp protocol

alchemy-specific enhanced rpc methods (enhanced apis)

mcp tool schema auto-generation from alchemy method signatures

alchemy api key management and request signing

multi-chain rpc endpoint routing

transaction simulation and dry-run execution

webhook-based event streaming and indexing

contract abi parsing and function encoding

Related Artifactssharing capabilities

ALAPI

Openfort

Nebula-Block-Data/nebulablock-mcp-server

phoenix-ai

Armor Crypto MCP

@grackle-ai/mcp

Best For

Known Limitations

Requirements

Input / Output

UnfragileRank

Package Details

About

Categories

Alternatives to @alchemy/mcp-server

Are you the builder of @alchemy/mcp-server?

Get the weekly brief

Data Sources