solana-agent-kit

Par elophanto · elophanto

Guide complet pour créer des agents IA interagissant avec la blockchain Solana à l'aide du Solana Agent Kit de SendAI. Couvre plus de 60 actions, l'intégration LangChain/Vercel AI, la configuration du serveur MCP et les patterns d'agents autonomes.

npx skills add https://github.com/elophanto/elophanto --skill solana-agent-kit

Guide de développement de Solana Agent Kit

Créez des agents IA qui exécutent autonomement 60+ opérations blockchain Solana en utilisant le toolkit open-source de SendAI. Compatible avec LangChain, Vercel AI SDK et Claude via MCP.

Aperçu

Solana Agent Kit permet à n'importe quel modèle IA de :

  • Déployer et gérer des tokens (SPL & Token-2022)
  • Créer et trader des NFT via Metaplex
  • Exécuter des opérations DeFi (Jupiter, Raydium, Orca, Meteora)
  • Staker du SOL, bridger des tokens, enregistrer des domaines
  • Fonctionner en modes interactif ou entièrement autonome

Fonctionnalités clés

Fonctionnalité Description
60+ Actions Token, NFT, DeFi, staking, bridging
Architecture Plugin Modulaire - utilisez uniquement ce dont vous avez besoin
Multi-Framework LangChain, Vercel AI SDK, MCP, Eliza
Agnostique au modèle Fonctionne avec OpenAI, Claude, Llama, Gemini
Mode autonome Exécution sans intervention avec récupération d'erreurs

Démarrage rapide

Installation

# Package principal
npm install solana-agent-kit

# Avec plugins (recommandé)
npm install solana-agent-kit \
  @solana-agent-kit/plugin-token \
  @solana-agent-kit/plugin-nft \
  @solana-agent-kit/plugin-defi \
  @solana-agent-kit/plugin-misc \
  @solana-agent-kit/plugin-blinks

Configuration de l'environnement

# Fichier .env
OPENAI_API_KEY=your_openai_api_key
RPC_URL=https://api.mainnet-beta.solana.com  # ou devnet
SOLANA_PRIVATE_KEY=your_base58_private_key

# Clés API optionnelles pour des fonctionnalités améliorées
COINGECKO_API_KEY=your_coingecko_key
HELIUS_API_KEY=your_helius_key

Configuration basique de l'agent

import {
  SolanaAgentKit,
  createVercelAITools,
  KeypairWallet,
} from "solana-agent-kit";
import { Keypair } from "@solana/web3.js";
import bs58 from "bs58";

// Importer les plugins
import TokenPlugin from "@solana-agent-kit/plugin-token";
import NFTPlugin from "@solana-agent-kit/plugin-nft";
import DefiPlugin from "@solana-agent-kit/plugin-defi";
import MiscPlugin from "@solana-agent-kit/plugin-misc";
import BlinksPlugin from "@solana-agent-kit/plugin-blinks";

// Créer un portefeuille à partir de la clé privée
const privateKey = bs58.decode(process.env.SOLANA_PRIVATE_KEY!);
const keypair = Keypair.fromSecretKey(privateKey);
const wallet = new KeypairWallet(keypair);

// Initialiser l'agent avec les plugins
const agent = new SolanaAgentKit(
  wallet,
  process.env.RPC_URL!,
  {
    OPENAI_API_KEY: process.env.OPENAI_API_KEY!,
  }
)
  .use(TokenPlugin)
  .use(NFTPlugin)
  .use(DefiPlugin)
  .use(MiscPlugin)
  .use(BlinksPlugin);

// Créer des tools pour le framework IA
const tools = createVercelAITools(agent, agent.actions);

Plugins et actions

Plugin Token (@solana-agent-kit/plugin-token)

