NOUVEAU : Solana Privacy Rings est désormais disponible sur le réseau principal
Helius pour les agents
Blog/Actualités

Helius pour les agents

Developer Experience Engineer0xIchigo sur X0xIchigo sur LinkedIn0xIchigo sur GitHub
9 min de lecture

Les agents d’IA ont besoin d’outils structurés, de workflows clairs et du bon contexte pour créer des applications prêtes pour la production sur Solana.

Sans cela, les agents devinent les appels API, hallucinent des endpoints, codent en dur des frais qui devraient être dynamiques et passent à côté de solutions plus rapides comme Helius Sender et LaserStream.

Pour y remédier, nous lançons une suite d’outils pour les agents qui développent avec Helius :

  1. Serveur MCP Helius
  2. Helius Skills
  3. Helius CLI
  4. Plugin Helius pour Claude Code

Nous avons également optimisé sans relâche nos SDK TypeScript et Rust, ainsi que notre documentation, afin d’aider les agents autonomes et les assistants d’IA à recommander et à utiliser efficacement ces outils. 

Voici le rôle de chaque outil et la manière dont ils s’articulent :

Le serveur MCP Helius : les outils

Le Model Context Protocol (MCP) est une norme open source introduite par Anthropic qui permet aux modèles d’IA de se connecter en toute sécurité à des sources de données, des outils et des API externes. Il remplace les intégrations personnalisées par une interface universelle et standardisée. 

Le serveur MCP Helius expose Helius — et Solana — à n’importe quel client MCP.

Sans MCP, un agent qui tente de vérifier le solde d’un portefeuille doit ouvrir un shell, construire une commande curl, l’envoyer, analyser la sortie JSON et espérer avoir utilisé le bon endpoint et les bons paramètres.

Répétez cela pour chaque appel API d’un workflow et vous obtenez des interactions lentes, fragiles et sujettes aux erreurs, alourdies par la nécessité de lancer une instance de shell pour chaque commande.

Avec MCP, rien de tout cela n’est nécessaire.

L’agent appelle getBalance comme un outil structuré et reçoit une réponse typée. Aucun shell. Aucun curl. Aucune analyse de sortie : tout fonctionne simplement.

Il en va de même pour parseTransaction, getAssetsByOwner, createWebhook et les plus de 60 autres outils. Les agents peuvent désormais utiliser Helius directement avec les bons paramètres et recevoir des données structurées. 

Le serveur MCP Helius fournit des outils pour :

  • Inscription autonome : créer des comptes, obtenir des clés API, changer de forfait, etc.
  • Données blockchain en direct : RPC, DAS API, ZK Compression et plus encore
  • Streaming de données : WebSockets (standard et améliorés), LaserStream gRPC (latence au niveau des shreds)
  • Envoi de transactions : Priority Fee API, transferts SPL et Sender
  • Webhooks : créer, mettre à jour et supprimer des notifications déclenchées par des événements
  • Portefeuille et historique : soldes, transferts, analyse des transactions, identité du portefeuille et analyse des financements
  • Connaissances sur Solana : SIMDs, références au code source d’Agave et de Firedancer, contenu du blog Helius et recherche dans la documentation officielle de Solana

Installation rapide

Pour ajouter le serveur MCP Helius avec Claude Code, exécutez :

Code
claude mcp add helius npx helius-mcp@latest

Pour Codex, exécutez :

Code
codex mcp add helius -- npx helius-mcp@latest

Pour Cursor, VS Code ou des outils similaires, ajoutez ceci à votre configuration MCP :

Code
{
  "mcpServers": {
    "helius": {
      "command": "npx",
      "args": ["helius-mcp@latest"]
    }
  }
}

Définissez ensuite votre clé API à l’aide de l’outil setHeliusApiKey ou d’une variable d’environnement (par exemple, HELIUS_API_KEY), puis commencez à déployer.

