Créer un serveur EVM MCP avec Claude AI

14 minutes de lecture

Aperçu

Le protocole MCP (Model Context Protocol) permet aux grands modèles linguistiques (LLM) d’interagir avec des outils externes — tels que des API HTTP, des fichiers ou même des blockchains — à l’aide d’un protocole standardisé basé sur des messages. On peut le considérer comme une interface d’« appel de fonction » à laquelle des agents tels que Claude ou Cursor peuvent se connecter, transformant ainsi un script ou un service en une extension native de l’IA.

Dans ce guide, vous apprendrez à créer et à déployer un serveur MCP permettant aux agents LLM d'accéder aux données de la blockchain sur plusieurs réseaux compatibles EVM. Cette intégration puissante permet à des modèles d'IA tels que Claude d'interagir directement avec les données de la blockchain, ouvrant ainsi de nouvelles perspectives en matière d'automatisation et d'analyse du Web3.

Ce que vous ferez

Mettre en place un serveur MCP capable d'interagir avec plusieurs chaînes EVM
Permettre aux modèles de langage de grande envergure (LLM) d'accéder aux données sur la blockchain grâce à Viem et au RPC multichaîne de Quicknode
Enregistrer des outils, des consignes et des ressources pour orienter le comportement des modèles de langage de grande envergure (LLM)
Lancez le serveur dans Claude Desktop et testez-le à l'aide de requêtes en langage naturel

Ce dont vous aurez besoin

Node.js v20 ou version ultérieure
Un compte Quicknode gratuit
Claude Desktop (ou un exécuteur d'agents compatible)
Expérience avec la blockchain Ethereum

Qu'est-ce que le MCP ?

Le Model Context Protocol (MCP) est une norme ouverte qui permet aux agents d'IA d'interagir avec des outils et des sources de données externes. Il établit un canal de communication structuré entre les modèles linguistiques et les outils.

Sans le MCP, les modèles d'IA sont limités à :

Les informations sur lesquelles leur formation portait
La conversation qu'ils ont en ce moment
Impossibilité de vérifier des sources de données externes
Impossible d'effectuer des actions dans le monde réel

MCP comble cette lacune en mettant en place des méthodes standardisées permettant à l'IA d'accéder à des outils et à des données externes.

Architecture de haut niveau Source (adaptée au serveur que nous développons) : Protocol de contexte de modèle

Concepts clés

Fonctionnement des serveurs MCP

Les serveurs MCP sont chargés de traiter les requêtes entrantes provenant du client et de renvoyer les données appropriées. Ils utilisent le protocole MCP pour communiquer avec le LLM et peuvent être implémentés dans n'importe quel langage de programmation ou framework.

Chaque serveur communique avec le LLM via des canaux standard (stdio, HTTP ou sockets) et renvoie une sortie bien structurée. Cela permet au LLM de comprendre le contexte et l'intention de la requête, et d'y répondre de manière appropriée. Le protocole MCP est conçu pour être extensible, ce qui permet aux développeurs d'ajouter de nouveaux outils, ressources et invites selon leurs besoins.

Outils: fonctions que l'IA peut appeler pour effectuer des actions spécifiques. Il peut s'agir aussi bien d'un simple appel d'API que d'une tâche complexe.

Exemple : eth_getBalance pour vérifier le solde d'un portefeuille
Exemple : prévisions_météo pour obtenir les données météorologiques actuelles

Ressources: Connaissances statiques auxquelles l'IA peut se référer. Celles-ci influencent le cadre de référence et les hypothèses du modèle — par exemple, l'ajout d'un référence-gaz Cette ressource permet à Claude de savoir si le prix du gaz est bas, moyen ou élevé pour une chaîne spécifique, sans avoir à faire appel à aucun outil.

Exemple : informations sur les prix de l'essence dans une chaîne spécifique
Exemple : documentation sur les paramètres de l'API

Consignes: instructions pré-rédigées qui guident l'IA. Elles font office de modèles réutilisables pour la réflexion. Chaque consigne définit la manière dont le LLM doit aborder une tâche (par exemple, « analyser ce portefeuille ») à l'aide d'outils et d'un raisonnement structuré.

Exemple : modèles d'analyse de l'activité d'un portefeuille
Exemple : guides étape par étape pour réaliser des tâches complexes

Lorsque vous connectez un serveur MCP à une IA telle que Claude :

L'IA identifie les outils, les ressources et les consignes disponibles
Si nécessaire, l'IA peut lancer ces outils en leur attribuant des paramètres spécifiques
Le serveur traite ces requêtes et renvoie des données structurées
L'IA interprète les résultats et les intègre dans sa réponse

Voici comment se déroule la même requête utilisateur avec et sans serveur MCP :

Exemple simple : vérifier le solde d'un portefeuille

	Sans MCP	Avec MCP
Utilisateur	« Quel est le solde du portefeuille 0x123... ? »	« Quel est le solde du portefeuille 0x123... ? »
Processus d'IA	Pas d'accès aux données externes	[Appel de l'outil eth_getBalance via MCP]
Réponse générée par l'IA	« Je n'ai pas accès aux données actuelles de la blockchain, je ne peux donc pas vérifier le solde de ce portefeuille. »	« Ce portefeuille contient actuellement 0,45 ETH sur Ethereum. »
Résultat	❌ La demande de l'utilisateur ne peut pas être satisfaite	✅ Fourniture de données blockchain en temps réel

Cycle de vie des requêtes sur le serveur MCP

Voici ce qui se passe lorsque l'agent effectue une requête via une invite :

Analyse la requête pour déterminer l'action et les paramètres
Vérifie la validité des paramètres
Sélectionne le client de chaîne approprié
Exécute la requête via Viem vers Quicknode
Mette en forme la réponse et la renvoie à l'agent

Flux du serveur MCP

Nous avons découvert le fonctionnement des serveurs MCP. Maintenant, créons-en un !

Structure du projet

La structure du projet est la suivante :

evm-mcp-server/
├── index.ts              # Point d'entrée, configure le serveur MCP
├── chains.ts             # Configuration de la chaîne + mappage des points de terminaison Quicknode
├── clients.ts            # Créateur de client public Viem
├── package.json          # Dépendances et scripts
├── prompts.ts            # Définitions des invites LLM
├── resources.ts          # Références externes (prix du gaz, explorateurs)
├── tools.ts              # Outils MCP : getCode, getBalance, gasPrice
└── tsconfig.json         # Configuration TypeScript

Commençons par examiner chaque fichier et sa fonction. Toutefois, si vous souhaitez passer directement au code, n'hésitez pas à passer à la section « Créer votre serveur EVM MCP ».

Code du projet

Tout le code de ce guide est disponible dans le dépôt GitHub de Quicknode. Nous vous expliquons ici le fonctionnement du système en vous donnant un aperçu général du code, mais nous utiliserons le dépôt GitHub dans la section « Créer votre serveur MCP ».

Point d'entrée : `index.ts`

Ce fichier constitue le point d'entrée qui initialise et lance le serveur MCP. Il enregistre les outils, les invites et les ressources :

Extrait du fichier 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)
})

