29 minutes de lecture

Aperçu

Le Model Context Protocol (MCP) vous permet d'étendre les assistants IA tels que Claude grâce à des outils personnalisés qui interagissent avec des sources de données et des services externes. Dans ce guide, vous allez créer un serveur MCP Solana qui permettra à des outils tels que Claude Desktop (ou Cursor) d’interroger directement la blockchain Solana. Cette intégration permettra à Claude d’effectuer des tâches telles que vérifier les soldes de portefeuilles, consulter les comptes de tokens, récupérer les détails des transactions et analyser les informations de compte, tout en vous laissant le contrôle total de ces interactions. Il existe de nombreux outils performants faisant le lien entre l’IA et Solana, comme Goat SDK et SendAI.fun, mais si vous souhaitez créer le vôtre, ce guide est fait pour vous ! À la fin de ce tutoriel, vous disposerez d’un serveur MCP Solana entièrement fonctionnel que vous pourrez connecter à Claude Desktop, permettant ainsi des interactions transparentes avec la blockchain via le langage naturel :

Ce que vous ferez

• Configurer un serveur Solana MCP à l'aide de TypeScript et du SDK MCP
• Implémenter des fonctionnalités spécifiques à Solana avec Solana Kit
• Testez votre serveur avec Claude Desktop
• Ajouter des fonctionnalités de plus en plus complexes, telles que la récupération des comptes de jetons et les détails des transactions
• Créez des consignes utiles pour guider l'IA dans l'utilisation de vos outils

Ce dont vous aurez besoin

• Connaissances de base en TypeScript
• Expérience avec Solana Basics et Solana Kit
• Node.js
• Claude Desktop est installé sur votre ordinateur
• Un point de terminaison RPC Solana (vous pouvez en obtenir un gratuitement ici)

Dépendance	Version
nœud	>=23.0.0
@modelcontextprotocol/sdk	^1.9.0
@solana/kit	^2.1.0
zod	^3.24.2
Typescript	^5.8.3
Bureau Claude	0.9.2

Comprendre les MCP

Le Model Context Protocol (MCP) est un protocole ouvert qui fait le lien entre les modèles d’IA et les sources de données ou outils externes. Il établit une méthode standardisée permettant aux applications de fournir du contexte aux grands modèles linguistiques (LLM), leur donnant ainsi la possibilité d’accéder à des informations en temps réel et d’effectuer des actions allant au-delà de leurs données d’entraînement. On peut considérer le MCP comme un adaptateur universel qui permet aux modèles d’IA d’interagir en toute sécurité avec diverses sources de données, API et fonctionnalités. Fondamentalement, le MCP repose sur une architecture client-serveur dans laquelle des applications d’IA telles que Claude agissent en tant que clients se connectant à des serveurs MCP. Ces serveurs offrent trois fonctionnalités principales :

• Outils : fonctions que l'IA peut appeler pour effectuer des actions (comme vérifier le solde d'un portefeuille)
• Ressources : données de type fichier pouvant être lues par l'IA (comme des documents)
• Consignes : modèles prédéfinis destinés à guider les interactions de l'IA avec vos outils

Que vous développiez un outil de visualisation de données, un analyseur de code ou une interface vers des systèmes externes, MCP offre un cadre structuré et sécurisé permettant d'étendre les capacités de l'IA. Cela peut s'avérer particulièrement utile pour rendre les données de la blockchain plus accessibles et plus faciles à exploiter.

MCP et Solana

Le protocole Model Context permet une communication sécurisée entre les assistants IA et des services externes tels que Quicknode, facilitant ainsi l'accès aux données de Solana (ou de toute autre blockchain) :

Pour notre MCP Solana, nous nous concentrerons principalement sur les outils utilisant des appels RPC, mais nous mettrons également en place une ressource et quelques invites afin d'illustrer une intégration complète. C'est parti !

Configurer votre environnement

Commençons par créer un nouveau projet et installer les dépendances nécessaires :

mkdir solana-mcp && cd solana-mcp

Initialiser un nouveau projet npm

npm init -y

Installer les dépendances

npm installer @modelcontextprotocol/sdk @solana/kit zod

npm installer --save-dev typescript @types/node

Créer un tsconfig.json fichier contenant la configuration suivante :

