Einen EVM-MCP-Server mit Claude AI erstellen

14 Minuten Lesezeit

Übersicht

Das Model Context Protocol (MCP) ermöglicht es großen Sprachmodellen (LLMs), mithilfe eines standardisierten, nachrichtenbasierten Protokolls mit externen Tools – wie HTTP-APIs, Dateien oder sogar Blockchains – zu interagieren. Man kann es sich als eine Schnittstelle zum „Aufrufen von Funktionen“ vorstellen, an die sich Agenten wie Claude oder Cursor anbinden können, um ein Skript oder einen Dienst in eine KI-native Erweiterung zu verwandeln.

In diesem Leitfaden erfahren Sie, wie Sie einen MCP-Server einrichten und bereitstellen, der es LLM-Agenten ermöglicht, auf Blockchain-Daten in mehreren EVM-kompatiblen Netzwerken zuzugreifen. Diese leistungsstarke Integration ermöglicht es KI-Modellen wie Claude, direkt mit Blockchain-Daten zu interagieren, was neue Möglichkeiten für die Automatisierung und Analyse im Web3 eröffnet.

Ihre Aufgaben

Einrichten eines MCP-Servers, der mit mehreren EVM-Chains interagiert
Ermöglichen Sie LLMs den Zugriff auf On-Chain-Daten mithilfe von Viem und dem Multichain-RPC von Quicknode
Werkzeuge, Anweisungen und Ressourcen registrieren, um das Verhalten von LLMs zu steuern
Starten Sie den Server in Claude Desktop und testen Sie ihn mit Anfragen in natürlicher Sprache.

Was Sie benötigen

Node.js v20 oder höher
Ein kostenloses Quicknode -Konto
Claude Desktop (oder ein kompatibler Agent-Runner)
Erfahrung mit der Ethereum-Blockchain

Was ist MCP?

Das Model Context Protocol (MCP) ist ein offener Standard, der es KI-Agenten ermöglicht, mit externen Tools und Datenquellen zu interagieren. Es schafft einen strukturierten Kommunikationskanal zwischen Sprachmodellen und Tools.

Ohne MCP sind KI-Modelle auf Folgendes beschränkt:

Inhalt der Schulung
Das Gespräch, das sie gerade führen
Keine Möglichkeit, externe Datenquellen zu überprüfen
Es gibt keine Möglichkeit, Handlungen in der realen Welt auszuführen

MCP schließt diese Lücke, indem es standardisierte Verfahren schafft, über die KI auf externe Tools und Daten zugreifen kann.

Übergeordnete Architektur Quelle (angepasst an den Server, den wir entwickeln): Model Context Protocol

Zentrale Konzepte

So funktionieren MCP-Server

MCP-Server sind dafür zuständig, eingehende Anfragen vom Client zu bearbeiten und die entsprechenden Daten zurückzugeben. Sie nutzen das MCP-Protokoll zur Kommunikation mit dem LLM und können in jeder Programmiersprache oder jedem Framework implementiert werden.

Jeder Server kommuniziert über Standardkanäle (stdio, HTTP oder Sockets) mit dem LLM und gibt eine gut strukturierte Ausgabe zurück. Dadurch kann das LLM den Kontext und die Absicht der Anfrage verstehen und entsprechend reagieren. Das MCP-Protokoll ist so konzipiert, dass es erweiterbar ist, sodass Entwickler bei Bedarf neue Tools, Ressourcen und Eingabeaufforderungen hinzufügen können.

Tools: Funktionen, die die KI aufrufen kann, um bestimmte Aktionen auszuführen. Dabei kann es sich um alles Mögliche handeln – von einem einfachen API-Aufruf bis hin zu einer komplexen Aufgabe.

Beispiel: eth_getBalance um den Kontostand einer Wallet zu überprüfen
Beispiel: Wettervorhersage um aktuelle Wetterdaten abzurufen

Ressourcen: Statisches Wissen, auf das die KI zurückgreifen kann. Dies beeinflusst die Verankerung und die Annahmen des Modells – zum Beispiel durch Hinzufügen eines Gas-Referenz Mithilfe dieser Ressource kann Claude feststellen, ob ein Gaspreis für eine bestimmte Blockchain niedrig, durchschnittlich oder hoch ist, ohne ein Tool aufrufen zu müssen.