Pour les nouveaux utilisateurs, votre agent peut créer un compte de manière autonome : il génère une paire de clés et appelle signup avec votre adresse e-mail et votre nom. Vous réglez ensuite le forfait souhaité via le lien de paiement, ou vous approvisionnez la paire de clés pour le paiement automatique. 

Helius Skills : le cerveau

MCP donne aux agents accès à plus de 60 outils. Mais l’accès seul ne suffit pas : un agent disposant d’un catalogue d’outils ressemble à un développeur avec des onglets de documentation ouverts, mais sans aucune expérience. Il peut appeler les outils, mais il ne sait pas lequel choisir, comment les combiner pour une tâche donnée ni quelles erreurs éviter. 

Les compétences sont le cerveau. Ce sont des ensembles d’instructions expertes — des prompts soigneusement élaborés avec une logique de routage, des fichiers de référence et des règles — qui apprennent à un agent à devenir un développeur Solana expert.

Lorsqu’une compétence est chargée, l’agent sait que searchAssets est préférable à getProgramAccounts pour rechercher des NFT, que les frais de priorité doivent être récupérés dynamiquement via getPriorityFeeEstimates et que les transactions doivent passer par Sender afin de maximiser leur taux d’inclusion. Les compétences apportent à votre agent une expertise métier.

Aujourd’hui, nous lançons quatre principales Helius Skills :

Build

La compétence Build est destinée au développement Solana fondamental. Elle oriente vers les bons outils pour DAS, Sender, WebSockets, LaserStream, les Webhooks, Enhanced Transactions, l’analyse de portefeuille et l’intégration. C’est la compétence par défaut pour créer quoi que ce soit sur Solana avec Helius. 

DFlow

La compétence DFlow sert à créer des applications de trading. Elle associe les API DFlow — swaps au comptant, marchés prédictifs, streaming en temps réel et Proof KYC — à l’infrastructure Helius pour l’envoi de transactions, l’optimisation des frais et la surveillance on-chain. 

Phantom

La compétence Phantom sert à créer des applications frontend avec le SDK Phantom Connect. Elle couvre la connexion des portefeuilles, le contrôle d’accès par token, la création de NFT, les paiements en cryptomonnaies, l’affichage des portefeuilles d’actifs et l’architecture frontend sécurisée.

SVM

La compétence SVM permet aux agents de comprendre le fonctionnement interne du protocole Solana. Découvrez comment le bytecode sBPF est exécuté, les considérations de conception d’Alpenglow, l’économie des validateurs et bien plus encore en récupérant du contenu en direct depuis le blog Helius, les SIMDs et le code source d’Agave/Firedancer. Aucune clé API requise.

Fonctionnement des compétences

Les compétences sont indépendantes du modèle. Chacune inclut des variantes prédéfinies de prompts système qui fonctionnent sur toutes les plateformes, et pas uniquement avec Claude.

Utilisez openai.developer.md pour l’API OpenAI, claude.system.md pour l’API Claude ou full.md pour les règles Cursor, les instructions personnalisées de ChatGPT ou tout autre outil. Consultez la présentation des compétences pour connaître la configuration propre à chaque plateforme.

Les compétences sont installées automatiquement lorsque vous utilisez le plugin Helius pour Claude Code. Les compétences autonomes peuvent être installées en tant qu’Agent Skills : elles sont invoquées automatiquement, sans commande slash :

Code
# Clone our AI tooling repo
git clone https://github.com/helius-labs/core-ai.git

# Navigate to helius-skills
cd core-ai/helius-skills

# Install your desired skill
./helius/install.sh            # Build skill → ~/.claude/skills/helius/
./helius-dflow/install.sh      # DFlow skill → ~/.claude/skills/helius-dflow/
./svm/install.sh               # SVM skill   → ~/.claude/skills/svm/

Grâce à ces compétences, les agents peuvent créer pratiquement n’importe quelle application Solana — des frontends de trading aux applications de marchés prédictifs, en passant par les processeurs de paiements en stablecoins — en appliquant les bons modèles dès le départ.