{
    "compilerOptions": {
      "target": "ES2022",
      "module": "NodeNext",
      "moduleResolution": "NodeNext",
      "esModuleInterop": true,
      "strict": true,
      "outDir": "./build",
      "rootDir": "./",
      "skipLibCheck": true,
      "forceConsistentCasingInFileNames": true
    },
    "include": ["*.ts", "src/**/*.ts"],
    "exclude": ["node_modules", "build"]
}

Assurez-vous que ces scripts se trouvent dans votre package.json:

"scripts": {
  "build": "tsc",
  "start": "node build/index.js"
}

Créez un nouveau répertoire, src et index.ts fichier qu'il contient :

mkdir src && touch src/index.ts

Configurez votre serveur MCP

Commençons par mettre en place un outil simple qui permettra à notre client de récupérer le solde en SOL d'un portefeuille.

Importer les dépendances

Ouvrir src/index.ts et ajoutez le code suivant :

import {
  McpServer,
} from "@modelcontextprotocol/sdk/server/mcp.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import { z } from "zod";
import {
  createSolanaRpc,
  address,
  isSolanaError,
  assertIsAddress,
  assertIsSignature,
} from "@solana/kit";

Nous importons ici les dépendances nécessaires à la création de notre serveur MCP. Le @modelcontextprotocol/sdk Ce package fournit les fonctionnalités essentielles à la création de serveurs MCP, tandis que @solana/kit fournit des utilitaires permettant de gérer les appels RPC Solana. Nous importons également zod pour la validation du schéma, ce qui permettra au serveur de valider les données d'entrée et de sortie.

Définir des constantes

Ensuite, nous devons définir certaines constantes pour notre serveur. Il s'agit notamment du point de terminaison RPC et des clés du programme SPL. Ajoutez le code suivant à src/index.ts:

const CONFIG = {
  rpcEndpoint:
    process.env.SOLANA_RPC_ENDPOINT || "https://api.mainnet-beta.solana.com",
};
const SPL_PROGRAM_KEYS = {
  TOKEN_PROGRAM: address("TokenkegQfeZyiNwAJbNbGKPFXCWuBvf9Ss623VQ5DA"),
  TOKEN_2022_PROGRAM: address("TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb"),
};

const solanaRpc = createSolanaRpc(CONFIG.rpcEndpoint);

Vous remarquerez que nous faisons référence à des variables d'environnement sans utiliser de bibliothèque telle que dotenv. Le serveur MCP chargera les variables d'environnement telles qu'elles ont été configurées par le client (par exemple, claude_desktop_config.json). Nous nous en occuperons plus tard.

Créer le serveur MCP

Créons maintenant le serveur MCP. Ce serveur traitera les requêtes entrantes provenant du client et y répondra en fournissant les données appropriées. Ajoutez le code suivant à src/index.ts:

const server = new McpServer({
  name: "SolanaMCP",
  version: "1.0.0",
});

Notre nouvelle variable, serveur crée une nouvelle instance de la McpServer classe. La nom et Version Ces propriétés permettent d'identifier le serveur et sa version. Il ne nous reste plus qu'à définir les outils, les ressources et les invites que notre serveur mettra à la disposition du client. Pour ce faire, il suffit d'utiliser le server.tool() méthode (ou .resource() ou .prompt() si nécessaire).

Créer l'outil « Balance »

Le premier outil que nous allons créer est un simple vérificateur de solde. Cet outil prendra une adresse Solana en entrée et renverra le solde de cette adresse. Ajoutez le code suivant à src/index.ts:

server.tool(
  "getBalance",
  {
    walletAddress: z
      .string()
      .describe("Solana wallet address to check the balance for"),
  },
  async (args: { walletAddress: string }) => {
    try {
      assertIsAddress(args.walletAddress);
      const accountAddress = address(args.walletAddress);

      const { value: lamports } = await solanaRpc
        .getBalance(accountAddress)
        .send();

      const solBalance = Number(lamports) / 1_000_000_000;

      return {
        content: [
          {
            type: "text" as const,
            text: `Balance for ${args.walletAddress}: ${solBalance} SOL (${lamports.toString()} lamports)`,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error while getting balance: ${isSolanaError(error) ? error.message : "Unknown error"}`,
          },
        ],
        isError: true,
      };
    }
  },
);

Ce code définit un nouvel outil appelé getBalance. L'outil prend un seul argument, adresse de portefeuille, qui est une chaîne de caractères représentant l'adresse Solana dont il faut vérifier le solde. Le tool() La méthode prend trois arguments :

• le nom de l'outil,
• le schéma d'entrée « zod », et
• la fonction de rappel à exécuter lorsque l'outil est appelé.

La fonction de rappel utilise le assertIsAddress fonction de @solana/kit pour vérifier le format de l'adresse. Si l'adresse est valide, il appelle la fonction getBalance méthode du client RPC Solana et renvoie le solde en SOL et en lamports. En cas d'erreur, elle renvoie un message d'erreur.

Initialiser le serveur

Parfait ! Nous avons désormais mis en place les bases de notre serveur. Ensuite, nous devons initialiser le serveur et le configurer pour qu’il écoute les requêtes entrantes. Ajoutez le code suivant à src/index.ts:

async function runServer() {
  const transport = new StdioServerTransport();
  await server.connect(transport);
}

runServer().catch((error) => {
  console.error("Fatal error:", error);
  process.exit(1);
});

Nous utilisons la classe « Standard Input/Output » pour traiter les requêtes entrantes (recommandée pour les intégrations locales). Ce mode de transport permet au serveur de communiquer avec le client via les entrées et sorties standard. Le connect() Cette méthode démarre le serveur et le met en écoute pour les requêtes entrantes. À mesure que vous développerez davantage avec MCP, vous aurez peut-être besoin d'options de transport supplémentaires ; vous pouvez vous reporter à la Documentation du SDK MCP Pour plus d'informations.

Configurer le serveur

Maintenant que notre serveur est configuré, passons à sa compilation et à son exécution. Dans votre terminal, exécutez la commande suivante :

npm exécuter la compilation

Cela compilera votre code TypeScript en JavaScript et placera le résultat dans le construire répertoire. Nous pouvons désormais lancer le serveur, mais avec Claude Desktop, ce n'est en réalité pas nécessaire, car il se charge de l'initialiser pour nous.

Configuration de Claude Desktop

Maintenant que notre serveur MCP est compilé, nous devons nous assurer que Claude peut le trouver et qu’il est configuré pour l’utiliser. Vérifiez que Claude Desktop est bien installé. Dans l’application, allez dans « Claude » -> « Paramètres », puis cliquez sur « Développeur ». Cliquez ensuite sur « Modifier la configuration » :

Cela devrait ouvrir une claude_desktop_config.json fichier (ou son répertoire parent). Si vous ne voyez pas le fichier, consultez la dernière version documentation de référence pour voir où il se trouve.

Vous devriez voir un objet JSON contenant les serveurs MCP. S'il s'agit de votre premier MCP, il devrait être vide. Nous allons ajouter un nouveau Solana s'opposer à la mcpServers objet. Cet objet contiendra la configuration de notre serveur MCP Solana. Mise à jour claude_desktop_config.json avec :

{
    "mcpServers": {
        "solana": {
            "command": "node",
            "args": [
                "/absolute/path/to/build/index.js"
            ],
            "env": {
                "SOLANA_RPC_ENDPOINT": "https://example.solana-mainnet.quiknode.pro/123456/"
            }
        }
        // other MCP servers that you already have configured...
    }
}

Assurez-vous de :

• remplacer /chemin/absolu/vers/build/index.js avec le chemin d'accès absolu vers votre build/index.js fichier. Vous pouvez le trouver en exécutant la commande pwd dans votre terminal.
• remplacer https://example.solana-mainnet.quiknode.pro/123456/ avec votre propre point de terminaison RPC Solana. Si vous n'en avez pas, vous pouvez en obtenir un gratuitement ici. Veillez à utiliser votre https point de terminaison.

Remarque : c'est ici que le SOLANA_RPC_ENDPOINT Une variable d'environnement est en cours de définition. Pour plus d'informations sur les variables d'environnement dans les serveurs MCP, consultez la documentation officielle.

Enregistrez et fermez le fichier. Vous ne devriez pas avoir besoin de le modifier davantage dans le cadre de ce guide.

Testez votre serveur MCP

Maintenant que nous avons mis à jour notre configuration Claude, vous devrez fermer puis relancer Claude Desktop. Une fois cette opération effectuée, Claude Desktop devrait démarrer votre serveur MCP au redémarrage. Vous devriez voir un écran similaire à celui-ci au démarrage :

Cliquez sur le bouton « 🔨 Outils » : vous devriez alors voir s'afficher les outils disponibles que vous pouvez utiliser (dans notre cas, getBalance) 👀 :

Testons cela. Demandez à Claude de vous indiquer le solde de votre portefeuille (par exemple : « Quel est le solde de CebN5WGQ4jvEPvsVU4EoHEpgzq1VV7AbicfhtW4xC9iM ? »). Après avoir réfléchi un instant, Claude devrait vous demander l'autorisation d'utiliser l'outil MCP :

Cliquez pour autoriser l'utilisation de l'outil ; Claude devrait alors récupérer les données de la blockchain et les renvoyer dans votre réponse :

Félicitations ! Vous avez réussi à créer un serveur MCP Solana de base et à l'intégrer à Claude Desktop.

Optimisez votre serveur MCP

Maintenant que l'intégration de base fonctionne, améliorons notre serveur en lui ajoutant de nouvelles fonctionnalités. Nous allons ajouter :

• Un outil permettant de récupérer des comptes de jetons
• Un outil permettant de vérifier l'état du réseau
• Un outil permettant d'obtenir les détails d'une transaction
• Un outil permettant d'obtenir des informations sur un compte
• Exemple simple de ressource
• Conseils utiles pour les tâches courantes

Leur ajout est très simple : il suffit de les enregistrer à l'aide d'un simple appel de méthode. Passons-les en revue une par une ; n'hésitez pas à sauter certaines étapes et à ne mettre en œuvre que celles qui vous intéressent.

Outil de gestion des comptes de jetons

Nous disposons déjà d'un outil permettant d'obtenir le solde SOL d'un utilisateur, mais que faire si nous souhaitons également connaître ses soldes en tokens ? Notre outil de gestion des comptes de tokens nous permettra de récupérer tous les comptes de tokens associés à une adresse de portefeuille donnée. Ajoutez le code suivant à src/index.ts:

server.tool(
  "getTokenAccounts",
  {
    walletAddress: z
      .string()
      .describe("Solana wallet address to check token accounts for"),
  },
  async ({ walletAddress }) => {
    try {
      assertIsAddress(walletAddress);

      const accounts = await Promise.all([
        solanaRpc
          .getTokenAccountsByOwner(
            walletAddress,
            { programId: SPL_PROGRAM_KEYS.TOKEN_PROGRAM },
            { encoding: "jsonParsed" },
          )
          .send(),
        solanaRpc
          .getTokenAccountsByOwner(
            walletAddress,
            { programId: SPL_PROGRAM_KEYS.TOKEN_2022_PROGRAM },
            { encoding: "jsonParsed" },
          )
          .send(),
      ]);
      const tokenAccounts = accounts.flat();

      const tokenAccountDetails = tokenAccounts.flatMap((account) => {
        return account.value.map((account) => {
          const address = account.pubkey;
          const mint = account.account.data.parsed.info.mint;
          const amount = account.account.data.parsed.info.tokenAmount.uiAmount;
          const decimals =
            account.account.data.parsed.info.tokenAmount.decimals;
          return { address, mint, amount, decimals };
        });
      });

      // Format data as a markdown table
      let markdownTable = "| Token Address | Mint | Amount | Decimals |\n";
      markdownTable += "|-------------|------|--------|----------|\n";

      tokenAccountDetails
        .filter((account) => account.amount !== null)
        .filter((account) => account.amount !== 0)
        .filter((account) => account.amount !== 1) // removing possible NFTs
        .sort((a, b) => b.amount! - a.amount!) // we already removed null and 0 amounts
        .forEach((account) => {
          markdownTable += `| ${account.address} | ${account.mint} | ${account.amount} | ${account.decimals} |\n`;
        });

      return {
        content: [
          {
            type: "text",
            text: `Found ${tokenAccountDetails.length} token accounts for ${walletAddress}`,
          },
          {
            type: "text",
            text: markdownTable,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error while getting balance: ${isSolanaError(error) ? error.message : "Unknown error"}`,
          },
        ],
        isError: true,
      };
    }
  },
);

