Crear un servidor EVM MCP con Claude AI

14 minutos de lectura

Resumen

El Protocolo de Contexto de Modelos (MCP) permite a los grandes modelos de lenguaje (LLM) interactuar con herramientas externas —como API HTTP, archivos o incluso cadenas de bloques— mediante un protocolo estandarizado basado en mensajes. Piensa en él como una interfaz de «llamada a funciones» a la que pueden conectarse agentes como Claude o Cursor, convirtiendo un script o un servicio en una extensión nativa de IA.

En esta guía, aprenderás a crear e implementar un servidor MCP que permita a los agentes LLM acceder a datos de blockchain en múltiples redes compatibles con EVM. Esta potente integración permite que modelos de IA como Claude interactúen directamente con datos de blockchain, lo que abre nuevas posibilidades para la automatización y el análisis en Web3.

Tus funciones

Crear un servidor MCP que interactúe con varias cadenas EVM
Permitir que los modelos de lenguaje grande (LLM) obtengan datos en cadena mediante Viem y el RPC multichain de Quicknode
Registrar herramientas, indicaciones y recursos para orientar el comportamiento de los modelos de lenguaje grande (LLM)
Ejecuta el servidor en Claude Desktop y pruébalo con solicitudes en lenguaje natural

Lo que necesitarás

Node.js v20 o superior
Una cuenta gratuita de Quicknode
Claude Desktop (o un ejecutor de agentes compatible)
Experiencia con la cadena de bloques de Ethereum

¿Qué es el MCP?

El Protocolo de Contexto de Modelos (MCP) es un estándar abierto que permite a los agentes de IA interactuar con herramientas y fuentes de datos externas. Establece un canal de comunicación estructurado entre los modelos de lenguaje y las herramientas.

Sin MCP, los modelos de IA se ven limitados a:

Información sobre la que recibieron formación
La conversación que están manteniendo ahora mismo
No es posible consultar fuentes de datos externas
No hay forma de llevar a cabo acciones en el mundo real

MCP cubre esta carencia creando métodos estandarizados para que la IA acceda a herramientas y datos externos.

Arquitectura de alto nivel Fuente (modificada para el servidor que estamos desarrollando): Protocolo de contexto del modelo

Conceptos clave

Cómo funcionan los servidores MCP

Los servidores MCP se encargan de gestionar las solicitudes entrantes del cliente y de devolver los datos correspondientes. Utilizan el protocolo MCP para comunicarse con el LLM y pueden implementarse en cualquier lenguaje de programación o marco de trabajo.

Cada servidor se comunica con el LLM a través de canales estándar (stdio, HTTP o sockets) y devuelve una salida bien estructurada. Esto permite al LLM comprender el contexto y la intención de la solicitud, y responder de forma adecuada. El protocolo MCP está diseñado para ser extensible, lo que permite a los desarrolladores añadir nuevas herramientas, recursos y indicaciones según sea necesario.

Herramientas: funciones que la IA puede invocar para realizar acciones específicas. Pueden ser desde una simple llamada a una API hasta una tarea compleja.

Ejemplo: eth_getBalance para consultar el saldo de un monedero
Ejemplo: previsión_meteorológica para obtener datos meteorológicos actualizados

Recursos: Conocimientos estáticos a los que la IA puede recurrir. Estos influyen en el contexto y los supuestos del modelo; por ejemplo, añadir un referencia de gas Este recurso ayuda a Claude a saber si el precio del gas es bajo, medio o alto para una cadena concreta, sin necesidad de recurrir a ninguna herramienta.

Ejemplo: Información sobre los precios de la gasolina en una cadena concreta
Ejemplo: Documentación sobre los parámetros de la API

Indicaciones: Instrucciones predefinidas que guían a la IA. Funcionan como plantillas reutilizables para el razonamiento. Cada indicación define cómo debe abordar el modelo de lenguaje grande (LLM) una tarea (por ejemplo, «analiza esta cartera») utilizando herramientas y un razonamiento estructurado.

Ejemplo: Plantillas para analizar la actividad de la cartera
Ejemplo: Guías paso a paso para realizar tareas complejas