Action Description
deployToken Déployer un nouveau token SPL ou Token-2022
transfer Transférer du SOL ou des tokens SPL
getBalance Vérifier les soldes de tokens
stake Staker du SOL via Jupiter/Solayer
bridge Bridger des tokens via Wormhole
rugCheck Analyser la sécurité d'un token 
// Déployer un nouveau token
const result = await agent.methods.deployToken({
  name: "My Token",
  symbol: "MTK",
  decimals: 9,
  initialSupply: 1000000,
});

// Transférer des tokens
await agent.methods.transfer({
  to: "recipient_address",
  amount: 100,
  mint: "token_mint_address", // optionnel, par défaut SOL
});

// Vérifier le solde
const balance = await agent.methods.getBalance({
  tokenAddress: "token_mint_address", // optionnel
});

Plugin NFT (@solana-agent-kit/plugin-nft)

Action Description
createCollection Créer une collection NFT via Metaplex
mintNFT Minter un NFT dans une collection
listNFT Lister un NFT sur les marketplaces
updateMetadata Mettre à jour les métadonnées NFT 
// Créer une collection
const collection = await agent.methods.createCollection({
  name: "My Collection",
  symbol: "MYCOL",
  uri: "https://arweave.net/metadata.json",
});

// Minter un NFT dans la collection
const nft = await agent.methods.mintNFT({
  collectionMint: collection.collectionAddress,
  name: "NFT #1",
  uri: "https://arweave.net/nft1.json",
});

Plugin DeFi (@solana-agent-kit/plugin-defi)

Action Description
trade Swapper des tokens via Jupiter
createRaydiumPool Créer un pool Raydium AMM
createOrcaPool Créer un Orca Whirlpool
createMeteoraPool Créer un pool Meteora DLMM
limitOrder Placer un ordre limite via Manifest
lend Prêter des actifs via Lulo
perpetualTrade Trader des perps via Adrena/Drift 
// Swapper des tokens via Jupiter
const swap = await agent.methods.trade({
  outputMint: "target_token_mint",
  inputAmount: 1.0,
  inputMint: "So11111111111111111111111111111111111111112", // SOL
  slippageBps: 50, // 0,5%
});

// Créer un pool Raydium CPMM
const pool = await agent.methods.createRaydiumCpmm({
  mintA: "token_a_mint",
  mintB: "token_b_mint",
  configId: "config_id",
  mintAAmount: 1000,
  mintBAmount: 1000,
});

Plugin Misc (@solana-agent-kit/plugin-misc)

Action Description
airdrop Airdrop ZK-compressé via Helius
getPrice Obtenir le prix d'un token via CoinGecko
registerDomain Enregistrer un domaine .sol
resolveDomain Résoudre un domaine en adresse
getTPS Obtenir le TPS du réseau 
// Airdrop compressé (économique)
const airdrop = await agent.methods.sendCompressedAirdrop({
  mintAddress: "token_mint",
  amount: 100,
  recipients: ["addr1", "addr2", "addr3"],
  priorityFeeInLamports: 10000,
});

// Obtenir le prix d'un token
const price = await agent.methods.getPrice({
  tokenId: "solana", // ID CoinGecko
});

Plugin Blinks (@solana-agent-kit/plugin-blinks)

Exécuter directement Solana Actions/Blinks :

// Exécuter un Blink
const result = await agent.methods.executeBlink({
  blinkUrl: "https://example.com/blink",
  params: { /* blink-specific params */ },
});

Modèles d'intégration

Intégration LangChain

import { SolanaAgentKit, createSolanaTools } from "solana-agent-kit";
import { ChatOpenAI } from "@langchain/openai";
import { createReactAgent } from "@langchain/langgraph/prebuilt";
import { MemorySaver } from "@langchain/langgraph";
import { HumanMessage } from "@langchain/core/messages";