D'un point de vue structurel, cela ressemble beaucoup au getBalance outil. La principale différence réside dans le fait que nous utilisons le getTokenAccountsByOwner Méthode permettant de récupérer tous les comptes de jetons associés à une adresse de portefeuille donnée. Nous avons intégré la prise en charge à la fois de l'ancien programme SPL Token et du programme Token 2022. La réponse pouvant être assez volumineuse, nous filtrons tous les comptes dont le solde est égal à 0 ou 1 (ce qui correspond probablement à un NFT) et effectuons un traitement pour mettre en forme un sous-ensemble des données sous forme de tableau au format Markdown. N’hésitez pas à tester différentes structures de réponse pour déterminer celle qui convient le mieux à votre cas d’utilisation.

Outil de surveillance de l'état du réseau

Ajoutons ensuite un outil permettant de vérifier l'état du réseau. Cet outil renverra l'époque actuelle, la hauteur du bloc et le numéro de slot. Ajoutez le code suivant à src/index.ts:

server.tool("networkStatus", {}, async () => {
  try {
    await solanaRpc.getHealth().send();
  } catch (error) {
    return {
      content: [
        {
          type: "text",
          text: `Network is down`,
        },
      ],
    };
  }
  try {
    const { epoch, blockHeight, absoluteSlot } = await solanaRpc
      .getEpochInfo()
      .send();

    const status = {
      health: "okay",
      currentEpoch: epoch.toString(),
      blockHeight: blockHeight.toString(),
      currentSlot: absoluteSlot.toString(),
    };

    return {
      content: [
        {
          type: "text",
          text: JSON.stringify(status, null, 2),
        },
      ],
    };
  } catch (error) {
    return {
      content: [
        {
          type: "text",
          text: `Error while getting network status: ${isSolanaError(error) ? error.message : "Unknown error"}`,
        },
      ],
      isError: true,
    };
  }
});