Cuando conectas un servidor MCP a una IA como Claude:

La IA descubre qué herramientas, recursos y indicaciones hay disponibles
Cuando sea necesario, la IA puede invocar estas herramientas con parámetros específicos
El servidor procesa estas solicitudes y devuelve datos estructurados
La IA interpreta los resultados y los incorpora a su respuesta

A continuación se muestra cómo se desarrolla la misma consulta de usuario con y sin un servidor MCP:

Ejemplo sencillo: cómo consultar el saldo de un monedero

	Sin MCP	Con MCP
Usuario	«¿Cuál es el saldo de la cartera 0x123...?»	«¿Cuál es el saldo de la cartera 0x123...?»
Proceso de IA	No hay acceso a datos externos	[Llama a la herramienta eth_getBalance a través de MCP]
Respuesta de la IA	«No tengo acceso a los datos actuales de la cadena de bloques, así que no puedo comprobar el saldo de esa cartera».	«Esa cartera contiene actualmente 0,45 ETH en Ethereum».
Resultado	❌ No es posible atender la solicitud del usuario	✅ Se proporcionan datos de la cadena de bloques en tiempo real

Ciclo de vida de las solicitudes en el servidor MCP

Esto es lo que ocurre cuando el agente realiza una solicitud a través de un mensaje de solicitud:

Analiza la solicitud para determinar la acción y los parámetros
Valida los parámetros
Selecciona el cliente de cadena adecuado
Ejecuta la solicitud a través de Viem hacia Quicknode
Da formato a la respuesta y se la devuelve al agente

Flujo del servidor MCP

Hemos aprendido cómo funcionan los servidores MCP. ¡Ahora, vamos a crear uno!

Estructura del proyecto

La estructura del proyecto es la siguiente:

evm-mcp-server/
├── index.ts              # Punto de entrada, configura el servidor MCP
├── chains.ts             # Configuración de la cadena + asignación de puntos finales de Quicknode
├── clients.ts            # Creador de clientes públicos de Viem
├── package.json          # Dependencias y scripts
├── prompts.ts            # Definiciones de prompts para LLM
├── resources.ts          # Referencias externas (precios del gas, exploradores)
├── tools.ts              # Herramientas MCP: getCode, getBalance, gasPrice
└── tsconfig.json         # Configuración de TypeScript

En primer lugar, veamos cada archivo y su finalidad. No obstante, si quieres pasar directamente al código, no dudes en saltar a la sección «Crear tu servidor EVM MCP ».

Código del proyecto

Todo el código de esta guía se puede encontrar en el repositorio de GitHub de Quicknode. Aquí te explicamos cómo funcionan las cosas ofreciéndote una visión general del código, pero utilizaremos el repositorio de GitHub en la sección «Crea tu servidor MCP ».

Punto de entrada: `index.ts`

Este archivo es el punto de entrada que inicializa y pone en marcha el servidor MCP. En él se registran herramientas, mensajes y recursos:

Una parte del archivo index.ts
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js'
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
import { registerTools } from './tools'
import { registerPrompts } from './prompts'
import { registerResources } from './resources'

async function main() {
	try {
		// Create the MCP server
		const server = new McpServer({
			name: 'EVM MCP Server',
			version: '0.1.0',
			description: 'A server for LLM agents to access EVM blockchain data',
		})

		// Register all tools, prompts, and resources
		registerTools(server)
		registerPrompts(server)
		registerResources(server)

		// Start the MCP server
		const transport = new StdioServerTransport()
		await server.connect(transport)
	} catch (error) {
		console.error('❌ Failed to start server:', error)
		process.exit(1)
	}
}

// Run the main function
main().catch(error => {
	console.error('❌ Unhandled error:', error)
	process.exit(1)
})

Configuración de la cadena: `chains.ts`

Este archivo define la configuración de la cadena de bloques y genera direcciones URL RPC basadas en el formato multichain de Quicknode.

Una parte del archivo chains.ts
// Get the endpoint name and token ID from environment variables
const QN_ENDPOINT_NAME = validateEnvVar('QN_ENDPOINT_NAME')
const QN_TOKEN_ID = validateEnvVar('QN_TOKEN_ID')