Beispiel: Angaben zu den Benzinpreisen einer bestimmten Tankstellenkette
Beispiel: Dokumentation zu API-Parametern

Prompts: Vorab verfasste Anweisungen, die der KI als Leitfaden dienen. Sie fungieren als wiederverwendbare Denkvorlagen. Jeder Prompt legt fest, wie das LLM eine Aufgabe (z. B. „Analysiere diese Geldbörse“) mithilfe von Werkzeugen und strukturiertem Denken angehen soll.

Beispiel: Vorlagen zur Analyse der Wallet-Aktivitäten
Beispiel: Schritt-für-Schritt-Anleitungen zur Durchführung komplexer Aufgaben

Wenn Sie einen MCP-Server mit einer KI wie Claude verbinden:

Die KI ermittelt, welche Tools, Ressourcen und Eingabeaufforderungen verfügbar sind
Bei Bedarf kann die KI diese Tools mit bestimmten Parametern aufrufen
Der Server verarbeitet diese Anfragen und gibt strukturierte Daten zurück
Die KI wertet die Ergebnisse aus und lässt sie in ihre Antwort einfließen

So sieht der Ablauf derselben Benutzeranfrage mit und ohne MCP-Server aus:

Einfaches Beispiel: Den Kontostand einer Wallet überprüfen

	Ohne MCP	Mit MCP
Benutzer	„Wie hoch ist der Kontostand von 0x123...?“	„Wie hoch ist der Kontostand von 0x123...?“
KI-Prozess	Kein Zugriff auf externe Daten	[Ruft das Tool „eth_getBalance“ über MCP auf]
KI-Antwort	„Ich habe keinen Zugriff auf aktuelle Blockchain-Daten, daher kann ich den Kontostand dieser Wallet nicht überprüfen.“	„In dieser Wallet befinden sich derzeit 0,45 ETH auf Ethereum.“
Ergebnis	❌ Die Anfrage des Benutzers kann nicht erfüllt werden	✅ Bereitstellung von Blockchain-Daten in Echtzeit

Anfrage-Lebenszyklus auf dem MCP-Server

Folgendes geschieht, wenn der Agent über eine Eingabeaufforderung eine Anfrage stellt:

Analysiert die Anfrage, um die Aktion und die Parameter zu ermitteln
Überprüft die Parameter
Wählt den passenden Chain-Client aus
Führt die Anfrage über Viem an Quicknode aus
Formatiert die Antwort und gibt sie an den Agenten zurück

MCP-Server-Ablauf

Wir haben gelernt, wie MCP-Server funktionieren. Jetzt bauen wir einen!

Projektstruktur

Die Projektstruktur sieht wie folgt aus:

evm-mcp-server/
├── index.ts              # Einstiegspunkt, richtet den MCP-Server ein
├── chains.ts             # Chain-Konfiguration + Zuordnung der Quicknode-Endpunkte
├── clients.ts            # Viem-Client-Generator für den öffentlichen Client
├── package.json          # Abhängigkeiten und Skripte
├── prompts.ts            # LLM-Prompt-Definitionen
├── resources.ts          # Externe Referenzen (Gaspreise, Explorer)
├── tools.ts              # MCP-Tools: getCode, getBalance, gasPrice
└── tsconfig.json         # TypeScript-Konfiguration

Schauen wir uns zunächst die einzelnen Dateien und ihren Zweck an. Wenn Sie jedoch direkt zum Code springen möchten, können Sie gerne zum Abschnitt „Erstellen Sie Ihren eigenen EVM-MCP-Server“ weiterblättern.

Projektcode

Der gesamte Code für diese Anleitung ist im Quicknode-GitHub-Repository zu finden. Hier erklären wir Ihnen anhand eines allgemeinen Überblicks über den Code, wie alles funktioniert, aber im Abschnitt „Erstellen Sie Ihren eigenen MCP-Server“ werden wir das GitHub-Repository nutzen.

Einstiegspunkt: `index.ts`

Diese Datei ist der Einstiegspunkt, über den der MCP-Server initialisiert und gestartet wird. Sie registriert Tools, Eingabeaufforderungen und Ressourcen:

Ein Ausschnitt aus der Datei „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)
})

Kettenkonfiguration: `chains.ts`

Diese Datei definiert die Blockchain-Konfiguration und erstellt RPC-URLs auf Basis des Multichain-Formats von Quicknode.

Ein Ausschnitt aus der Datei „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...

