> ## 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.

# Compétences

> Jeux d'instructions indépendants du modèle qui enseignent aux assistants IA à construire sur Solana avec Helius — logique de routage, modèles SDK corrects, et invites système prêtes à l'emploi.

Les compétences sont des ensembles d'instructions indépendants du modèle qui enseignent aux assistants IA comment router vos demandes vers les bons [outils MCP](/docs/fr/agents/mcp/tools) et fichiers de référence. Elles vont au-delà de l'accès aux outils bruts — elles incluent la logique de routage, les modèles SDK corrects et les règles qui évitent des erreurs courantes comme les frais codés en dur, les mauvais endpoints ou les conseils de l'expéditeur manquants.

Les compétences fonctionnent avec **n'importe quelle plateforme IA** — Claude Code, Codex, OpenAI API, Claude API, Cursor, ChatGPT, et plus. Chaque compétence est livrée avec des variantes d'invite système pré-construites que vous pouvez intégrer dans n'importe quel outil que vous utilisez.

## Compétences Disponibles

<CardGroup cols={2}>
  <Card title="Build" icon="hammer" href="/docs/fr/agents/skills/build">
    Développement Solana de base — DAS, Sender, WebSockets, LaserStream, Webhooks, API Wallet, et plus encore
  </Card>

  <Card title="Phantom" icon="wallet" href="/docs/fr/agents/skills/phantom">
    Développement de dApp frontend — Phantom Connect SDK (React, React Native, navigateur), contrôle d'accès aux tokens, paiements
  </Card>

  <Card title="Jupiter" icon="rocket" href="/docs/fr/agents/skills/jupiter">
    Applications DeFi — échanges de tokens, prêts, ordres à cours limité, DCA, données de token/prix
  </Card>

  <Card title="DFlow" icon="chart-line" href="/docs/fr/agents/skills/dflow">
    Applications de trading — swaps au comptant, marchés de prédiction, streaming en temps réel, Proof KYC
  </Card>

  <Card title="OKX" icon="chart-mixed" href="/docs/fr/agents/skills/okx">
    Trading et intelligence — agrégation DEX OKX, signaux smart money, analyse des tokens mèmes
  </Card>

  <Card title="SVM" icon="microchip" href="/docs/fr/agents/skills/svm">
    Internes du protocole Solana — exécution SVM, consensus, modèle de compte, économie des validateurs
  </Card>
</CardGroup>

## Comment Fonctionnent les Compétences

Les compétences suivent une architecture d'invite à 3 couches :

| Couche         | Quoi                                                          | Où                                                                                      |
| -------------- | ------------------------------------------------------------- | --------------------------------------------------------------------------------------- |
| **A: Harness** | Comportement spécifique de l'agent/runtime et règles d'outil  | Intégré (Claude Code), `AGENTS.md` (Codex), préambule dans les variantes d'invite (API) |
| **B: Skills**  | Procédures canoniques, réutilisables, indépendantes du modèle | Fichiers `SKILL.md` + répertoire `references/`                                          |
| **C: Task**    | Demande de l'utilisateur + contexte dynamique                 | Fourni à l'exécution par chaque plateforme                                              |

Le contenu des compétences (Couche B) est identique sur toutes les plateformes — seul l'enrobage de l'harness (Couche A) diffère.

Chaque compétence inclut :

* **Logique de routage** — mappe votre demande aux outils MCP corrects et fichiers de référence
* **Fichiers de référence** — documentation approfondie pour chaque produit Helius que l'IA lit avant d'écrire le code
* **Règles** — évite les erreurs courantes (par exemple, frais de priorité codés en dur, mauvais endpoints RPC, gestion des erreurs manquante)

## Utilisation des Compétences sur Diverses Plateformes

Chaque compétence est livrée avec trois variantes d'invite pré-construites dans son répertoire `prompts/` :

| Fichier               | Cas d'utilisation                                                    | Format                                                                                    |
| --------------------- | -------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
| `openai.developer.md` | Réponses OpenAI / API des complétions de chat                        | Préambule de la couche A + contenu des compétences avec délimiteurs `=== BEGIN SKILL ===` |
| `claude.system.md`    | Invite système API Claude                                            | Préambule de la couche A + contenu des compétences avec délimiteurs                       |
| `full.md`             | Règles de Cursor, instructions personnalisées ChatGPT, autres outils | Tous les fichiers de référence en ligne, sans dépendances externes                        |

Trouvez-les dans :

* **Repo** : `.agents/skills/<skill>/prompts/`
* **npm package** : `helius-mcp/system-prompts/<skill>/`