// Function to build Quicknode RPC URL based on network name
const buildRpcUrl = (networkName: string): string => {
	// Special case for Ethereum mainnet
	if (networkName === 'mainnet') {
		return `https://${QN_ENDPOINT_NAME}.quiknode.pro/${QN_TOKEN_ID}/`
	}

	// Special case for Avalanche mainnet
	if (networkName === 'avalanche-mainnet') {
		return `https://${QN_ENDPOINT_NAME}.${networkName}.quiknode.pro/${QN_TOKEN_ID}/ext/bc/C/rpc`
	}

	// For other networks, include network name in the URL
	return `https://${QN_ENDPOINT_NAME}.${networkName}.quiknode.pro/${QN_TOKEN_ID}/`
}

export const CHAINS = {
	ethereum: {
		network: 'mainnet',
		rpc: buildRpcUrl('mainnet'),
		name: 'Ethereum',
		symbol: 'ETH',
		decimals: 18,
	},
	// Other chains...
}

// Rest of the code...

Creador del cliente: `clients.ts`

Este archivo crea clientes para cada cadena utilizando el createPublicClient función de la Viem biblioteca para establecer una conexión con la cadena mediante los puntos finales RPC de Quicknode.

Una parte del archivo clients.ts
import { createPublicClient, http } from 'viem'
import { ChainId, getChain } from './chains'

// Cache for viem clients to avoid creating duplicate clients
const clientCache = new Map<ChainId, ReturnType<typeof createPublicClient>>()

export const getPublicClient = (chainId: ChainId) => {
	// Return from cache if exists
	if (clientCache.has(chainId)) {
		return clientCache.get(chainId)!
	}

	// Get chain configuration
	const chain = getChain(chainId)

	// Create new public client
	const client = createPublicClient({
		transport: http(chain.rpc),
	})

	// Cache for future use
	clientCache.set(chainId, client)

	return client
}

Indicaciones: `prompts.ts`

Este archivo define las indicaciones que deben utilizar los agentes LLM. El objeto «prompt» contiene el descripción y mensajes propiedades que utiliza el servidor MCP para generar el mensaje de solicitud. Los mensajes de solicitud incluyen instrucciones para ejecutar herramientas, interpretar resultados y dar formato a las respuestas.

Una parte del archivo «prompts.ts»
// Register check-wallet prompt
server.prompt(
	'check-wallet',
	checkWalletSchema.shape,
	({ address, chain }: { address: string; chain: string }) => ({
		description: "Guide for analyzing a wallet's balance and context",
		messages: [
			{
				role: 'user',
				content: {
					type: 'text',
					text: `Please analyze this Ethereum wallet address: ${address} on ${chain} chain.
            
You need to analyze a wallet address on an EVM blockchain.

First, use the eth_getBalance tool to check the wallet's balance.
Next, use the eth_getCode tool to verify if it's a regular wallet or a contract.

Once you have this information, provide a summary of:
1. The wallet's address
2. The chain it's on
3. Its balance in the native token
4. Whether it's a regular wallet (EOA) or a contract
5. Any relevant observations about the balance (e.g., if it's empty, has significant funds, etc.)

Aim to be concise but informative in your analysis.`,
				},
			},
		],
	})
)

// Schema for check-wallet prompt
const checkWalletSchema = z.object({
	address: z.string().refine(isAddress, {
		message: 'Invalid Ethereum address format',
	}),
	chain: z
		.string()
		.refine((val): val is ChainId => Object.keys(CHAINS).includes(val), {
			message:
				'Unsupported chain. Use one of: ethereum, base, arbitrum, avalanche, bsc',
		}),
})

// Rest of the code...

Recursos: `resources.ts`

Este archivo define las referencias externas que pueden utilizar los agentes LLM. En este caso, les proporcionamos acceso a los niveles de precio del gas de cada cadena, enlaces a exploradores de bloques de cada cadena y algunos detalles sobre las propias cadenas.

