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

# Intégration IA

> Branchez la documentation Raydium dans votre agent de codage ou flux LLM — serveur MCP, index llms.txt, copie par page, et fichiers de contexte prédéfinis.

<Info>
  **Cette page est traduite automatiquement par IA. La version anglaise fait foi.**

  [Voir la version anglaise →](/sdk-api/ai-integration)
</Info>

<Info>
  Cette documentation est conçue pour être consommée par les outils IA ainsi que par les humains. Si vous développez avec un agent de codage (Claude Code, Cursor, Windsurf, Continue, etc.) ou si vous appliquez la RAG sur la documentation, les surfaces ci-dessous vous permettent de brancher la documentation Raydium sans scraping personnalisé.
</Info>

## Ce qui est disponible

| Surface                     | Modèle d'URL                                                                                 | À utiliser quand                                                                                                              |
| --------------------------- | -------------------------------------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------- |
| **Serveur MCP**             | `https://docs.raydium.io/mcp`                                                                | Vous voulez que votre éditeur IA (Claude Code, Cursor, Windsurf, etc.) interroge et cite la documentation Raydium nativement. |
| **Index `llms.txt`**        | `https://docs.raydium.io/llms.txt`                                                           | Vous construisez un pipeline RAG et avez besoin d'un index plat de chaque page.                                               |
| **Corps `llms-full.txt`**   | `https://docs.raydium.io/llms-full.txt`                                                      | Vous voulez l'intégralité du corpus comme un seul fichier concaténé pour l'indexation hors ligne.                             |
| **Menu de copie par page**  | Le bouton `Copy page` en haut de chaque page de contenu                                      | Vous collez une page dans une discussion avec un LLM.                                                                         |
| **Liens profonds par page** | `View as Markdown`, `Open in ChatGPT`, `Open in Claude`, `Open in Cursor`, `Open in VS Code` | Transfert en un clic d'une page de documentation vers l'outil de votre choix.                                                 |

Le bouton `Copy page` et le menu de lien profond se trouvent en haut à droite de chaque page (à côté du titre). Les deux sont alimentés par le menu contextuel de la plateforme de documentation.

## Serveur MCP

Le serveur MCP (Model Context Protocol) permet aux clients IA d'interroger la documentation Raydium comme un outil. Une fois configuré, votre agent peut demander « recherche dans la documentation Raydium les paramètres `addLiquidity` » et obtenir des réponses fiables avec citations.

### Claude Code

```bash theme={null}
claude mcp add --transport http raydium-docs https://docs.raydium.io/mcp
```

Après l'ajout, demandez à Claude Code de « rechercher dans la documentation Raydium X » et il utilisera l'outil.

### Cursor

Ajoutez à vos paramètres Cursor (`Cmd/Ctrl + ,` → MCP) :

```json theme={null}
{
  "mcpServers": {
    "raydium-docs": {
      "url": "https://docs.raydium.io/mcp"
    }
  }
}
```

### Windsurf, Continue, clients génériques

Tout client compatible MCP peut pointer vers `https://docs.raydium.io/mcp`. Si votre client nécessite un manifeste, il se trouve à `https://docs.raydium.io/mcp/.well-known/mcp.json`.

### Ce que le serveur expose

Le serveur MCP de documentation Raydium expose un outil principal, `search_docs(query: string)`, qui retourne les passages les mieux classés pour la requête ainsi que leurs URL canoniques. L'agent est responsable de citer l'URL qu'il a utilisée ; nous ne suivons pas et ne limitons pas par agent.

## `llms.txt` pour RAG

`llms.txt` est un standard émergent pour « l'index de documentation lisible par machine ». Raydium publie :

* `https://docs.raydium.io/llms.txt` — une liste plate de chaque page avec titre et résumé d'une ligne, organisée par chapitre.
* `https://docs.raydium.io/llms-full.txt` — le corps Markdown complet de chaque page, concaténé, avec les limites de page préservées comme en-têtes.

La variante `full` est régénérée à chaque déploiement de documentation. Récupérez-la selon un calendrier (quotidien suffit) ou à la demande.

```bash theme={null}
# Insérez l'intégralité du corpus dans votre pipeline d'ingestion RAG.
curl -sSL https://docs.raydium.io/llms-full.txt -o raydium-docs.md
```

## Menu de transfert par page

Chaque page de contenu possède un menu contextuel (en haut à droite, à côté du titre) avec ces actions en un clic :

* **Copy** — copier la page en Markdown pur.
* **View as Markdown** — ouvrir la source `.md` dans un nouvel onglet pour que vous puissiez l'enregistrer.
* **Open in ChatGPT / Claude / Perplexity** — précharger le contenu de la page dans une invite de discussion pour l'outil nommé.
* **Open in Cursor / VS Code** — ouvrir un buffer dans l'éditeur nommé avec le contenu de la page.

C'est la bonne surface quand vous voulez poser une question à un modèle sur une seule page sans configurer MCP.