<Tabs>
  <Tab title="Vercel Skills CLI">
    Installez les compétences directement dans votre agent de codage IA à l'aide du [Vercel Skills CLI](https://skills.sh/). Fonctionne avec Claude Code, Cursor, Copilot, Codex, et plus.

    ```bash theme={"system"}
    # Install a single skill
    npx skills add helius-labs/core-ai --skill build

    # Browse all available Helius skills
    npx skills add helius-labs/core-ai --list
    ```

    | Compétence                                                                      | Commande d'installation                              |
    | ------------------------------------------------------------------------------- | ---------------------------------------------------- |
    | **build** — Dev Solana de base (Sender, DAS, WebSockets, LaserStream, webhooks) | `npx skills add helius-labs/core-ai --skill build`   |
    | **phantom** — dApps Frontend (Phantom Connect, React, contrôle d'accès tokens)  | `npx skills add helius-labs/core-ai --skill phantom` |
    | **jupiter** — Apps DeFi (swaps, prêts, ordres limités, DCA)                     | `npx skills add helius-labs/core-ai --skill jupiter` |
    | **dflow** — Apps de Trading (swaps, marchés de prédiction, streaming, KYC)      | `npx skills add helius-labs/core-ai --skill dflow`   |
    | **okx** — Trading et intelligence (DEX OKX, smart money, scanner de mèmes)      | `npx skills add helius-labs/core-ai --skill okx`     |
    | **svm** — Internes du protocole (moteur SVM, consensus, modèle de compte)       | `npx skills add helius-labs/core-ai --skill svm`     |
  </Tab>

  <Tab title="Claude Code Plugin">
    Le [plugin Helius](/docs/fr/agents/claude-code-plugin) regroupe toutes les compétences + serveurs MCP en une seule installation. Dans Claude Code, exécutez-les en deux commandes distinctes :

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

    ```
    /plugin install helius@helius-labs
    ```

    Les compétences sont invoquées avec `/helius:build`, `/helius:phantom`, `/helius:jupiter`, `/helius:dflow`, `/helius:okx`, ou `/helius:svm`.
  </Tab>

  <Tab title="Claude Code Standalone">
    Chaque compétence peut être installée indépendamment à l'aide de son script `install.sh` :

    ```bash theme={"system"}
    git clone https://github.com/helius-labs/core-ai.git
    cd core-ai/helius-skills
    ./helius/install.sh            # Install to ~/.claude/skills/helius/
    ./helius/install.sh --project  # Or install to current project
    ```

    Les compétences autonomes sont automatiquement invoquées en tant que Compétences de l'Agent — aucune commande slash requise.
  </Tab>

  <Tab title="Codex CLI">
    Codex découvre automatiquement les compétences de `.agents/skills/` à la racine de votre projet :

    ```bash theme={"system"}
    # Copy the .agents/ directory into your project
    cp -r /path/to/core-ai/.agents/ your-project/
    ```

    Les compétences sont déclenchées implicitement lorsque votre tâche correspond, ou explicitement avec `$helius`, `$helius-phantom`, `$helius-jupiter`, `$helius-dflow`, `$helius-okx`, ou `$svm`.
  </Tab>

  <Tab title="OpenAI API">
    Utilisez `openai.developer.md` comme message `developer` :

    ```python theme={"system"}
    from openai import OpenAI

    client = OpenAI()

    with open(".agents/skills/helius/prompts/openai.developer.md") as f:
        skill_prompt = f.read()

    response = client.responses.create(
        model="o3",
        instructions=skill_prompt,
        input="Build a swap interface that submits via Helius Sender"
    )
    ```

    Fonctionne aussi avec les complétions de chat en utilisant `{"role": "developer", "content": skill_prompt}`.
  </Tab>

  <Tab title="Claude API">
    Utilisez `claude.system.md` comme invite système :

    ```python theme={"system"}
    import anthropic

    client = anthropic.Anthropic()

    with open(".agents/skills/helius/prompts/claude.system.md") as f:
        skill_prompt = f.read()

    message = client.messages.create(
        model="claude-sonnet-4-6-20250514",
        max_tokens=4096,
        system=skill_prompt,
        messages=[
            {"role": "user", "content": "Build a swap interface that submits via Helius Sender"}
        ]
    )
    ```
  </Tab>

  <Tab title="Cursor / ChatGPT">
    Utilisez `full.md` — il intègre tous les fichiers de référence pour qu'il n'y ait pas de dépendances externes.

    **Cursor :** Copiez dans `.cursor/rules/helius.md` :

    ```bash theme={"system"}
    cp .agents/skills/helius/prompts/full.md .cursor/rules/helius.md
    ```

    **Instructions Personnalisées ChatGPT :** Utilisez le contenu core `SKILL.md` (le `full.md` peut dépasser la limite de 8 000 caractères de ChatGPT pour les compétences les plus grandes).
  </Tab>
</Tabs>

## Prérequis

Toutes les compétences nécessitent que le [serveur MCP Helius](/docs/fr/agents/mcp) soit en cours d'exécution (ou les outils équivalents configurés dans votre cadre d'agent). La compétence DFlow nécessite également le [serveur MCP DFlow](https://pond.dflow.net/build/mcp). La compétence Phantom nécessite un compte [Phantom Portal](https://phantom.com/portal) pour les portefeuilles intégrés. La compétence Jupiter nécessite une [clé API Jupiter](https://developers.jup.ag/portal). La compétence OKX nécessite la [bibliothèque de compétences OKX](https://github.com/okx/onchainos-skills) et le CLI `onchainos`.

| Compétence                           | Requiert                                                       | Clé API Nécessaire                   |
| ------------------------------------ | -------------------------------------------------------------- | ------------------------------------ |
| [Build](/docs/fr/agents/skills/build)     | MCP Helius                                                     | Oui (Helius)                         |
| [Phantom](/docs/fr/agents/skills/phantom) | MCP Helius                                                     | Oui (Helius)                         |
| [Jupiter](/docs/fr/agents/skills/jupiter) | MCP Helius                                                     | Oui (Helius + Jupiter)               |
| [DFlow](/docs/fr/agents/skills/dflow)     | MCP Helius + MCP DFlow                                         | Oui (Helius + DFlow pour production) |
| [OKX](/docs/fr/agents/skills/okx)         | MCP Helius + bibliothèque de compétences OKX + CLI `onchainos` | Oui (Helius; OKX optionnel pour dev) |
| [SVM](/docs/fr/agents/skills/svm)         | MCP Helius                                                     | Non                                  |