Configuration de la chaîne : `chains.ts`

Ce fichier définit la configuration de la blockchain et génère des URL RPC selon le format multichain de Quicknode.

Extrait du fichier 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...

Créateur du client : `clients.ts`

Ce fichier crée des clients pour chaque chaîne à l'aide du createPublicClient fonction à partir de la Viem bibliothèque permettant d'établir une connexion à la chaîne à l'aide des points de terminaison RPC de Quicknode.

Extrait du fichier 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
}

Consignes : `prompts.ts`

Ce fichier définit les invites destinées aux agents LLM. L'objet « prompt » contient le description et messages propriétés utilisées par le serveur MCP pour générer l'invite. Les invites contiennent des instructions permettant d'appeler des outils, d'interpréter les résultats et de mettre en forme les réponses.

Extrait du fichier 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...

Ressources : `resources.ts`

Ce fichier définit les références externes pouvant être utilisées par les agents LLM. Dans ce cas précis, nous leur donnons accès aux niveaux de prix du gaz pour chaque chaîne, aux liens vers les explorateurs de blocs de chaque chaîne, ainsi qu'à certaines informations sur les chaînes elles-mêmes.

Extrait du fichier 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...

Outils : `tools.ts`

Ce fichier définit les outils que le serveur peut appeler. Dans ce cas précis, nous utilisons le eth_getBalance, eth_getCode, et eth_gasPrice outils. Chaque outil est une fonction asynchrone qui interroge la blockchain via Viem et renvoie des données structurées destinées à être utilisées par un modèle de langage de grande envergure (LLM).

Extrait du fichier 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...

Configurez votre serveur EVM MCP

Nous avons vu quel rôle joue chaque fichier au sein du serveur MCP. Passons maintenant à la compilation et à l'exécution de notre serveur.