Le plugin Helius pour Claude Code : l’offre groupée

MCP fournit les outils, tandis que les compétences constituent le cerveau. Le plugin Helius pour Claude Code est l’offre groupée : une seule installation relie tous les éléments. Tout fonctionne simplement.

Le plugin regroupe le MCP Helius, le MCP DFlow, les quatre compétences et des fichiers de référence détaillés pour chaque produit Helius.

Aucune configuration manuelle de MCP. Aucune installation séparée des compétences.

Une seule installation suffit pour donner à votre agent un accès structuré à la blockchain et une expertise de Solana au sein d’une même session.

Installation rapide

Voici comment installer le plugin Helius depuis la marketplace Claude Code :

Code
/plugin marketplace add helius-labs/core-ai
/plugin install helius@helius-labs

C’est tout. Le plugin démarre automatiquement les deux serveurs MCP et vous donne actuellement accès à quatre commandes slash :

CompétenceCommandeFonction
Build/helius:buildDéveloppement Solana fondamental avec toutes les API Helius
Phantom/helius:phantomdApps frontend créées avec le SDK Phantom Connect et Helius
DFlow/helius:dflowApplications de trading créées avec DFlow et Helius
SVM/helius:svmConnaissance approfondie du protocole Solana

La configuration de la clé API est identique à celle du MCP autonome : utilisez une clé existante, activez l’inscription autonome ou utilisez la Helius CLI. 

À quoi cela ressemble en pratique

Une fois le plugin installé, un seul prompt suffit pour obtenir une application fonctionnelle. Par exemple :

« Crée-moi une CLI de déclaration fiscale afin que je puisse récupérer l’activité on-chain de Toly à l’aide de l’adresse de son portefeuille 86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY. Commence par le mois dernier (février) et génère un fichier CSV répertoriant tous ses événements imposables. Conçois-la pour qu’elle fonctionne avec n’importe quel portefeuille et n’importe quelle période. »

Claude la réalise en une seule passe :   

La compétence /helius:build se déclenche et suggère correctement getTransactionsByAddress avec pagination et filtrage par horodatage afin de renvoyer un historique des transactions entièrement analysé à partir de l’activité récente de Toly.

Aucune sélection manuelle des outils, aucun prompt intermédiaire. L’agent lit les bons fichiers de référence, invoque les bons outils MCP et produit une CLI fonctionnelle compatible avec n’importe quel portefeuille et n’importe quelle plage de dates.

Les agents peuvent bien sûr créer des applications plus complexes, comme des bots de trading :

Pour cet exemple, nous avons installé le plugin Helius pour Claude Code et demandé à Claude de créer un bot de trading qui suit les tokens PumpFun en temps réel, en diffusant les créations de tokens et les transactions via LaserStream.

Nous lui avons également demandé d’afficher les données du marché et de fournir des graphiques de base afin que nous puissions simuler des transactions. C’est tout. Claude a créé ce bot de trading, avec streaming et trading de tokens en direct, en moins de 10 minutes.

Voilà la différence entre donner des outils à un agent et lui apporter une expertise.

La Helius CLI

La Helius CLI est une interface de ligne de commande complète proposant plus de 95 commandes CLI. Elles couvrent la gestion des comptes, les requêtes sur Solana, l’envoi de transactions, la gestion des webhooks, le streaming en temps réel, le staking, ZK Compression et bien plus encore.

Bien que nous recommandions MCP pour les workflows pilotés par l’IA — les appels d’outils structurés sont préférables au lancement d’instances de shell et à l’analyse de leur sortie — la CLI est le bon choix pour les scripts shell, la création de pipelines CI/CD ou les environnements dans lesquels MCP n’est pas disponible. Chaque commande prend en charge l’option --json pour produire une sortie lisible par une machine et renvoie des codes de sortie structurés, ce qui permet aux automatisations de gérer les erreurs par programmation.