Una parte del archivo resources.ts
export const registerResources = (server: any) => {
	// Register gas reference resource
	server.resource(
		'gas-reference',
		'evm://docs/gas-reference',
		async (uri: URL) => {
			return {
				contents: [
					{
						uri: uri.href,
						text: JSON.stringify(gasReferencePoints, null, 2),
					},
				],
			}
		}
	)

	// Other resources...
}

// Gas reference points for each chain
const gasReferencePoints = {
	ethereum: {
		low: 20,
		average: 40,
		high: 100,
		veryHigh: 200,
	},
	base: {
		low: 0.05,
		average: 0.1,
		high: 0.3,
		veryHigh: 0.5,
	},
	// Other chains...
}

// Rest of the code...

Herramientas: `tools.ts`

Este archivo define las herramientas a las que puede recurrir el servidor. En este caso, estamos utilizando la eth_getBalance, eth_getCode, y eth_gasPrice herramientas. Cada herramienta es una función asíncrona que consulta la cadena de bloques a través de Viem y devuelve datos estructurados para su uso por parte de los modelos de lenguaje grandes (LLM).

Una parte del archivo tools.ts
// Register tools with the MCP server
export const registerTools = (server: any) => {
	// Register eth_getBalance tool
	server.tool(
		'eth_getBalance',
		balanceSchema.shape,
		async (args: z.infer<typeof balanceSchema>) => {
			try {
				const result = await getBalance(args)
				return {
					content: [
						{
							type: 'text',
							text: JSON.stringify(result, null, 2),
						},
					],
				}
			} catch (error) {
				// Handle errors
			}
		}
	)
	// Other tools...
}

// Schema for eth_getBalance tool
const balanceSchema = z.object({
	address: z.string().refine(isAddress, {
		message: 'Invalid Ethereum address format',
	}),
	chain: z
		.string()
		.refine((val): val is ChainId => Object.keys(CHAINS).includes(val), {
			message:
				'Unsupported chain. Use one of: ethereum, base, arbitrum, avalanche, bsc',
		}),
})

// Other tool schemas...

/**
 * Get the balance of an Ethereum address on the specified chain
 */
export const getBalance = async (params: z.infer<typeof balanceSchema>) => {
	const { address, chain } = balanceSchema.parse(params)

	try {
		const client = getPublicClient(chain as ChainId)
		const chainInfo = getChain(chain as ChainId)

		// Get balance in wei
		const balanceWei = await client.getBalance({ address })

		// Format balance to ETH/native token
		const balanceFormatted = formatEther(balanceWei)

		return {
			address,
			chain: chainInfo.name,
			balanceWei: balanceWei.toString(),
			balanceFormatted: `${balanceFormatted} ${chainInfo.symbol}`,
			symbol: chainInfo.symbol,
			decimals: chainInfo.decimals,
		}
	} catch (error) {
		return {
			error: `Failed to get balance: ${(error as Error).message}`,
		}
	}
}

// Rest of the code...

Configura tu servidor EVM MCP

Hemos visto cómo cada archivo cumple una función en el servidor MCP. Ahora, vamos a crear y poner en marcha nuestro servidor.

Obtener un punto final de Multichain

El servidor MCP que estamos desarrollando será compatible con varias cadenas EVM (Ethereum, Base, Arbitrum, Avalanche y BSC). Al aprovechar el formato multichain de Quicknode, podemos conectarnos fácilmente a estas cadenas mediante un único punto de acceso. Si no tienes una cuenta de Quicknode, puedes crear una gratuita aquí.

Inicia sesión en tu cuenta de Quicknode.
Ve a la pestaña «Puntos finales».
Haz clic en «Crear punto final».
Selecciona la red principal de Ethereum o una de las demás cadenas EVM.
Una vez creado el punto final, activa el formato multichain.
Anota la URL de tu punto final, que tendrá un aspecto similar a este: https://{endpoint_name}.quiknode.pro/{token_id}/ o https://{endpoint_name}.{chain_name}.quiknode.pro/{token_id}.
Extrae el nombre del punto final y el ID del token de la URL.