Client Creator: `clients.ts`

Diese Datei erstellt für jede Kette Clients mithilfe der createPublicClient Funktion aus der Viem Bibliothek zum Herstellen einer Verbindung zur Blockchain über Quicknode-RPC-Endpunkte.

Ein Ausschnitt aus der Datei „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
}

Eingabeaufforderungen: `prompts.ts`

Diese Datei definiert Prompts, die von LLM-Agenten verwendet werden sollen. Das Prompt-Objekt enthält die Beschreibung und Nachrichten Eigenschaften, die vom MCP-Server zur Generierung der Eingabeaufforderung verwendet werden. Die Eingabeaufforderungen enthalten Anweisungen zum Aufrufen von Tools, zur Interpretation von Ergebnissen und zur Formatierung von Antworten.

Ein Ausschnitt aus der Datei „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...

Quellen: `resources.ts`

Diese Datei definiert externe Referenzen, auf die LLM-Agenten zugreifen können. In diesem Fall gewähren wir ihnen Zugriff auf die Gaspreisniveaus der einzelnen Blockchains, Links zu Block-Explorern für jede Blockchain sowie einige Details zu den Blockchains selbst.

Ein Ausschnitt aus der Datei „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...

Werkzeuge: `tools.ts`

Diese Datei definiert die Tools, die der Server aufrufen kann. In diesem Fall verwenden wir das eth_getBalance, eth_getCode, und eth_gasPrice Tools. Jedes Tool ist eine asynchrone Funktion, die über Viem Abfragen an die Blockchain sendet und strukturierte Daten für die Verwendung durch LLMs zurückgibt.

Ein Ausschnitt aus der Datei „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...

Richten Sie Ihren EVM-MCP-Server ein

Wir haben gelernt, welche Funktion die einzelnen Dateien auf dem MCP-Server erfüllen. Nun wollen wir unseren Server erstellen und starten.

Multichain-Endpunkt abrufen

Der MCP-Server, den wir gerade aufbauen, wird mehrere EVM-Chains unterstützen (Ethereum, Base, Arbitrum, Avalanche und BSC). Durch die Nutzung des Multichain-Formats von Quicknode können wir über einen einzigen Endpunkt problemlos eine Verbindung zu diesen Chains herstellen. Falls Sie noch kein Quicknode-Konto haben, können Sie hier ein kostenloses Konto erstellen.

Melden Sie sich bei Ihrem Quicknode-Konto an.
Wechseln Sie zur Registerkarte „Endpunkte“.
Klicken Sie auf „Endpunkt erstellen“.
Wählen Sie das Ethereum-Mainnet oder eine der anderen EVM-Chains aus.
Nachdem der Endpunkt erstellt wurde, aktivieren Sie das Multichain-Format.
Notieren Sie sich die URL Ihres Endpunkts, die etwa so aussehen wird: https://{endpoint_name}.quiknode.pro/{token_id}/ oder https://{endpoint_name}.{chain_name}.quiknode.pro/{token_id}.
Extrahieren Sie den Endpunktnamen und die Token-ID aus der URL.

Dank des Multichain-Formats können wir nun über einen einzigen Endpunkt eine Verbindung zu jeder beliebigen EVM-Chain herstellen. Der Endpunktname und die Token-ID dienen zur Identifizierung der Chain und ihrer Konfiguration.

Quicknode-Multichain-Endpunkt

Einrichtungsanleitung

Da wir nun unseren Endpunkt haben, richten wir unseren MCP-Server ein.

Schritt 1: Das Repository klonen

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

Schritt 2: Abhängigkeiten installieren

npm installieren

Dadurch werden die für das Projekt erforderlichen Abhängigkeiten installiert:

@modelcontextprotocol/sdk: Ein TypeScript-SDK zum Erstellen von MCP-Servern.
viem: Eine TypeScript-Bibliothek für die Interaktion mit EVM-Blockchains.
zod: Eine TypeScript-Bibliothek zum Definieren von Schemata und zum Validieren von Daten.
typescript: Ein TypeScript-Compiler.
@types/node: TypeScript-Typdefinitionen für Node.js.

Schritt 3: Das Projekt erstellen

npm npm build ausführen

Dadurch wird die build/ Verzeichnis, das die kompilierten index.js Datei, die als Einstiegspunkt für den Server dient.

Schritt 4: Claude Desktop konfigurieren

