> ## Documentation Index
> Fetch the complete documentation index at: https://www.helius.dev/docs/llms.txt
> Use this file to discover all available pages before exploring further.

# Helius MCP Server

> Serveur MCP pour Helius — 9 outils routés plus expandResult donnent aux assistants IA Solana interrogation, envoi de transactions, webhooks, streaming et analyse de portefeuille.

Le [serveur Helius MCP](https://www.npmjs.com/package/helius-mcp) offre aux outils IA un accès direct aux API de Helius via **10 outils publics** — 9 outils de domaine routés qui couvrent toutes les fonctionnalités de Helius et Solana, plus `expandResult` pour paginer à travers de grandes réponses.

<CardGroup cols={2}>
  <Card title="9 Outils Routés" icon="bolt">
    Outils groupés par domaine (`heliusWallet`, `heliusAsset`, `heliusTransaction`, …) — chaque action de Helius est accessible à travers l'un d'eux
  </Card>

  <Card title="Inscription au Compte" icon="robot">
    Créez un compte Helius depuis votre outil IA — payez via un lien hébergé ou autopay USDC depuis une paire de clés locale
  </Card>

  <Card title="Données en Temps Réel" icon="signal-stream">
    Abonnez-vous à Enhanced WebSockets et LaserStream gRPC directement depuis votre outil IA
  </Card>

  <Card title="Tout Client MCP" icon="plug">
    Fonctionne avec Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Codex, et tout outil compatible MCP
  </Card>
</CardGroup>

## Qu'est-ce que le MCP?

Le [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) est une norme open-source introduite par Anthropic qui permet aux modèles IA de se connecter en toute sécurité avec des sources de données externes, des outils et des APIs. Il utilise une architecture client-serveur où un hôte (comme Claude) se connecte à un serveur MCP, permettant à l'IA d'interroger des bases de données, d'appeler des APIs ou d'exécuter des actions via une interface universelle et standardisée.

**Pourquoi est-ce important pour Helius:** Le MCP donne à Claude un accès direct aux données en direct de Solana et à l'infrastructure Helius — soldes, métadonnées d'actifs, transactions analysées, gestion des webhooks, streaming, et plus encore. Sans cela, Claude doit deviner les réponses des API ou faire des requêtes curl répétées pour obtenir le contexte. Le MCP permet à Claude d'interagir réellement avec Solana via Helius en utilisant des appels d'outils structurés.

<Note>
  Le site de documentation Helius sur [helius.dev/docs](https://www.helius.dev/docs) expose également un serveur MCP distinct auto-généré par Mintlify. Ce serveur est limité à la recherche documentaire uniquement. `helius-mcp` documenté ici est le serveur complet couvrant toutes les fonctionnalités de Helius et Solana.
</Note>

## Démarrage rapide

<Steps>
  <Step title="Ajouter le serveur MCP">
    ```bash theme={"system"}
    claude mcp add helius npx helius-mcp@latest
    ```

    Ou ajoutez-le à la configuration de votre hôte MCP (Claude Desktop, Cursor, Windsurf, VS Code, etc.):

    ```json theme={"system"}
    {
      "mcpServers": {
        "helius": {
          "command": "npx",
          "args": ["helius-mcp@latest"]
        }
      }
    }
    ```
  </Step>

  <Step title="Configurez votre clé API">
    **Si vous avez déjà une clé :**

    ```bash theme={"system"}
    export HELIUS_API_KEY=YOUR_API_KEY
    ```

    Ou définissez-la dans Claude en appelant l'action `setHeliusApiKey` sur `heliusAccount`. Les clés API sont résolues dans cet ordre :

    1. Appel d'action `setHeliusApiKey` au sein de la session
    2. Variable d'environnement `HELIUS_API_KEY`
    3. `~/.helius/config.json` (défini via la [CLI Helius](/docs/fr/agents/cli))

    **Si vous avez besoin d'un nouveau compte :** Voir [Inscription](#inscription) ci-dessous.
  </Step>

  <Step title="Commencer à utiliser les outils">
    Posez des questions en anglais courant — l'outil et l'action appropriés sont sélectionnés automatiquement :

    * "Quels NFTs ce portefeuille possède-t-il ?"
    * "Analysez cette transaction : `5abc...`"
    * "Obtenez le solde de `Gh9ZwEm...`"
    * "Envoyez 1 SOL à `7xKp...`"
    * "Créez un webhook pour cette adresse"
  </Step>
</Steps>

## Connexion au Serveur MCP Helius

<Tabs>
  <Tab title="Claude Code">
    Exécutez la commande suivante :

    ```bash theme={"system"}
    claude mcp add helius npx helius-mcp@latest
    ```

    Ou ajoutez-le au `.mcp.json` de votre projet :

    ```json theme={"system"}
    {
      "mcpServers": {
        "helius": {
          "command": "npx",
          "args": ["helius-mcp@latest"]
        }
      }
    }
    ```

    Vérifiez avec :

    ```bash theme={"system"}
    claude mcp list
    ```

    <Tip>
      Vous voulez des compétences + MCP en une seule étape ? Installez le [plugin Helius](/docs/fr/agents/claude-code-plugin) à la place. Exécutez-les en deux commandes séparées :

      ```
      /plugin marketplace add helius-labs/core-ai
      ```

      ```
      /plugin install helius@helius-labs
      ```
    </Tip>
  </Tab>

  <Tab title="Claude Desktop">
    Ouvrez **Paramètres > Développeur > Modifier la Configuration** et ajoutez le serveur :

    ```json theme={"system"}
    {
      "mcpServers": {
        "helius": {
          "command": "npx",
          "args": ["helius-mcp@latest"]
        }
      }
    }
    ```

    Redémarrez Claude Desktop pour appliquer.
  </Tab>

  <Tab title="Cursor">
    Ouvrez la palette de commandes (`Cmd/Ctrl + Shift + P`), recherchez **MCP : Ajouter un Serveur**, et entrez :

    * **Nom :** `helius`
    * **Commande :** `npx helius-mcp@latest`

    Ou ajoutez-le au `.cursor/mcp.json` de votre projet :

    ```json theme={"system"}
    {
      "mcpServers": {
        "helius": {
          "command": "npx",
          "args": ["helius-mcp@latest"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="VS Code">
    Créez un fichier `.vscode/mcp.json` à la racine de votre projet :

    ```json theme={"system"}
    {
      "servers": {
        "helius": {
          "command": "npx",
          "args": ["helius-mcp@latest"]
        }
      }
    }
    ```

    Nécessite l'extension [GitHub Copilot](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot) avec le support MCP activé.
  </Tab>

  <Tab title="Windsurf">
    Ouvrez la palette de commandes (`Cmd/Ctrl + Shift + P`), recherchez **Configurer les Serveurs MCP**, et ajoutez :

    ```json theme={"system"}
    {
      "mcpServers": {
        "helius": {
          "command": "npx",
          "args": ["helius-mcp@latest"]
        }
      }
    }
    ```
  </Tab>

  <Tab title="Codex">
    Exécutez la commande suivante :

    ```bash theme={"system"}
    codex mcp add helius -- npx helius-mcp@latest
    ```

    Ou ajoutez-le à votre `~/.codex/config.toml` (ou `.codex/config.toml` pour une portée projet) :

    ```toml theme={"system"}
    [mcp_servers.helius]
    command = "npx"
    args = ["helius-mcp@latest"]
    ```

    Vérifiez avec :

    ```bash theme={"system"}
    codex mcp list
    ```
  </Tab>
</Tabs>

## Surface d'Outil Public

Helius MCP expose **10 outils publics** : 9 outils de domaine routés plus `expandResult`. Chaque action Helius et Solana est accessible en tant qu'argument `action` sur l'outil routé approprié.

| Outil               | Portée                                                                           |
| ------------------- | -------------------------------------------------------------------------------- |
| `heliusAccount`     | Configuration de compte, auth, plans, facturation                                |
| `heliusWallet`      | Soldes de portefeuille, avoirs, historique, identité                             |
| `heliusAsset`       | Actifs, NFTs, collections, détenteurs de tokens                                  |
| `heliusTransaction` | Analyse de transaction et historique de transaction de portefeuille              |
| `heliusChain`       | État de la chaîne, comptes de tokens, blocs, statut réseau, comptes de programme |
| `heliusStreaming`   | CRUD de webhook et configuration d'abonnement (WebSockets, LaserStream)          |
| `heliusKnowledge`   | Docs, guides, tarification, dépannage, source, blog, SIMDs                       |
| `heliusWrite`       | Transferts — Tokens SOL et SPL                                                   |
| `heliusCompression` | Preuves de Merkle pour NFTs compressés                                           |
| `expandResult`      | Élargir les sorties du résumé en premier avec `resultId`                         |

<Card title="Catalogue Complet d'Outils" icon="bolt" href="/docs/fr/agents/mcp/tools">
  Chaque action groupée par outil routé, avec détails de la forme d'appel et utilisation de `expandResult`
</Card>

### Forme d'appel de l'outil routé

Chacun des 9 outils routés partage une forme commune :

* `action` — le nom de l'action Helius à exécuter, tel que `getBalance` ou `createWebhook`
* paramètres spécifiques au domaine — par exemple `address`, `signatures`, ou `webhookURL`
* optionnel `detail` — `summary`, `standard`, ou `full`
* champs de télémétrie — `_feedback`, `_feedbackTool`, `_model`

Exemple d'appel :

```json theme={"system"}
{
  "name": "heliusWallet",
  "arguments": {
    "action": "getBalance",
    "address": "Gh9ZwEmdLJ8DscKNTkTqPbNwLNNBjuSzaG9Vp2KGtKJr",
    "_feedback": "initial balance check",
    "_feedbackTool": "heliusWallet.getBalance",
    "_model": "your-model-id"
  }
}
```

### Réponses en Résumé d'abord et `expandResult`

Les réponses lourdes sont **en résumé d'abord**. Les outils routés retournent un résumé compact plus un `resultId` lorsque la réponse complète serait grande ou lorsque `detail: "summary"` est demandée. Utilisez `expandResult` avec ce `resultId` pour récupérer une section spécifique, une plage, une page ou une tranche de continuation sur demande.

Cela maintient l'utilisation des tokens faible pour les requêtes exploratoires tout en permettant aux agents d'approfondir le contenu complet lorsque nécessaire.

## Inscription

Créez un compte Helius depuis votre outil IA via un lien de paiement hébergé ou en payant USDC directement depuis une paire de clés locale. Le flux d'inscription passe par l'outil routé `heliusAccount` :

<Steps>
  <Step title="Générer une paire de clés">
    L'IA appelle `heliusAccount` avec `action: "generateKeypair"` — elle crée un portefeuille Solana et retourne l'adresse.
  </Step>

  <Step title="Créer l'intention de paiement">
    L'IA appelle `heliusAccount` avec `action: "signup"` et `mode: "link"` — retourne un `paymentUrl` (e.g. `https://dashboard.helius.dev/pay/<id>`) que l'utilisateur ouvre pour payer avec n'importe quel portefeuille. Ou passez `mode: "autopay"` pour envoyer USDC depuis la paire de clés locale automatiquement (le portefeuille doit contenir \~0.001 SOL + le montant du plan en USDC).
  </Step>

  <Step title="Reprendre après le paiement">
    Après avoir payé via le lien, l'IA appelle `heliusAccount` avec `action: "signup"` et `mode: "resume"` — sonde l'intention de paiement, finalise l'approvisionnement du compte, et configure automatiquement la clé API.
  </Step>
</Steps>

<Note>
  **Informations de contact :** chaque nouvelle inscription — y compris le plan Agent — nécessite `email`, `firstName`, et `lastName`. `upgradePlan` nécessite la même chose.
</Note>

Ou faites de même depuis le terminal avec la [CLI Helius](/docs/fr/agents/cli) :

```bash theme={"system"}
npx helius-cli@latest keygen
npx helius-cli@latest signup --plan agent --email you@example.com --first-name Jane --last-name Doe   # Print hosted payment link
# (pay in browser, then:)
npx helius-cli@latest signup --resume         # Finalize account
# Or autopay from the local keypair:
npx helius-cli@latest signup --plan agent --pay --email you@example.com --first-name Jane --last-name Doe
```

## Configuration du Réseau

Le serveur MCP est par défaut sur **mainnet-beta**. Passez à devnet via la variable d'environnement :

```bash theme={"system"}
export HELIUS_NETWORK=devnet
```

Ou appelez l'action `setNetwork` sur `heliusAccount` au sein d'une session.

## Invites Système

Le package `helius-mcp` est livré avec des invites système préconstruites qui enseignent aux modèles IA comment utiliser efficacement les outils Helius. Elles se trouvent dans `system-prompts/` :

```
system-prompts/
├── helius/              # Core Helius skill
├── helius-phantom/      # Phantom frontend skill
├── helius-jupiter/      # Jupiter DeFi skill
├── helius-dflow/        # DFlow trading skill
├── helius-okx/          # OKX trading & intelligence skill
└── svm/                 # SVM architecture skill
```

Chacune contient trois variantes :

* `openai.developer.md` — pour OpenAI Responses/Chat Completions API (message `developer`)
* `claude.system.md` — pour Claude API (invite système)
* `full.md` — autonome avec toutes les références intégrées (Règles Cursor, ChatGPT, etc.)

Voir le guide d'intégration [`helius-skills/SYSTEM-PROMPTS.md`](https://github.com/helius-labs/core-ai/blob/main/helius-skills/SYSTEM-PROMPTS.md) pour des exemples de code.

## Compétences

Les compétences sont des ensembles d'instructions expertes qui apprennent à Claude comment acheminer vos requêtes vers les bonnes actions MCP et fichiers de référence. Elles vont au-delà de l'accès simple aux outils — elles incluent la logique d'acheminement, les modèles appropriés de SDK et les règles qui préviennent les erreurs courantes.

<Card title="Aperçu des Compétences" icon="brain" href="/docs/fr/agents/skills/overview">
  Six compétences disponibles : Build (développement Solana général), Phantom (dApps frontend), Jupiter (DeFi), DFlow (applications de trading), OKX (trading et intelligence), et SVM (internes du protocole)
</Card>

## En Savoir Plus

<CardGroup cols={2}>
  <Card title="Plugin Claude Code" icon="puzzle-piece" href="/docs/fr/agents/claude-code-plugin">
    Installation en un clic de MCP + compétences
  </Card>

  <Card title="Helius CLI" icon="terminal" href="/docs/fr/agents/cli">
    Gestion de compte en ligne de commande
  </Card>

  <Card title="Spécification MCP" icon="book" href="https://modelcontextprotocol.io/">
    En savoir plus sur la norme Model Context Protocol
  </Card>

  <Card title="helius-mcp sur npm" icon="npm" href="https://www.npmjs.com/package/helius-mcp">
    Détails du package et historique des versions
  </Card>

  <Card title="Changelog" icon="list" href="https://github.com/helius-labs/core-ai/blob/main/helius-mcp/CHANGELOG.md">
    Historique des versions et notes de mise à jour
  </Card>

  <Card title="Contribuer" icon="github" href="https://github.com/helius-labs/core-ai/blob/main/helius-mcp/CONTRIBUTING.md">
    Guide de contribution pour `helius-mcp`
  </Card>
</CardGroup>