Gracias al formato multichain, ahora podemos conectarnos a cualquier cadena EVM utilizando un único punto de conexión. El nombre del punto de conexión y el ID del token se utilizan para identificar la cadena y su configuración.

Punto final de Quicknode Multichain

Instrucciones de configuración

Ahora que ya tenemos nuestro punto final, vamos a configurar nuestro servidor MCP.

Paso 1: Clonar el repositorio

git clone https://github.com/quiknode-labs/qn-guide-examples.git
cd qn-guide-examples/AI/evm-mcp-server

Paso 2: Instalar las dependencias

npm instalar

Esto instalará las dependencias necesarias para el proyecto:

@modelcontextprotocol/sdk: Un SDK de TypeScript para crear servidores MCP.
viem: Una biblioteca de TypeScript para interactuar con cadenas de bloques EVM.
zod: Una biblioteca de TypeScript para definir esquemas y validar datos.
typescript: Un compilador de TypeScript.
@types/node: Definiciones de tipos de TypeScript para Node.js.

Paso 3: Compilar el proyecto

npm ejecutar build

Esto genera el compilar/ directorio que contiene el código compilado index.js archivo, que actúa como punto de entrada del servidor.

Paso 4: Configurar Claude Desktop

El servidor utiliza las variables de entorno definidas en el archivo de configuración de Claude Desktop (claude_desktop_config.json) para conectarse a Quicknode y poner en marcha el servidor.