async function createLangChainAgent() {
  // Initialiser le LLM
  const llm = new ChatOpenAI({
    modelName: "gpt-4-turbo-preview",
    temperature: 0.7,
  });

  // Initialiser Solana Agent Kit
  const solanaKit = new SolanaAgentKit(
    wallet,
    process.env.RPC_URL!,
    { OPENAI_API_KEY: process.env.OPENAI_API_KEY! }
  )
    .use(TokenPlugin)
    .use(DefiPlugin);

  // Créer les tools LangChain
  const tools = createSolanaTools(solanaKit);

  // Créer l'agent avec la mémoire
  const memory = new MemorySaver();
  const agent = createReactAgent({
    llm,
    tools,
    checkpointSaver: memory,
  });

  return agent;
}

// Exécuter l'agent
async function chat(agent: any, message: string) {
  const config = { configurable: { thread_id: "solana-agent" } };

  const stream = await agent.stream(
    { messages: [new HumanMessage(message)] },
    config
  );

  for await (const chunk of stream) {
    if ("agent" in chunk) {
      console.log(chunk.agent.messages[0].content);
    }
  }
}

Intégration Vercel AI SDK

import { SolanaAgentKit, createVercelAITools } from "solana-agent-kit";
import { openai } from "@ai-sdk/openai";
import { generateText } from "ai";

async function runVercelAgent(prompt: string) {
  const agent = new SolanaAgentKit(wallet, rpcUrl, options)
    .use(TokenPlugin)
    .use(DefiPlugin);

  const tools = createVercelAITools(agent, agent.actions);

  const result = await generateText({
    model: openai("gpt-4-turbo"),
    tools,
    maxSteps: 10,
    prompt,
  });

  return result.text;
}

// Utilisation
const response = await runVercelAgent(
  "Swap 0.1 SOL for USDC using the best rate"
);

Serveur MCP pour Claude

Installer et configurer le serveur MCP pour Claude Desktop :

# Installer globalement
npm install -g solana-mcp

# Ou exécuter directement
npx solana-mcp

Ajouter à la config Claude Desktop (~/Library/Application Support/Claude/claude_desktop_config.json) :

{
  "mcpServers": {
    "solana": {
      "command": "npx",
      "args": ["solana-mcp"],
      "env": {
        "RPC_URL": "https://api.mainnet-beta.solana.com",
        "SOLANA_PRIVATE_KEY": "your_base58_private_key",
        "OPENAI_API_KEY": "your_openai_key"
      }
    }
  }
}

Tools MCP disponibles :

  • GET_ASSET - Obtenir les infos token/actif
  • DEPLOY_TOKEN - Créer un nouveau token
  • GET_PRICE - Récupérer le prix d'un token
  • WALLET_ADDRESS - Obtenir l'adresse du portefeuille
  • BALANCE - Vérifier le solde
  • TRANSFER - Envoyer des tokens
  • MINT_NFT - Créer un NFT
  • TRADE - Exécuter un swap
  • REQUEST_FUNDS - Obtenir du SOL devnet
  • RESOLVE_DOMAIN - Chercher un domaine .sol
  • GET_TPS - Débit du réseau

Mode autonome

Exécuter l'agent en mode entièrement autonome :

import { SolanaAgentKit } from "solana-agent-kit";

const agent = new SolanaAgentKit(wallet, rpcUrl, options)
  .use(TokenPlugin)
  .use(DefiPlugin);

// Configurer le comportement autonome
const autonomousConfig = {
  intervalMs: 60000,        // Vérifier chaque minute
  maxActions: 100,          // Actions max par session
  errorRecovery: true,      // Réessai auto sur erreurs
  dryRun: false,            // Mettre true pour tester
};

// Démarrer la boucle autonome
async function runAutonomous() {
  while (true) {
    try {
      // L'agent décide quoi faire selon les conditions du marché
      const decision = await agent.analyze({
        context: "Monitor my portfolio and rebalance if needed",
        constraints: [
          "Keep at least 1 SOL for gas",
          "Max 10% allocation per token",
        ],
      });

      if (decision.shouldAct) {
        await agent.execute(decision.action);
      }

      await sleep(autonomousConfig.intervalMs);
    } catch (error) {
      if (autonomousConfig.errorRecovery) {
        console.error("Error, recovering:", error);
        await sleep(5000);
      } else {
        throw error;
      }
    }
  }
}