## Fichiers de contexte prédéfinis pour agents de codage

Si vous intégrez Raydium et voulez que votre agent ait les bonnes connaissances de base dès le départ, déposez ces fichiers dans votre projet :

### `.cursorrules` / `.windsurfrules` / invite système d'agent

```text theme={null}
Vous intégrez Raydium, un protocole DeFi Solana avec cinq surfaces de produit :
AMM v4, CPMM, CLMM, Farm, et LaunchLab. La documentation officielle se trouve
à docs.raydium.io. Le SDK officiel est `@raydium-io/raydium-sdk-v2` (épinglez
la version contre laquelle vous avez vérifié). Pour les swaps construits côté
serveur, préférez l'API Trade à transaction-v1.raydium.io. Toujours :

- Passez une `Connection` et un `cluster` qui correspondent.
- Gardez tous les montants en tant qu'instances `BN` ; n'appelez jamais
  `.toNumber()` sur des montants.
- Prépayez le portefeuille de l'utilisateur pour la rente de création d'ATA.
- Passez un `computeBudgetConfig` explicite pour toute tx qui pourrait
  concourir dans des fenêtres à haut volume.
- Re-récupérez `poolInfo` immédiatement avant les transactions de haute valeur ;
  l'état en cache devient obsolète.

Quand vous êtes incertain sur la liste des comptes d'une instruction, reportez-
vous à `docs.raydium.io/products/<product>/accounts` et à l'IDL on-chain.
```

Enregistrez comme `.cursorrules` (Cursor), `.windsurfrules` (Windsurf), ou `CLAUDE.md` (Claude Code) — ou collez dans l'invite système de votre agent. Le nom de fichier exact et l'emplacement varient selon la version de l'outil, donc vérifiez la documentation des paramètres de votre outil s'il ne récupère pas le fichier automatiquement.

### Liste de contexte épinglée

Pour les agents de codage qui acceptent une liste de pages « toujours inclure », cette liste est le contexte utile minimum pour la plupart des intégrations Raydium :

```text theme={null}
https://docs.raydium.io/sdk-api/typescript-sdk
https://docs.raydium.io/sdk-api/trade-api
https://docs.raydium.io/products/cpmm/instructions
https://docs.raydium.io/products/clmm/instructions
https://docs.raydium.io/integration-guides/priority-fee-tuning
https://docs.raydium.io/reference/program-addresses
https://docs.raydium.io/reference/error-codes
```

Ajustez en fonction des produits que vous intégrez.

## Recette d'indexation

Si vous construisez votre propre RAG et ne voulez pas utiliser `llms-full.txt`, voici la recette canonique :

```ts theme={null}
import { fetch } from "undici";

const INDEX_URL = "https://docs.raydium.io/llms.txt";
const BASE      = "https://docs.raydium.io";

const index    = await (await fetch(INDEX_URL)).text();
const pageUrls = [...index.matchAll(/^- \[(.+?)\]\((.+?)\)/gm)].map(m => m[2]);

for (const path of pageUrls) {
  const md = await (await fetch(`${BASE}${path}.md`)).text();
  // ingerez md dans votre vector store, indexé par path
}
```

Chaque page est servie à son chemin canonique avec un suffixe `.md` ajouté (par exemple `/sdk-api/typescript-sdk` → `/sdk-api/typescript-sdk.md`).

## Avertissements

* **Ne collez pas d'état privé dans les invites.** Le serveur MCP ne connaît que ce qui est dans la documentation publique. Les clés de portefeuille, les identifiants RPC et les secrets similaires ne doivent jamais entrer dans le contexte de l'agent.
* **La sortie IA n'est pas autoritaire.** Les modèles hallucinent les adresses de programme, les noms d'instructions et les listes de comptes avec une facilité inquiétante. Toujours vérifier par rapport à la documentation et à l'IDL avant de faire confiance à une transaction générée par agent.
* **Dérive de version.** Le SDK v2 est pré-1.0 ; les agents formés sur des versions antérieures peuvent émettre du code qui ne compile pas par rapport à votre version épinglée. Incluez la version SDK épinglée dans l'invite système de votre agent.

## Pointeurs

* [`sdk-api/typescript-sdk`](/fr/sdk-api/typescript-sdk) — la référence SDK principale.
* [`sdk-api/trade-api`](/fr/sdk-api/trade-api) — transactions de swap construites côté serveur, idéales pour les intégrations conviviales aux agents.
* [`reference/program-addresses`](/fr/reference/program-addresses) — adresses de programme vérifiées.
* [Model Context Protocol](https://modelcontextprotocol.io) — la spécification MCP en amont.
* [proposition `llms.txt`](https://llmstxt.org) — contexte sur le standard d'index.

Sources :

* [Support Mintlify MCP et llms.txt](https://mintlify.com/docs/ai/llms).
* Déploiement de la documentation Raydium.