Ici, nous effectuons en fait deux appels RPC. Le premier est un simple test de disponibilité visant à vérifier si le réseau fonctionne. Si cet appel renvoie une erreur, nous affichons un message indiquant que le réseau est hors service. S'il fonctionne, nous appelons getEpochInfo pour récupérer l'époque actuelle, la hauteur du bloc et le numéro de slot. Nous renvoyons ces données au format JSON. Notez que nous convertissons bigint convertir les valeurs en chaînes de caractères pour éviter les problèmes de sérialisation avec JSON.stringify.

Outil de détails des transactions

Ajoutons ensuite un outil permettant d'obtenir les détails d'une transaction. Cet outil prendra en entrée la signature d'une transaction et renverra les détails de celle-ci. Ajoutez le code suivant à src/index.ts:

server.tool(
  "getTransaction",
  {
    signature: z.string().describe("Solana transaction signature to look up"),
  },
  async ({ signature }) => {
    try {
      assertIsSignature(signature);
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `not a vaid signature: ${signature}`,
          },
        ],
        isError: true,
      };
    }
    try {
      const transaction = await solanaRpc
        .getTransaction(signature, {
          maxSupportedTransactionVersion: 0,
          encoding: "json",
        })
        .send();

      if (!transaction) {
        return {
          content: [
            { type: "text", text: `Transaction ${signature} not found` },
          ],
          isError: true,
        };
      }

      const programIndices = transaction.transaction.message.instructions.map(
        (instruction) => instruction.programIdIndex,
      );
      const programsInvoked = programIndices.map((index) => {
        const programId = transaction.transaction.message.accountKeys[index];
        return programId.toString();
      });

      // Format the transaction data for readability
      const formattedTx = {
        signature,
        computeUnits: transaction.meta?.computeUnitsConsumed?.toString(),
        logs: transaction.meta?.logMessages,
        accountKeys: transaction.transaction.message.accountKeys,
        programsInvoked: programsInvoked,
        instructions: transaction.transaction.message.instructions,
        slot: transaction.slot.toString(),
        blockTime: transaction.blockTime
          ? new Date(Number(transaction.blockTime) * 1000).toISOString()
          : null,
        fee: transaction.meta?.fee.toString(),
        status: transaction.meta?.err ? "Failed" : "Success",
        preBalances: transaction.meta?.preBalances.map((balance) =>
          balance.toString(),
        ),
        postBalances: transaction.meta?.postBalances.map((balance) =>
          balance.toString(),
        ),
        preTokenBalances: transaction.meta?.preTokenBalances,
        postTokenBalances: transaction.meta?.postTokenBalances,
      };

      return {
        content: [
          {
            type: "text",
            text: `Transaction ${signature}:\n${JSON.stringify(formattedTx, null, 2)}`,
          },
        ],
      };
    } catch (error) {
      return {
        content: [
          {
            type: "text",
            text: `Error while getting balance: ${isSolanaError(error) ? error.message : "Unknown error"}`,
          },
        ],
        isError: true,
      };
    }
  },
);