Obtenir un point de terminaison Multichain

Le serveur MCP que nous développons prendra en charge plusieurs chaînes EVM (Ethereum, Base, Arbitrum, Avalanche et BSC). En tirant parti du format multichaîne de Quicknode, nous pouvons facilement nous connecter à ces chaînes via un seul point de terminaison. Si vous ne disposez pas d'un compte Quicknode, vous pouvez en créer un gratuitement ici.

Connectez-vous à votre compte Quicknode.
Accédez à l'onglet « Endpoints ».
Cliquez sur « Créer un point de terminaison ».
Sélectionnez le réseau principal Ethereum ou l'une des autres chaînes EVM.
Une fois le point de terminaison créé, activez le format multichaîne.
Notez l'URL de votre point de terminaison, qui ressemblera à ceci : https://{endpoint_name}.quiknode.pro/{token_id}/ ou https://{endpoint_name}.{chain_name}.quiknode.pro/{token_id}.
Extrayez le nom du point de terminaison et l'identifiant du jeton de l'URL.

Grâce au format multichaîne, nous pouvons désormais nous connecter à n'importe quelle chaîne EVM à l'aide d'un seul point de terminaison. Le nom du point de terminaison et l'identifiant du jeton permettent d'identifier la chaîne et sa configuration.

Point de terminaison Quicknode Multichain

Instructions d'installation

Maintenant que nous avons notre point de terminaison, configurons notre serveur MCP.

Étape 1 : Cloner le dépôt

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

Étape 2 : Installer les dépendances

npm installer

Cela permettra d'installer les dépendances nécessaires au projet :

@modelcontextprotocol/sdk: un SDK TypeScript permettant de créer des serveurs MCP.
viem: une bibliothèque TypeScript permettant d'interagir avec les blockchains EVM.
zod: une bibliothèque TypeScript permettant de définir des schémas et de valider des données.
typescript: un compilateur TypeScript.
@types/node: définitions de types TypeScript pour Node.js.

Étape 3 : Compiler le projet

npm exécuter la compilation

Cela génère le build/ répertoire contenant le fichier compilé index.js fichier, qui sert de point d'entrée au serveur.

Étape 4 : Configurer Claude Desktop

Le serveur utilise les variables d'environnement définies dans le fichier de configuration de Claude Desktop (claude_desktop_config.json) pour se connecter à Quicknode et lancer le serveur.

Ouvrez Claude Desktop, accédez à Claude > Paramètres > Développeur
Modifier claude_desktop_config.json pour inclure ce qui suit (à ajouter sous mcpServers (s'il existe d'autres configurations) :

{
	"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"
			}
		}
	}
}

Remplacez « your-quicknode-endpoint-name » par le nom de votre point de terminaison Quicknode.
Remplacez « your-quicknode-token-id » par l'identifiant de votre jeton Quicknode.
Remplacez /absolute-path-to par le chemin d'accès absolu au répertoire du projet (par exemple, /Users/username/qn-guide-examples/AI/evm-mcp-server).

Enregistrez le fichier et redémarrez Claude Desktop. Les outils, ressources et invites de votre serveur MCP devraient désormais être disponibles dans Claude.

Outils

Testez votre serveur MCP

Commençons par poser quelques questions pour comprendre comment fonctionne le serveur.

Analyse du portefeuille

Utilisez la consigne suivante ou nos consignes prédéfinies pour aider Claude à analyser le solde et le contexte d'un portefeuille :

Afficher le solde de 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 sur Ethereum

Vous pouvez également demander à Claude d'analyser le solde d'un portefeuille sur l'ensemble des chaînes prises en charge :

Indiquez l'adresse 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 sur tous les réseaux que vous prenez en charge.

Vitalik Balance - Tous les réseaux

Claude va :

Appelez le eth_getBalance outil
Renvoyer une réponse en fonction de l'invite

Notez que Claude appellera le eth_getBalance outil ne fonctionne qu'avec les chaînes qu'il prend en charge, grâce à la chaînes prises en charge ressource.

Détection des contrats

Utilisez la consigne suivante ou nos consignes prédéfinies pour aider Claude à déterminer si un portefeuille est un contrat :

De quel type de contrat s'agit-il : 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2 ?

Claude va :

Détecter s'il s'agit d'un contrat (en vérifiant la présence de bytecode)
Précisez s'il s'agit d'un contrat connu (en vous appuyant sur une ressource ou des données historiques)