Installation rapide

Pour les nouveaux utilisateurs, la procédure est simple :

Code
# Install the CLI
npm install -g helius-cli
helius keygen                    # Generate keypair

# Signup requires a valid email and name
helius signup --email you@example.com --first-name Jane --last-name Doe
# Pay via the printed link with any wallet, then:
helius signup --resume           # Finalize and get API key
helius projects                  # List projects
helius apikeys <project-id>      # Get API keys

Pour les utilisateurs existants, il suffit d’exécuter :

Code
helius config set-api-key YOUR_API_KEY

Des SDK optimisés pour les agents

Pour les agents qui créent des applications par programmation, nous avons publié une documentation optimisée pour les agents concernant nos SDK TypeScript et Rust.

Ces pages présentent les approches recommandées pour les workflows courants des agents, notamment l’envoi de transactions via Sender, le traitement par lots, les données en temps réel, la pagination et la gestion des erreurs. 

SDK TypeScript

Le SDK TypeScript de Helius fournit des méthodes à typage sûr pour chaque appel API Helius. Pour les agents, l’élément essentiel est que les méthodes propres à Helius réduisent les workflows Solana en plusieurs étapes à un seul appel. 

Par exemple, getTransactionsForAddress remplace l’ancien modèle standard en deux étapes qui consistait à récupérer les signatures, puis les transactions. Un seul appel suffit, avec filtrage côté serveur, plages temporelles et prise en charge des comptes de tokens : 

Code
import { createHelius } from "helius-sdk";

const helius = createHelius({ apiKey: "YOUR_API_KEY" });

// Single call: full transaction history with token activity
const txs = await helius.getTransactionsForAddress([
  "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
  {
    transactionDetails: "full",
    limit: 100,
    filters: { tokenAccounts: "balanceChanged" },
  },
]);

De même, sendSmartTransaction gère automatiquement la simulation, l’estimation des unités de calcul, les frais de priorité et la confirmation.

sendTransactionWithSender va encore plus loin et optimise l’envoi de transactions pour une latence extrêmement faible.

Consultez les bonnes pratiques TypeScript pour le traitement par lots, la pagination, les données en temps réel via webhook et WebSockets, la récupération incrémentielle des comptes, la gestion des erreurs et les pièges courants que les agents doivent éviter. 

SDK Rust

Le SDK Rust de Helius fournit des bindings Rust asynchrones avec les mêmes méthodes Helius, ce qui le rend idéal pour les workflows agentiques à hautes performances :

Code
use helius::Helius;
use helius::types::*;

let helius = Helius::new("YOUR_API_KEY", Cluster::MainnetBeta)?;

// Same single-call pattern as TypeScript
let txs = helius.rpc().get_transactions_for_address(
    "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY".to_string(),
    GetTransactionsForAddressOptions {
        transaction_details: Some(TransactionDetails::Full),
        limit: Some(100),
        filters: Some(GetTransactionsFilters {
            token_accounts: Some(TokenAccountsFilter::BalanceChanged),
            ..Default::default()
        }),
        ..Default::default()
    },
).await?;

Le SDK Rust fournit également des variantes d’erreurs typées (par exemple, HeliusError::RateLimitExceeded), ce qui permet aux agents de traiter directement les erreurs au lieu d’analyser des chaînes de caractères.

Consultez les bonnes pratiques Rust pour découvrir les mêmes approches en Rust, notamment le traitement par lots, la pagination, Sender, les stratégies de nouvelle tentative et les pièges courants. 

Commencer

Helius offre aux agents la boîte à outils la plus complète pour créer des applications prêtes pour la production sur Solana. Voici comment commencer :

Consultez notre documentation, explorez le dépôt GitHub, proposez une intégration de compétence et contactez notre équipe d’assistance si vous avez des questions.

Abonnez-vous à Helius

Suivez les dernières actualités du développement sur Solana et recevez une notification à chaque publication

Image agrandie