Tout comme pour nos outils de vérification du solde, nous pouvons utiliser une assertion du Solana Kit pour vérifier nos paramètres (dans ce cas, assertIsSignature). Nous appelons alors le getTransaction méthode permettant de récupérer les détails d'une transaction. Nous analysons les données et ne renvoyons qu'un sous-ensemble de celles-ci que nous estimons utiles au LLM pour analyser une transaction. Dans ce cas précis, nous extrayons les identifiants des programmes invoqués lors de la transaction, la signature de la transaction, les unités de calcul consommées, les journaux, les clés de compte, les programmes invoqués, les instructions, le numéro de slot, la durée du bloc, les frais, le statut, les soldes avant et après la transaction, ainsi que les soldes de jetons avant et après la transaction. Comme pour l’outil précédent, nous veillons à convertir bigint convertir les valeurs en chaînes de caractères pour éviter les problèmes de sérialisation.

Au fur et à mesure que vous vous familiarisez avec les MCP, vous pourriez envisager d'enrichir un peu les données de réponse en utilisant les IDL pour analyser les données d'instructions ou en ajoutant tout autre contexte ou mappage supplémentaire qui vous semblerait utile.

Outil d'informations sur le compte

Ajoutons ensuite un outil permettant d'obtenir les informations relatives à un compte. Cet outil prendra en entrée l'adresse d'un compte et renverra les informations correspondantes. Ajoutez le code suivant à src/index.ts:

server.tool(
  "getAccountInfo",
  {
    walletAddress: z
      .string()
      .describe("Solana wallet address to check account information for"),
  },
  async ({ walletAddress }) => {
    try {
      assertIsAddress(walletAddress);
      const accountAddress = address(walletAddress);

      const { value: accountInfo } = await solanaRpc
        .getAccountInfo(accountAddress)
        .send();

      if (!accountInfo) {
        return {
          content: [
            {
              type: "text",
              text: `Account ${walletAddress} not found or has no SOL balance`,
            },
          ],
          isError: true,
        };
      }

      const info = {
        executable: accountInfo.executable,
        lamports: accountInfo.lamports.toString(),
        owner: accountInfo.owner.toString(),
        rentEpoch: accountInfo.rentEpoch.toLocaleString(),
        space: accountInfo.data.length,
      };

      return {
        content: [
          {
            type: "text",
            text: JSON.stringify(info, null, 2),
          },
        ],
      };
    } catch (error) {
      console.error("Error fetching account info:", error);
      return {
        content: [
          {
            type: "text",
            text: `Error while getting account info: ${isSolanaError(error) ? error.message : "Unknown error"}`,
          },
        ],
        isError: true,
      };
    }
  },
);

Ces schémas devraient vous être familiers à présent. Nous utilisons le getAccountInfo méthode permettant de récupérer les informations relatives au compte.

Exemple de ressource

Les ressources de MCP permettent aux serveurs de mettre à disposition des données structurées pouvant être consultées et utilisées par les modèles de langage de grande envergure (LLM). Contrairement aux outils, qui exécutent des opérations lorsqu’ils sont appelés, les ressources s’apparentent davantage à des « points de terminaison en lecture seule » qui exposent des données dans un format standardisé. Elles sont identifiées par des URI (Uniform Resource Identifiers) qui suivent des schémas tels que file://, https://, ou des schémas personnalisés comme solana:// dans notre exemple.

Voici un exemple complet illustrant comment intégrer une ressource de documentation à votre serveur. Il s'agit d'une version condensée du contenu de notre documentation sur l'optimisation des transactions Solana:

server.resource(
  "transaction-optimization",
  "solana://docs/transaction-optimization",
  async (uri) => {
    const optimizationGuide = {
      title: "Solana Transaction Optimization Strategies",
      strategies: {
        priority_fees: {
          description: "Increase transaction priority in validator queues",
          implementation:
            "Use ComputeBudgetProgram.setComputeUnitPrice({microLamports})",
          best_practice:
            "Use QN Priority Fee API to determine optimal fee based on network conditions",
        },
        compute_units: {
          description:
            "Optimize compute unit usage to prevent transaction drops",
          current_limits: {
            per_block: "48 million",
            per_account_per_block: "12 million",
            per_transaction: "1.4 million",
            transaction_default: "200,000",
          },
          implementation:
            "Use ComputeBudgetProgram.setComputeUnitLimit({units}) after simulation",
        },
        transaction_assembly: {
          steps: [
            "Create transaction with instructions",
            "Fetch and add priority fees",
            "Simulate transaction to determine compute usage",
            "Set compute limit based on simulation",
            "Add recent blockhash",
            "Sign and send",
          ],
        },
        jito_bundles: {
          description: "Bundle multiple transactions for atomic execution",
          requires: "SOL transfer to Jito Tip Account",
        },
        confirmation: {
          description: "Poll transaction status to ensure it landed",
          method: "Use getSignatureStatuses and implement retry logic",
        },
      },
      moreInfo: "https://www.quicknode.com/docs/solana/transactions",
    };

    return {
      contents: [
        {
          uri: uri.href,
          text: JSON.stringify(optimizationGuide, null, 2),
        },
      ],
    };
  },
);