Évaluation des gisements de gaz

Utilisez la consigne suivante ou nos consignes prédéfinies pour demander à Claude d'évaluer le prix du gaz sur le réseau Ethereum :

Analyser le prix actuel du gaz sur Ethereum. Est-ce le bon moment pour effectuer une transaction ?

Claude va :

Appelez le eth_gasPrice outil permettant de récupérer le prix actuel du gaz depuis Quicknode
Consultez le référence-gaz la ressource que vous avez fournie, qui indique les seuils correspondant aux prix du gaz « bas », « moyens », « élevés » et « très élevés » par chaîne
Comparez les données en temps réel sur les prix du gaz à ces valeurs de référence
Fournir une réponse adaptée au contexte, indiquant s'il s'agit d'un moment propice à la transaction

Prix de l'essence

Félicitations ! Vous venez de créer votre propre outil d'analyse de données blockchain basé sur un LLM. Vous pouvez désormais utiliser Claude pour analyser les données blockchain et interagir avec celles-ci, ce qui vous permettra de développer des applications intelligentes et d'automatiser des processus.

Et maintenant ?

Une fois que votre serveur EVM MCP est opérationnel, il existe de nombreuses façons d'étendre ses capacités et de renforcer son intégration dans les flux de travail d'IA. Voici quelques pistes à explorer :

Étendre les fonctionnalités de l'EVM

Ajoutez d'autres méthodes EVM natives pour étendre les capacités du serveur :

eth_getLogs: Surveiller les événements liés aux contrats, tels que les transferts de jetons ou les votes au sein d'un DAO
eth_call: Lire les données des contrats intelligents (par exemple, les soldes de jetons, les configurations)
eth_blockNumber: Récupérer le dernier bloc pour le suivi de l'état de la chaîne
eth_getTransactionByHash: Analyser des transactions spécifiques

Mettre en place des améliorations spécifiques à l'IA

Les agents LLM gagnent en utilité lorsqu'ils sont guidés par un raisonnement et un contexte propres à un domaine donné. Prenons l'exemple suivant :

Consignes spécialisées: élaborer des instructions spécifiques à chaque tâche pour l'analyse DeFi, l'audit de contrats, le profilage de portefeuilles, etc.
Assistance ENS: Résolution .eth noms de domaine pour une meilleure expérience utilisateur
Exploration des données relatives aux jetons ERC20 et aux NFT: utilisez l'ensemble d'API « Token et NFT v2 » pour récupérer les soldes des jetons, les métadonnées des NFT et bien plus encore
Données de cours en temps réel: intégrez les cours des jetons à l'aide d'un module complémentaire de Quicknode Marketplace, tel que l'API DEX Aggregator Trading.
Fonctionnalités de trading: si vous souhaitez aller au-delà des requêtes en lecture seule, consultez notre guide « Créer un bot de trading Telegram sur Base ». Imaginez pouvoir associer les invites MCP à des actions de trading pour créer des agents de trading autonomes.
Agents personnalisés: associez MCP à LangChain, AutoGen ou CrewAI pour créer des agents entièrement autonomes dotés d'une mémoire, de capacités de planification et d'un accès à la blockchain
Découvrez l'extension multi-chaînes: vous souhaitez prendre en charge Solana en plus des chaînes EVM ? Suivez notre guide « Comment créer un serveur MCP Solana pour l'intégration d'un LLM » afin d'étendre la portée de votre agent à l'ensemble des écosystèmes.

Ajouter la mise en cache et l'optimisation des performances

Pour les données fréquemment consultées, la mise en cache permet de réduire la latence et d'éviter les appels RPC répétés :

Utilisation Redis, SQLite, ou de simples caches basés sur des fichiers pour eth_getBalance et eth_gasPrice
Définissez des valeurs TTL (Time-To-Live) pour chaque chaîne/méthode afin de garantir l'actualité des données
Utilisez des techniques de mémorisation ou des wrappers personnalisés pour éviter les appels Viem en double à chaque exécution

Suivi des statistiques et de l'utilisation

Comprenez comment vos outils sont utilisés :

Enregistrer les appels d'outils entrants et afficher des invites d'utilisation
Identifier les chaînes les plus consultées
Ajouter des indicateurs d'utilisation de base (par exemple, volume par chaîne, latence par outil)

Ces données peuvent servir de base à de futures améliorations, telles que l'optimisation des modèles de prompts ou l'extension de l'infrastructure.

Renforcer la sécurité et la stabilité