Der Server verwendet Umgebungsvariablen, die in der Konfigurationsdatei von Claude Desktop definiert sind (claude_desktop_config.json), um eine Verbindung zu Quicknode herzustellen und den Server zu starten.

Öffnen Sie Claude Desktop und navigieren Sie zu „Claude > Einstellungen > Entwickler“.
Bearbeiten claude_desktop_config.json um Folgendes aufzunehmen (unter mcpServers (falls andere Konfigurationen vorhanden sind):

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

Ersetzen Sie „your-quicknode-endpoint-name“ durch den Namen Ihres Quicknode-Endpunkts.
Ersetzen Sie „your-quicknode-token-id“ durch Ihre Quicknode-Token-ID.
Ersetzen Sie „/absolute-path-to“ durch den absoluten Pfad zum Projektverzeichnis (z. B. /Users/username/qn-guide-examples/AI/evm-mcp-server).

Speichern Sie die Datei und starten Sie Claude Desktop neu. Die Tools, Ressourcen und Eingabeaufforderungen Ihres MCP-Servers sollten nun in Claude verfügbar sein.

Werkzeuge

Testen Sie Ihren MCP-Server

Fangen wir damit an, Fragen zu stellen, um herauszufinden, wie der Server funktioniert.

Wallet-Analyse

Verwenden Sie die folgende Eingabeaufforderung oder nutzen Sie unsere vorgefertigten Eingabeaufforderungen, um Claude dabei zu unterstützen, den Kontostand und den Kontext einer Wallet zu analysieren:

Gib den Kontostand 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 auf Ethereum an

Oder bitten Sie Claude, den Kontostand einer Wallet über alle unterstützten Blockchains hinweg zu analysieren:

Geben Sie die Adresse 0xd8dA6BF26964aF9D7eEd9e03E53415D37aA96045 in allen von Ihnen unterstützten Netzwerken an.

Vitalik Balance – Alle Netzwerke

Claude wird:

Rufen Sie die eth_getBalance Werkzeug
Gib eine Antwort entsprechend der Eingabeaufforderung zurück

Beachten Sie, dass Claude die eth_getBalance Tool nur für die von ihm unterstützten Ketten, dank der unterstützte-Ketten Ressource.

Vertragserkennung

Verwenden Sie die folgende Eingabeaufforderung oder nutzen Sie unsere vorgefertigten Eingabeaufforderungen, um Claude dabei zu unterstützen, festzustellen, ob es sich bei einer Wallet um einen Vertrag handelt:

Um welche Art von Vertrag handelt es sich bei 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2?

Claude wird:

Erkennen, dass es sich um einen Vertrag handelt (anhand des Vorhandenseins von Bytecode)
Erläutern Sie, ob es sich um einen bekannten Vertrag handelt (unter Verwendung einer Quelle oder historischer Daten).

Gasauswertung

Verwenden Sie die folgende Eingabeaufforderung oder nutzen Sie unsere vorgefertigten Eingabeaufforderungen, um Claude dabei zu unterstützen, den Gaspreis im Ethereum-Netzwerk zu bewerten:

Analysiere die aktuelle Gasgebühr auf Ethereum. Ist jetzt ein guter Zeitpunkt für eine Transaktion?

Claude wird:

Rufen Sie die eth_gasPrice Tool zum Abrufen des aktuellen Gaspreises von Quicknode
Siehe Gas-Referenz die von Ihnen bereitgestellte Quelle, die Schwellenwerte für niedrige, durchschnittliche, hohe und sehr hohe Gaspreise pro Blockchain enthält
Vergleichen Sie die Echtzeit-Gasdaten mit diesen Referenzwerten
Eine kontextbezogene Antwort liefern, aus der hervorgeht, ob es ein guter Zeitpunkt für die Transaktion ist

Benzinpreis

Herzlichen Glückwunsch! Sie haben Ihr eigenes, auf einem LLM basierendes Tool zur Analyse von Blockchain-Daten entwickelt. Jetzt können Sie Claude nutzen, um Blockchain-Daten zu analysieren und mit ihnen zu interagieren, wodurch Sie intelligente Anwendungen entwickeln und Prozesse automatisieren können.

Wie geht es weiter?

Sobald Ihr EVM MCP-Server betriebsbereit ist, gibt es zahlreiche Möglichkeiten, seine Funktionen zu erweitern und seine Integration in KI-Workflows zu vertiefen. Im Folgenden finden Sie einige Bereiche, die Sie näher betrachten können:

Erweiterung der EVM-Funktionalität

Fügen Sie weitere native EVM-Methoden hinzu, um die Funktionsmöglichkeiten des Servers zu erweitern:

eth_getLogs: Überwachung von Vertragsereignissen, wie beispielsweise Token-Übertragungen oder DAO-Abstimmungen
eth_call: Daten aus Smart Contracts auslesen (z. B. Token-Guthaben, Konfigurationen)
eth_blockNumber: Den neuesten Block abrufen, um den Zustand bzw. Status der Blockchain zu überwachen
eth_getTransactionByHash: Bestimmte Transaktionen analysieren

KI-spezifische Verbesserungen entwickeln

LLM-Agenten sind umso nützlicher, je mehr sie durch fachspezifisches Denken und Kontext angeleitet werden. Bedenken Sie Folgendes:

Spezifische Vorgaben: Erstellen Sie aufgabenspezifische Anweisungen für die DeFi-Analyse, die Vertragsprüfung, die Wallet-Profilierung usw.
ENS-Unterstützung: Entschlossenheit .eth Domainnamen für eine bessere Benutzererfahrung
Auswertung von ERC20-Token- und NFT-Daten: Verwenden Sie das „Token and NFT API v2“-Paket, um Token-Guthaben, NFT-Metadaten und mehr abzurufen
Echtzeit-Kursdaten: Integrieren Sie Token-Kurse mithilfe eines Quicknode-Marketplace-Add-ons, beispielsweise der DEX Aggregator Trading API
Handelsfunktionen: Wenn Sie über reine Leseabfragen hinausgehen möchten, lesen Sie unseren Leitfaden „Erstellen eines Telegram-Handelsbots auf Base “. Stellen Sie sich vor, Sie könnten MCP-Prompts mit Handelsaktionen kombinieren, um autonome Handelsagenten zu erstellen.
Benutzerdefinierte Agenten: Kombinieren Sie MCP mit LangChain, AutoGen oder CrewAI, um vollständig autonome Agenten mit Gedächtnis, Planungsfähigkeit und Blockchain-Zugriff zu erstellen
Entdecken Sie die Multi-Chain-Erweiterung: Möchten Sie neben EVM-Chains auch Solana unterstützen? Folgen Sie unserer Anleitung „So richten Sie einen Solana-MCP-Server für die LLM-Integration ein“, um die Reichweite Ihres Agenten über verschiedene Ökosysteme hinweg zu erweitern.

Caching und Leistungsoptimierung hinzufügen

Bei häufig abgefragten Daten kann das Caching die Latenz verringern und wiederholte RPC-Aufrufe vermeiden:

Verwendung Redis, SQLite, oder einfache dateibasierte Caches für eth_getBalance und eth_gasPrice
Legen Sie für jede Kette/Methode TTL -Werte (Time-To-Live) fest, um die Aktualität sicherzustellen
Verwenden Sie Memoization-Muster oder benutzerdefinierte Wrapper, um doppelte Viem-Aufrufe pro Durchlauf zu vermeiden.

Analysen und Nutzung nachverfolgen

Verstehen Sie, wie Ihre Tools genutzt werden:

Eingehende Werkzeugaufrufe protokollieren und zur Verwendung auffordern
Überwachen, welche Ketten am häufigsten abgefragt werden
Grundlegende Nutzungskennzahlen hinzufügen (z. B. Volumen pro Kette, Latenz pro Tool)

Diese Daten können als Orientierung für künftige Verbesserungen dienen, beispielsweise bei der Optimierung von Prompt-Vorlagen oder der Skalierung der Infrastruktur.

Sicherheit und Stabilität stärken

Da MCP-Server Eingaben von Agenten entgegennehmen, ist es wichtig, die Angriffsfläche abzusichern:

Verwenden Sie Zod-Schemas, um alle Eingaben streng zu validieren und zu bereinigen
Lesen Sie die MCP-Sicherheitshinweise, um eine Eingabe von Befehlen über die Eingabeaufforderung oder Missbrauch zu verhindern.
Erwägen Sie eine Ratenbegrenzung oder das Hinzufügen von Authentifizierungsebenen, wenn Sie den MCP-Server öffentlich zugänglich machen.

Fazit

Der EVM-MCP-Server bildet eine leistungsstarke Brücke zwischen LLM-Agenten und Blockchain-Daten. Durch die Implementierung des Model Context Protocol haben wir eine standardisierte Schnittstelle geschaffen, die es KI-Modellen ermöglicht, auf On-Chain-Informationen in mehreren EVM-kompatiblen Netzwerken zuzugreifen und diese zu analysieren.

Diese technische Grundlage eröffnet zahlreiche Möglichkeiten für KI-gestützte Blockchain-Anwendungen, von der automatisierten Überwachung bis hin zu intelligenten Analyse- und Empfehlungssystemen. Ganz gleich, ob Sie Tools für Analysten, dApps oder interne Automatisierungslösungen entwickeln – dies ist Ihre Grundlage: Einmal entwickeln, dann überall erweitern.

Wenn du Fragen hast oder Hilfe benötigst, kannst du dich gerne über Discord oder Twitter an uns wenden.

Weitere Ressourcen

Dokumentation zum Model Context Protocol
Viem-Dokumentation
Quicknode-Leitfaden für Multichain
EVM-JSON-RPC-Spezifikation
Claude Desktop – Dokumentation
MCP Inspector – Ein nützliches Tool zur Fehlerbehebung auf Ihrem MCP-Server
Sicherheitshinweise zu MCP – Wichtige Sicherheitshinweise beim Einrichten Ihres MCP-Servers

Wir ❤️ Feedback!

Teilen Sie uns gerne mit, wenn Sie Feedback oder Vorschläge für neue Themen haben. Wir freuen uns auf Ihre Rückmeldung.

Erstellen Sie einen EVM-MCP-Server mit Claude AI

Übersicht​

Ihre Aufgaben​

Was Sie benötigen​

Was ist MCP?​

Zentrale Konzepte​

So funktionieren MCP-Server​

Einfaches Beispiel: Den Kontostand einer Wallet überprüfen​

Anfrage-Lebenszyklus auf dem MCP-Server​

Projektstruktur​

Einstiegspunkt: index.ts​

Kettenkonfiguration: chains.ts​

Client Creator: clients.ts​

Eingabeaufforderungen: prompts.ts​

Quellen: resources.ts​

Werkzeuge: tools.ts​

Richten Sie Ihren EVM-MCP-Server ein​

Multichain-Endpunkt abrufen​

Einrichtungsanleitung​

Schritt 1: Das Repository klonen​

Schritt 2: Abhängigkeiten installieren​

Schritt 3: Das Projekt erstellen​

Schritt 4: Claude Desktop konfigurieren​

Testen Sie Ihren MCP-Server​

Wallet-Analyse​

Vertragserkennung​

Gasauswertung​

Wie geht es weiter?​

Erweiterung der EVM-Funktionalität​

KI-spezifische Verbesserungen entwickeln​

Caching und Leistungsoptimierung hinzufügen​

Analysen und Nutzung nachverfolgen​

Sicherheit und Stabilität stärken​

Fazit​

Weitere Ressourcen​

Wir ❤️ Feedback!

Übersicht

Ihre Aufgaben

Was Sie benötigen

Was ist MCP?

Zentrale Konzepte

So funktionieren MCP-Server

Einfaches Beispiel: Den Kontostand einer Wallet überprüfen

Anfrage-Lebenszyklus auf dem MCP-Server

Projektstruktur

Einstiegspunkt: `index.ts`

Kettenkonfiguration: `chains.ts`

Client Creator: `clients.ts`

Eingabeaufforderungen: `prompts.ts`

Quellen: `resources.ts`

Werkzeuge: `tools.ts`

Richten Sie Ihren EVM-MCP-Server ein

Multichain-Endpunkt abrufen

Einrichtungsanleitung

Schritt 1: Das Repository klonen

Schritt 2: Abhängigkeiten installieren

Schritt 3: Das Projekt erstellen

Schritt 4: Claude Desktop konfigurieren

Testen Sie Ihren MCP-Server

Wallet-Analyse

Vertragserkennung

Gasauswertung

Wie geht es weiter?

Erweiterung der EVM-Funktionalität

KI-spezifische Verbesserungen entwickeln

Caching und Leistungsoptimierung hinzufügen

Analysen und Nutzung nachverfolgen

Sicherheit und Stabilität stärken

Fazit

Weitere Ressourcen