Abre Claude Desktop, ve a Claude > Configuración > Desarrollador
Editar claude_desktop_config.json para incluir lo siguiente (añadir debajo de mcpServers (si existen otras configuraciones):

{
	"mcpServers": {
		"evm": {
			"command": "node",
			"args": ["/absolute-path-to/build/index.js"],
			"env": {
				"QN_ENDPOINT_NAME": "your-quicknode-endpoint-name",
				"QN_TOKEN_ID": "your-quicknode-token-id"
			}
		}
	}
}

Sustituye «your-quicknode-endpoint-name» por el nombre de tu punto final de Quicknode.
Sustituye «your-quicknode-token-id» por tu ID de token de Quicknode.
Sustituye /absolute-path-to por la ruta absoluta al directorio del proyecto (por ejemplo, /Users/username/qn-guide-examples/AI/evm-mcp-server).

Guarda el archivo y reinicia Claude Desktop. Las herramientas, los recursos y las indicaciones de tu servidor MCP deberían estar ahora disponibles en Claude.

Herramientas

Pon a prueba tu servidor MCP

Empecemos a hacer preguntas para ver cómo funciona el servidor.

Análisis de la cartera

Utiliza la siguiente indicación o nuestras indicaciones predefinidas para guiar a Claude a la hora de analizar el saldo y el contexto de una cartera:

Indica el saldo de 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 en Ethereum

O bien, pide a Claude que analice el saldo de una cartera en todas las cadenas compatibles:

Indica la dirección 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 en todas las redes que admites.

Vitalik Balance - Todas las redes

Claude va a:

Llama al eth_getBalance herramienta
Devuelve una respuesta según la indicación

Ten en cuenta que Claude llamará al eth_getBalance herramienta solo para las cadenas con las que es compatible, gracias a la cadenas compatibles recurso.

Detección de contratos

Utiliza la siguiente indicación o nuestras indicaciones predefinidas para guiar a Claude a la hora de detectar si un monedero es un contrato:

¿Qué tipo de contrato es 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2?

Claude va a:

Detectar si se trata de un contrato (mediante la presencia de bytecode)
Explica si se trata de un contrato conocido (utilizando un recurso o datos históricos).

Evaluación de gas

Utiliza la siguiente indicación o nuestras indicaciones predefinidas para guiar a Claude a la hora de evaluar el precio del gas en la red Ethereum:

Analiza el precio actual del gas en Ethereum. ¿Es ahora un buen momento para realizar una transacción?

Claude va a:

Llama al eth_gasPrice herramienta para consultar el precio actual del gas en Quicknode
Consulta el referencia de gas el recurso que has facilitado, que incluye los umbrales de precios del gas bajos, medios, altos y muy altos por cadena
Compara los datos en tiempo real sobre el gas con estos puntos de referencia
Ofrecer una respuesta adaptada al contexto que indique si es un buen momento para realizar la transacción

Precio de la gasolina

¡Enhorabuena! Has creado tu propia herramienta de análisis de datos de blockchain basada en un modelo de lenguaje grande (LLM). Ahora puedes utilizar Claude para analizar e interactuar con datos de blockchain, lo que te permitirá crear aplicaciones inteligentes y automatizar procesos.

¿Y ahora qué?

Una vez que tu servidor EVM MCP esté en funcionamiento, existen muchas formas de ampliar sus capacidades y profundizar su integración en los flujos de trabajo de IA. A continuación se indican varias áreas que puedes explorar:

Ampliar la funcionalidad de EVM

Añade más métodos nativos de EVM para ampliar las capacidades del servidor:

eth_getLogs: Supervisar eventos relacionados con los contratos, como transferencias de tokens o votaciones de DAO
eth_call: Leer datos de contratos inteligentes (por ejemplo, saldos de tokens, configuraciones)
eth_blockNumber: Obtener el último bloque para el seguimiento del estado y la salud de la cadena
eth_getTransactionByHash: Analizar transacciones concretas

Desarrollar mejoras específicas para la IA

Los agentes LLM resultan más útiles cuando se les orienta con un razonamiento y un contexto específicos del ámbito. Consideremos lo siguiente:

Indicaciones específicas: Diseña instrucciones específicas para cada tarea relacionadas con el análisis de DeFi, la auditoría de contratos, la elaboración de perfiles de carteras, etc.
Asistencia técnica de ENS: Resolución .eth nombres de dominio para mejorar la experiencia del usuario
Exploración de datos de tokens ERC20 y NFT: utiliza el paquete de la API v2 de tokens y NFT para obtener saldos de tokens, metadatos de NFT y mucho más
Datos de precios en tiempo real: integra los precios de los tokens mediante un complemento de Quicknode Marketplace, como la API de negociación DEX Aggregator.
Funcionalidad de trading: Si quieres ir más allá de las consultas de solo lectura, echa un vistazo a nuestra guía «Cómo crear un bot de trading para Telegram en Base ». Imagínate combinar las indicaciones de MCP con acciones de trading para crear agentes de trading autónomos.
Agentes personalizados: Combina MCP con LangChain, AutoGen o CrewAI para crear agentes totalmente autónomos con memoria, capacidad de planificación y acceso a la cadena de bloques.
Explora la expansión a múltiples cadenas: ¿Te interesa dar soporte a Solana junto con las cadenas EVM? Sigue nuestra guía «Cómo crear un servidor MCP de Solana para la integración de LLM» para ampliar el alcance de tu agente a distintos ecosistemas.

Añadir almacenamiento en caché y optimización del rendimiento

En el caso de los datos a los que se accede con frecuencia, el almacenamiento en caché puede reducir la latencia y evitar llamadas RPC repetidas:

Uso Redis, SQLite, o simples cachés basados en archivos para eth_getBalance y eth_gasPrice
Configura los valores de TTL (Time-To-Live) para cada cadena o método con el fin de garantizar la actualidad de la información
Utiliza patrones de memoización o envoltorios personalizados para evitar llamadas duplicadas a Viem en cada ejecución.

Análisis y uso de las pistas

Comprende cómo se utilizan tus herramientas:

Registrar las llamadas entrantes sobre herramientas y sugerir su uso
Supervisar qué cadenas son las más consultadas
Añadir métricas básicas de uso (por ejemplo, volumen por cadena, latencia por herramienta)

Estos datos pueden servir de guía para futuras mejoras, como la optimización de las plantillas de indicaciones o la ampliación de la infraestructura.

Reforzar la seguridad y la estabilidad

Dado que los servidores MCP aceptan entradas de los agentes, es importante proteger la superficie de exposición:

Utiliza los esquemas de Zod para validar y depurar rigurosamente todas las entradas
Lee las «Consideraciones de seguridad de MCP» para evitar la inyección de comandos o el uso indebido.
Si vas a exponer públicamente el servidor MCP, plantéate limitar el ancho de banda o añadir capas de autenticación.

Conclusión

El servidor EVM MCP constituye un potente puente entre los agentes LLM y los datos de la cadena de bloques. Mediante la implementación del Protocolo de Contexto de Modelos (Model Context Protocol), hemos creado una interfaz estandarizada que permite a los modelos de IA acceder y analizar la información en cadena en múltiples redes compatibles con EVM.

Esta base técnica abre numerosas posibilidades para las aplicaciones de blockchain basadas en IA, desde la supervisión automatizada hasta los sistemas inteligentes de análisis y recomendación. Tanto si estás desarrollando agentes para analistas, dApps o automatización interna, esta es tu base: créala una vez y luego amplíala a cualquier ámbito.

Si tienes alguna duda o necesitas ayuda, no dudes en ponerte en contacto con nosotros a través de Discord o Twitter.

Recursos adicionales

Documentación del Protocolo de Contexto de Modelos
Documentación de Viem
Guía de Quicknode Multichain
Especificación JSON-RPC de EVM
Documentación de Claude Desktop
MCP Inspector: una herramienta útil para depurar tu servidor MCP
Consideraciones de seguridad de MCP: consideraciones importantes de seguridad a la hora de configurar tu servidor MCP

¡Nos encanta recibir comentarios!

Si tienes algún comentario o sugerencia sobre nuevos temas, no dudes en hacérnoslo saber. Nos encantaría saber tu opinión.

Crear un servidor EVM MCP con Claude AI

Resumen​

Tus funciones​

Lo que necesitarás​

¿Qué es el MCP?​

Conceptos clave​

Cómo funcionan los servidores MCP​

Ejemplo sencillo: cómo consultar el saldo de un monedero​

Ciclo de vida de las solicitudes en el servidor MCP​

Estructura del proyecto​

Punto de entrada: index.ts​

Configuración de la cadena: chains.ts​

Creador del cliente: clients.ts​

Indicaciones: prompts.ts​

Recursos: resources.ts​

Herramientas: tools.ts​

Configura tu servidor EVM MCP​

Obtener un punto final de Multichain​

Instrucciones de configuración​

Paso 1: Clonar el repositorio​

Paso 2: Instalar las dependencias​

Paso 3: Compilar el proyecto​

Paso 4: Configurar Claude Desktop​

Pon a prueba tu servidor MCP​

Análisis de la cartera​

Detección de contratos​

Evaluación de gas​

¿Y ahora qué?​

Ampliar la funcionalidad de EVM​

Desarrollar mejoras específicas para la IA​

Añadir almacenamiento en caché y optimización del rendimiento​

Análisis y uso de las pistas​

Reforzar la seguridad y la estabilidad​

Conclusión​

Recursos adicionales​

¡Nos encanta recibir comentarios!

Resumen

Tus funciones

Lo que necesitarás

¿Qué es el MCP?

Conceptos clave

Cómo funcionan los servidores MCP

Ejemplo sencillo: cómo consultar el saldo de un monedero

Ciclo de vida de las solicitudes en el servidor MCP

Estructura del proyecto

Punto de entrada: `index.ts`

Configuración de la cadena: `chains.ts`

Creador del cliente: `clients.ts`

Indicaciones: `prompts.ts`

Recursos: `resources.ts`

Herramientas: `tools.ts`

Configura tu servidor EVM MCP

Obtener un punto final de Multichain

Instrucciones de configuración

Paso 1: Clonar el repositorio

Paso 2: Instalar las dependencias

Paso 3: Compilar el proyecto

Paso 4: Configurar Claude Desktop

Pon a prueba tu servidor MCP

Análisis de la cartera

Detección de contratos

Evaluación de gas

¿Y ahora qué?

Ampliar la funcionalidad de EVM

Desarrollar mejoras específicas para la IA

Añadir almacenamiento en caché y optimización del rendimiento

Análisis y uso de las pistas

Reforzar la seguridad y la estabilidad

Conclusión

Recursos adicionales