Étant donné que les serveurs MCP acceptent les entrées provenant des agents, il est important de sécuriser la surface d'exposition :

Utilisez les schémas Zod pour valider et nettoyer rigoureusement toutes les données d'entrée
Lisez les consignes de sécurité MCP afin d'éviter toute injection de prompt ou toute utilisation abusive.
Envisagez de mettre en place une limitation du débit ou d'ajouter des couches d'authentification si vous exposez le serveur MCP au public.

Conclusion

Le serveur EVM MCP constitue une passerelle performante entre les agents LLM et les données de la blockchain. En mettant en œuvre le protocole Model Context Protocol, nous avons créé une interface standardisée qui permet aux modèles d'IA d'accéder aux informations sur la chaîne et de les analyser sur plusieurs réseaux compatibles EVM.

Cette base technique ouvre de nombreuses possibilités pour les applications blockchain basées sur l'IA, allant de la surveillance automatisée aux systèmes d'analyse et de recommandation intelligents. Que vous développiez des agents destinés aux analystes, des dApps ou des solutions d'automatisation internes, voici la base dont vous avez besoin : développez-la une seule fois, puis étendez-la partout.

Si vous avez des questions ou besoin d'aide, n'hésitez pas à nous contacter sur Discord ou Twitter.

Ressources supplémentaires

Documentation du protocole Model Context
Documentation Viem
Guide Quicknode Multichain
Spécification JSON-RPC de l'EVM
Documentation de Claude Desktop
MCP Inspector - Un outil pratique pour le débogage de votre serveur MCP
Considérations relatives à la sécurité du MCP - Considérations importantes en matière de sécurité lors de la mise en place de votre serveur MCP

Nous ❤️ les commentaires !

Faites-nous savoir si vous avez des commentaires ou des suggestions de nouveaux sujets. Nous serions ravis de vous entendre.

Créer un serveur EVM MCP avec Claude AI

Aperçu​

Ce que vous ferez​

Ce dont vous aurez besoin​

Qu'est-ce que le MCP ?​

Concepts clés​

Fonctionnement des serveurs MCP​

Exemple simple : vérifier le solde d'un portefeuille​

Cycle de vie des requêtes sur le serveur MCP​

Structure du projet​

Point d'entrée : index.ts​

Configuration de la chaîne : chains.ts​

Créateur du client : clients.ts​

Consignes : prompts.ts​

Ressources : resources.ts​

Outils : tools.ts​

Configurez votre serveur EVM MCP​

Obtenir un point de terminaison Multichain​

Instructions d'installation​

Étape 1 : Cloner le dépôt​

Étape 2 : Installer les dépendances​

Étape 3 : Compiler le projet​

Étape 4 : Configurer Claude Desktop​

Testez votre serveur MCP​

Analyse du portefeuille​

Détection des contrats​

Évaluation des gisements de gaz​

Et maintenant ?​

Étendre les fonctionnalités de l'EVM​

Mettre en place des améliorations spécifiques à l'IA​

Ajouter la mise en cache et l'optimisation des performances​

Suivi des statistiques et de l'utilisation​

Renforcer la sécurité et la stabilité​

Conclusion​

Ressources supplémentaires​

Nous ❤️ les commentaires !

Aperçu

Ce que vous ferez

Ce dont vous aurez besoin

Qu'est-ce que le MCP ?

Concepts clés

Fonctionnement des serveurs MCP

Exemple simple : vérifier le solde d'un portefeuille

Cycle de vie des requêtes sur le serveur MCP

Structure du projet

Point d'entrée : `index.ts`

Configuration de la chaîne : `chains.ts`

Créateur du client : `clients.ts`

Consignes : `prompts.ts`

Ressources : `resources.ts`

Outils : `tools.ts`

Configurez votre serveur EVM MCP

Obtenir un point de terminaison Multichain

Instructions d'installation

Étape 1 : Cloner le dépôt

Étape 2 : Installer les dépendances

Étape 3 : Compiler le projet

Étape 4 : Configurer Claude Desktop

Testez votre serveur MCP

Analyse du portefeuille

Détection des contrats

Évaluation des gisements de gaz

Et maintenant ?

Étendre les fonctionnalités de l'EVM

Mettre en place des améliorations spécifiques à l'IA

Ajouter la mise en cache et l'optimisation des performances

Suivi des statistiques et de l'utilisation

Renforcer la sécurité et la stabilité

Conclusion

Ressources supplémentaires