Créer des actions personnalisées

Étendre l'agent avec des actions personnalisées :

import { Action, Tool, SolanaAgentKit } from "solana-agent-kit";

// Définir le Tool (dit au LLM COMMENT l'utiliser)
const myCustomTool: Tool = {
  name: "my_custom_action",
  description: "Does something custom on Solana",
  parameters: {
    type: "object",
    properties: {
      param1: {
        type: "string",
        description: "First parameter",
      },
      param2: {
        type: "number",
        description: "Second parameter",
      },
    },
    required: ["param1"],
  },
};

// Définir l'Action (dit à l'agent QUAND et POURQUOI l'utiliser)
const myCustomAction: Action = {
  name: "my_custom_action",
  description: "Use this when you need to do something custom",
  similes: ["custom thing", "special operation"],
  examples: [
    {
      input: "Do the custom thing with value X",
      output: "Custom action executed with param1=X",
    },
  ],
  handler: async (agent: SolanaAgentKit, params: any) => {
    const { param1, param2 } = params;

    // Votre logique personnalisée ici
    const connection = agent.connection;
    const wallet = agent.wallet;

    // Exécuter les opérations Solana...

    return {
      success: true,
      result: `Executed with ${param1}`,
    };
  },
};

// Enregistrer l'action personnalisée
agent.registerAction(myCustomAction);
agent.registerTool(myCustomTool);

Meilleures pratiques

Sécurité

  1. Ne jamais exposer les clés privées - Utiliser des variables d'environnement
  2. Utiliser des portefeuilles dédiés - Séparer le portefeuille de l'agent des fonds principaux
  3. Définir des limites de dépenses - Implémenter les montants maximum de transactions
  4. Tester sur devnet d'abord - Toujours tester avant mainnet
  5. Auditer les actions de l'agent - Enregistrer toutes les opérations

Performance

  1. Utiliser le bon RPC - Helius, Triton pour la production
  2. Regrouper les opérations - Combiner les transactions connexes
  3. Gérer les rate limits - Implémenter des stratégies de backoff
  4. Mettre en cache quand possible - Flux de prix, métadonnées de tokens

Conception de l'agent

  1. Limiter la portée des plugins - Charger uniquement les plugins nécessaires (réduit les hallucinations)
  2. Fournir un contexte clair - Les prompts détaillés améliorent la précision
  3. Ajouter des contraintes - Prévenir les actions non souhaitées
  4. Surveiller et itérer - Passer en revue les décisions de l'agent

Directives

  • Toujours tester sur devnet avant mainnet
  • Définir des limites de transaction maximales
  • Surveiller les logs d'activité de l'agent
  • Utiliser des portefeuilles dédiés pour les agents
  • Implémenter une bonne gestion des erreurs
  • Sécuriser les clés privées

Fichiers dans cette compétence

solana-agent-kit/
├── SKILL.md                           # Ce fichier
├── resources/
│   ├── actions-reference.md           # Liste complète des actions
│   ├── plugins-guide.md               # Guide approfondi des plugins
│   └── security-checklist.md          # Meilleures pratiques de sécurité
├── examples/
│   ├── langchain/                     # Intégration LangChain
│   ├── vercel-ai/                     # Vercel AI SDK
│   ├── mcp-server/                    # Configuration Claude MCP
│   └── autonomous-agent/              # Modèles autonomes
├── templates/
│   └── agent-template.ts              # Modèle de démarrage
└── docs/
    ├── custom-actions.md              # Créer des actions personnalisées
    └── troubleshooting.md             # Problèmes courants

Temps forts de la V2