Cette ressource offre un aperçu structuré des stratégies d'optimisation des transactions pour Solana. Le LLM peut utiliser cette ressource pour répondre à des questions sur l'optimisation des transactions sans avoir à faire appel à un outil ou à une API. Le schéma URI (solana://) indique qu'il s'agit d'un type de ressource personnalisé, et le contenu est renvoyé sous un format structuré.

Conseils utiles

Dans MCP, les « prompts » sont des modèles de messages prédéfinis qui aident à orienter les interactions de l'IA avec vos outils et vos ressources. Contrairement aux outils (qui exécutent du code) ou aux ressources (qui fournissent des données), les prompts sont des « recettes » qui structurent la manière dont le LLM doit aborder des tâches spécifiques.

Ajoutons quelques instructions utiles pour guider le LLM dans l'utilisation de nos outils. Ajoutez le code suivant à src/index.ts:

server.prompt(
  "analyze-wallet",
  { walletAddress: z.string() },
  ({ walletAddress }) => ({
    description:
      "Analyze a Solana wallet address and provide a summary of its balances and activity",
    messages: [
      {
        role: "user",
        content: {
          type: "text",
          text: `Please analyze this Solana wallet address: ${walletAddress}

1. What is the SOL balance of this wallet?
2. What token balances does this wallet hold?
3. Provide a summary of recent activity if possible.`,
        },
      },
    ],
  }),
);

server.prompt(
  "explain-transaction",
  { signature: z.string() },
  ({ signature }) => ({
    description: "Analyze and explain a Solana transaction in simple terms",
    messages: [
      {
        role: "user",
        content: {
          type: "text",
          text: `Please analyze this Solana transaction signature: ${signature}

1. Was this transaction successful?
2. What type of transaction is this? (e.g., token transfer, swap, NFT mint)
3. What accounts were involved?
4. Explain what happened in simple terms.`,
        },
      },
    ],
  }),
);

Chaque consigne comprend :

• Un nom unique (comme « analyze-wallet »)
• Schéma des paramètres (utilisant Zod pour la validation des types)
• Une fonction qui génère le contenu d'un message en fonction de ces paramètres

Lorsque les utilisateurs sélectionnent une invite dans Claude Desktop, un formulaire s'affiche pour leur permettre de renseigner les paramètres. Une fois le formulaire envoyé, Claude reçoit le modèle de message formaté et répond en conséquence. Les invites sont particulièrement utiles pour :

• Standardisation des processus courants
• Veiller à ce que les clients abordent les tâches de manière cohérente
• Aider les utilisateurs à formuler des requêtes efficaces
• Aider les clients à utiliser vos outils dans l'ordre le plus efficace

Reconfigurez votre serveur

Maintenant que nous avons ajouté tous nos outils, ressources et invites, reconstruisons le serveur :

npm exécuter la compilation

Testez votre serveur MCP amélioré

Maintenant que nous avons étendu les capacités de notre serveur, testons les nouvelles fonctionnalités avec Claude Desktop. Veillez à fermer Claude Desktop puis à le rouvrir afin de redémarrer le serveur après nos modifications de configuration. À l'ouverture de Claude Desktop, vous devriez constater que votre menu « Outils » propose désormais les 5 outils disponibles :

N'hésitez pas à tester un peu tout ça : vous pouvez par exemple essayer des choses comme :

• Quel est l'état actuel du réseau Solana ?
• Créez un tableau répertoriant les jetons contenus dans ce portefeuille : XYZ...ABC
• Donnez-moi les informations relatives à la transaction concernant : XYZ...ABC
• Donnez-moi les informations relatives au compte : XYZ...ABC

Vous devriez également remarquer un bouton 🔌 « Joindre depuis MCP ». Cliquez dessus : vous devriez alors voir apparaître votre ressource et les invites disponibles :

Si vous cliquez sur l'une de vos invites, un formulaire devrait s'afficher, vous permettant de renseigner les paramètres (par exemple, l'adresse du portefeuille ou le txid) :

Une fois que vous aurez renseigné les paramètres et cliqué sur « Envoyer », Claude utilisera la consigne pour générer un message (en s'appuyant sur les outils nécessaires) et répondra en conséquence. Essayez donc !

Enfin, nous pouvons tester notre ressource. Pour ce faire, vous pouvez ajouter le optimisation des transactions dans votre invite, puis posez à Claude une question en rapport avec celle-ci. Essayez donc :

Bravo !

Conclusion

Vous avez réussi à mettre en place un serveur MCP Solana qui enrichit les capacités des modèles de langage de grande envergure (LLM) grâce à des fonctionnalités blockchain. Cette intégration permet à Claude d’interagir directement avec la blockchain Solana : vérifier des soldes, récupérer des informations sur les tokens, examiner des transactions, et bien plus encore. En combinant la compréhension du langage naturel d’un assistant IA avec les capacités d’accès aux données d’un serveur MCP, vous avez créé un outil puissant pour interagir avec la blockchain. Que vous soyez développeur, trader ou simplement curieux de découvrir Solana, cette intégration rend les données de la blockchain plus accessibles et plus faciles à comprendre. Le framework MCP est flexible et extensible, ce qui vous permet de continuer à enrichir votre serveur de fonctionnalités supplémentaires à mesure que vos besoins évoluent. Les possibilités sont pratiquement illimitées : des simples requêtes de données aux analyses complexes, en passant par la construction de transactions (avec les mesures de sécurité appropriées) et l’assemblage d’agents. Nous espérons que ce guide vous aidera à vous lancer dans l’intégration de MCP et de Solana. Vous souhaitez étendre ce que vous avez déjà construit ? Voici quelques idées pour poursuivre le développement :

Extension de votre serveur MCP Solana

Maintenant que vous disposez d'un serveur MCP opérationnel, voici quelques idées pour l'améliorer encore davantage :

• Récupération des métadonnées des jetons : utilisez l'API DAS de Quicknode pour récupérer les NFT et les métadonnées des jetons à partir de différentes sources afin d'afficher les noms, les symboles et les logos à côté des soldes des jetons.
• Informations sur les prix : Intégrez l'API Metis Jupiter pour fournir les cours actuels des jetons SOL et SPL.
• Historique des transactions : mettre en place un outil permettant de récupérer les transactions récentes associées à une adresse de portefeuille.
• Analysez les données de compte et de transaction de votre programme : comme nous avons développé ce MCP à l'aide de Solana Kit, vous pouvez générer un client pour vos propres programmes avec Codama et intégrer les codecs de votre programme à votre serveur MCP.
• Informations sur les comptes de staking : ajouter des outils permettant de récupérer des informations sur les comptes de staking et l'état de la délégation (Exemple d'utilisation de la récupération des comptes de staking avec Solana Kit)
• Intégrez les modules complémentaires Quicknode pour bénéficier de fonctionnalités étendues

Laissez libre cours à votre créativité ! Nous avons hâte de découvrir ce que vous allez créer. Si vous avez des questions ou besoin d'aide, n'hésitez pas à nous contacter sur Discord ou Twitter.

Ressources supplémentaires

• Code de ce guide
• Documentation du protocole Model Context
• Documentation Solana
• Documentation du kit Solana
• 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.