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

# AI integration

> Plug Raydium docs into your coding agent or LLM workflow — MCP server, llms.txt index, per-page copy, and pre-built context files.

<Info>
  These docs are designed to be consumed by AI tools as well as humans. If you're building with a coding agent (Claude Code, Cursor, Windsurf, Continue, etc.) or running RAG over docs, the surfaces below let you wire Raydium documentation in without any custom scraping.
</Info>

## What's available

| Surface                  | URL pattern                                                                                  | Use when                                                                                               |
| ------------------------ | -------------------------------------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------ |
| **MCP server**           | `https://docs.raydium.io/mcp`                                                                | You want your AI editor (Claude Code, Cursor, Windsurf, etc.) to query and cite Raydium docs natively. |
| **`llms.txt` index**     | `https://docs.raydium.io/llms.txt`                                                           | You're building a RAG pipeline and need a flat index of every page.                                    |
| **`llms-full.txt` body** | `https://docs.raydium.io/llms-full.txt`                                                      | You want the full corpus as a single concatenated file for offline indexing.                           |
| **Per-page copy menu**   | The `Copy page` button at the top of every body page                                         | You're pasting one page into a chat with an LLM.                                                       |
| **Per-page deep-links**  | `View as Markdown`, `Open in ChatGPT`, `Open in Claude`, `Open in Cursor`, `Open in VS Code` | One-click hand-off from a doc page to your tool of choice.                                             |

The `Copy page` button and the deep-link menu sit in the top-right of every page (next to the page title). Both are powered by the documentation platform's contextual menu.

## MCP server

The MCP (Model Context Protocol) server lets AI clients query the Raydium docs as a tool. Once configured, your agent can ask "search Raydium docs for `addLiquidity` parameters" and get authoritative answers cited back.

### Claude Code

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

After adding, ask Claude Code to "search the Raydium docs for X" and it will use the tool.

### Cursor

Add to your Cursor settings (`Cmd/Ctrl + ,` → MCP):

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

### Windsurf, Continue, generic clients

Any MCP-compatible client can point at `https://docs.raydium.io/mcp`. If your client requires a manifest, it's at `https://docs.raydium.io/mcp/.well-known/mcp.json`.

### What the server exposes

The Raydium docs MCP server exposes one primary tool, `search_docs(query: string)`, which returns the highest-ranked passages for the query along with their canonical URLs. The agent is responsible for citing the URL it used; we don't track or rate-limit per-agent.

## `llms.txt` for RAG

`llms.txt` is an emerging standard for "machine-readable docs index". Raydium publishes:

* `https://docs.raydium.io/llms.txt` — a flat list of every page with title and one-line summary, organized by chapter.
* `https://docs.raydium.io/llms-full.txt` — the full Markdown body of every page, concatenated, with page boundaries preserved as headings.

The `full` variant is regenerated on every docs deploy. Pull it on a schedule (daily is plenty) or fetch on-demand.

```bash theme={null}
# Drop the full corpus into your RAG ingestion pipeline.
curl -sSL https://docs.raydium.io/llms-full.txt -o raydium-docs.md
```

## Per-page hand-off menu

Every body page has a contextual menu (top-right, next to the title) with these one-click actions:

* **Copy** — copy the page as plain Markdown.
* **View as Markdown** — open the source `.md` in a new tab so you can save it.
* **Open in ChatGPT / Claude / Perplexity** — pre-load the page content into a chat prompt for the named tool.
* **Open in Cursor / VS Code** — open a buffer in the named editor with the page content.

This is the right surface when you want to ask a model a question about a single page without setting up MCP.

## Pre-built context files for coding agents

If you're integrating Raydium and want your agent to have the right baseline knowledge from the start, drop these files into your project:

### `.cursorrules` / `.windsurfrules` / agent system prompt

```text theme={null}
You are integrating with Raydium, a Solana DeFi protocol with five product
surfaces: AMM v4, CPMM, CLMM, Farm, and LaunchLab. Authoritative docs live
at docs.raydium.io. The official SDK is `@raydium-io/raydium-sdk-v2` (pin
the version you've verified against). For server-built swaps, prefer the
Trade API at transaction-v1.raydium.io. Always:

- Pass a `Connection` and `cluster` that match.
- Keep all amounts as `BN` instances; never call `.toNumber()` on amounts.
- Pre-fund the user's wallet for ATA creation rent.
- Pass an explicit `computeBudgetConfig` for any tx that may compete in
  high-volume windows.
- Re-fetch `poolInfo` immediately before high-value transactions; cached
  state goes stale.

When uncertain about an instruction's accounts list, defer to
`docs.raydium.io/products/<product>/accounts` and the on-chain IDL.
```

Save as `.cursorrules` (Cursor), `.windsurfrules` (Windsurf), or `CLAUDE.md` (Claude Code) — or paste into your agent's system prompt. The exact filename and location vary by tool version, so check your tool's settings docs if it does not pick the file up automatically.

### Pinned context list

For coding agents that accept a list of "always include" pages, this list is the minimum useful context for most Raydium integrations:

```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
```

Adjust based on which products you're integrating.

## Indexing recipe

If you're building your own RAG and don't want to use `llms-full.txt`, here's the canonical recipe:

```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();
  // ingest md into your vector store, keyed by path
}
```

Every page is served at its canonical path with a `.md` suffix appended (e.g. `/sdk-api/typescript-sdk` → `/sdk-api/typescript-sdk.md`).

## Caveats

* **Don't paste private state into prompts.** The MCP server only knows what's in the public docs. Wallet keys, RPC credentials, and similar secrets should never enter agent context.
* **AI output isn't authoritative.** Models hallucinate program addresses, instruction names, and account lists with worrying ease. Always verify against the docs and the IDL before trusting agent-generated transactions.
* **Version drift.** SDK v2 is pre-1.0; agents trained on older releases may emit code that doesn't compile against your pinned version. Include the pinned SDK version in your agent's system prompt.

## Pointers

* [`sdk-api/typescript-sdk`](/sdk-api/typescript-sdk) — the primary SDK reference.
* [`sdk-api/trade-api`](/sdk-api/trade-api) — server-built swap transactions, ideal for agent-friendly integrations.
* [`reference/program-addresses`](/reference/program-addresses) — verified program IDs.
* [Model Context Protocol](https://modelcontextprotocol.io) — the upstream MCP spec.
* [`llms.txt` proposal](https://llmstxt.org) — context on the index standard.

Sources:

* [Mintlify MCP and llms.txt support](https://mintlify.com/docs/ai/llms).
* Raydium docs deployment.