La version 2 représente une évolution complète du toolkit avec des améliorations clés :

Architecture Plugin

La V2 répond directement à deux grands défis de V1 :

  1. Sécurité : La méthode d'entrée de clé privée n'était pas 100 % sécurisée
  2. Hallucinations : 100+ outils agrégés causaient de la confusion au LLM

Le système de plugins modulaires vous permet d'installer uniquement ce dont vous avez besoin, réduisant l'encombrement du contexte et les hallucinations.

Support du portefeuille intégré (Nouveau)

V2 s'intègre avec des fournisseurs de portefeuille sécurisés pour une sécurité améliorée :

import { TurnkeyWallet, PrivyWallet } from "solana-agent-kit/wallets";

// Turnkey - règles et politiques granulaires
const turnkeyWallet = new TurnkeyWallet({
  organizationId: process.env.TURNKEY_ORG_ID,
  privateKeyId: process.env.TURNKEY_PRIVATE_KEY_ID,
});

// Privy - confirmation avec implication humaine
const privyWallet = new PrivyWallet({
  appId: process.env.PRIVY_APP_ID,
  requireConfirmation: true,
});

// Initialiser l'agent avec un portefeuille sécurisé
const agent = new SolanaAgentKit(turnkeyWallet, rpcUrl, options)
  .use(TokenPlugin)
  .use(DefiPlugin);

Principaux avantages de V2

Fonctionnalité V1 V2
Sécurité du portefeuille Entrée de clé privée Portefeuilles intégrés (Turnkey, Privy)
Chargement des tools Tous les 100+ tools Basé sur plugins, charger ce dont vous avez besoin
Contexte LLM Large, causait hallucinations Minimal, contexte ciblé
Implication humaine Non supporté Natif avec Privy

Vérifier

  • Un vrai appel RPC/SDK a été émis (mainnet, devnet, ou validateur local) et le payload de réponse est capturé dans la transcription, pas simplement paraphrasé
  • Chaque transaction a été simulée (simulateTransaction ou équivalent) avant toute étape de signature/envoi ; les logs de simulation sont joints
  • Pour toute transaction signée/envoyée, la signature résultante est enregistrée et confirmée on-chain (statut retourné par getSignatureStatuses ou URL d'explorateur)
  • Le slippage, les frais prioritaires et les limites de compute unit ont été définis explicitement avec des valeurs numériques concrètes, pas laissés aux défauts de la bibliothèque
  • Les adresses de comptes, les mints et les IDs de programme utilisés dans l'exécution correspondent aux adresses documentées de solana-agent-kit pour le cluster ciblé (pas de mélange mainnet/devnet)
  • Le chemin d'erreur a été exercé au moins une fois (solde insuffisant, oracle obsolète, blockhash expiré, etc.) et la gestion d'erreur de l'agent a produit un message lisible

Notes

  • Solana Agent Kit est activement maintenu (1 400+ commits, 800+ forks)
  • V2 a introduit l'architecture plugin (guide de migration disponible)
  • Version Python disponible : solana-agent-kit-py
  • Le serveur MCP permet l'intégration Claude Desktop
  • 100 000+ téléchargements, 1,6k+ stars GitHub
  • Sous licence Apache-2.0

Skills similaires

langchain-dependencies
langchain-ai / langchain-skills

Configurer les dépendances LangChain selon les versions et cas d'usage requis.

681
eval-bootstrap
datadog-labs / agent-skills

Générer du code d'évaluation Python à partir de traces de production LLM Datadog.

107
langchain-fundamentals
langchain-ai / langchain-skills

Construire des agents IA production avec create_agent(), middleware et décorateur @tool.

681
claude-api
anthropics / skills

Construire des applications LLM avec Claude via le SDK officiel adapté au langage.

133 545
ad-model-onboard
nvidia / skills

Automatiser l'intégration de modèles HuggingFace dans AutoDeploy avec tests et rapport.

85