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

# Servidor MCP de Helius

> Servidor MCP para Helius: 9 herramientas enrutadas más expandResult brindan a los asistentes de IA consultas de Solana, envío de transacciones, webhooks, streaming y análisis de billeteras.

El [servidor MCP de Helius](https://www.npmjs.com/package/helius-mcp) brinda a las herramientas de IA acceso directo a las API de Helius mediante **10 herramientas públicas**: 9 herramientas de dominio enrutadas que cubren toda la funcionalidad de Helius y Solana, además de `expandResult` para paginar respuestas grandes.

<CardGroup cols={2}>
  <Card title="9 Routed Tools" icon="bolt">
    Herramientas agrupadas por dominio (`heliusWallet`, `heliusAsset`, `heliusTransaction`, …): puedes acceder a todas las acciones de Helius mediante una de ellas
  </Card>

  <Card title="Account Signup" icon="robot">
    Crea una cuenta de Helius desde tu herramienta de IA: paga mediante un enlace alojado o automáticamente con USDC desde un par de claves local
  </Card>

  <Card title="Real-Time Data" icon="signal-stream">
    Suscríbete a Enhanced WebSockets y LaserStream gRPC directamente desde tu herramienta de IA
  </Card>

  <Card title="Any MCP Client" icon="plug">
    Funciona con Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Codex y cualquier herramienta compatible con MCP
  </Card>
</CardGroup>

## ¿Qué es MCP?

El [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) es un estándar de código abierto presentado por Anthropic que permite a los modelos de IA conectarse de forma segura con fuentes de datos externas, herramientas y API. Usa una arquitectura cliente-servidor en la que un host (como Claude) se conecta a un servidor MCP, lo que permite a la IA consultar bases de datos, llamar a API o ejecutar acciones mediante una interfaz universal y estandarizada.

**Por qué esto es importante para Helius:** MCP brinda a Claude acceso directo a datos en vivo de Solana y a la infraestructura de Helius: saldos, metadatos de activos, transacciones analizadas, administración de webhooks, streaming y mucho más. Sin MCP, Claude debe adivinar las respuestas de la API o realizar solicitudes curl repetidas para obtener contexto. MCP permite que Claude interactúe realmente con Solana mediante Helius usando llamadas estructuradas a herramientas.

<Note>
  El sitio de documentación de Helius en [helius.dev/docs](https://www.helius.dev/docs) también expone otro servidor MCP generado automáticamente por Mintlify. Ese servidor se limita únicamente a la búsqueda en la documentación. `helius-mcp`, documentado aquí, es el servidor integral que cubre toda la funcionalidad de Helius y Solana.
</Note>

## Inicio rápido

<Steps>
  <Step title="Add the MCP server">
    ```bash theme={"system"}
    claude mcp add helius npx helius-mcp@latest
    ```

    O agrégalo a la configuración de tu host MCP (Claude Desktop, Cursor, Windsurf, VS Code, etc.):

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

  <Step title="Configure your API key">
    **Si ya tienes una clave:**

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

    O configúrala dentro de Claude llamando a la acción `setHeliusApiKey` en `heliusAccount`. Las claves de API se resuelven en este orden:

    1. Llamada a la acción `setHeliusApiKey` dentro de la sesión
    2. Variable de entorno `HELIUS_API_KEY`
    3. `~/.helius/config.json` (configurada mediante la [CLI de Helius](/docs/es/agents/cli))

    **Si necesitas una cuenta nueva:** Consulta [Registro](#registro) a continuación.
  </Step>

  <Step title="Start using tools">
    Haz preguntas en lenguaje natural; la herramienta y la acción correctas se seleccionan automáticamente:

    * "¿Qué NFT posee esta billetera?"
    * "Analiza esta transacción: `5abc...`"
    * "Obtén el saldo de `Gh9ZwEm...`"
    * "Envía 1 SOL a `7xKp...`"
    * "Crea un webhook para esta dirección"
  </Step>
</Steps>

## Conectarse al servidor MCP de Helius

<Tabs>
  <Tab title="Claude Code">
    Ejecuta el siguiente comando:

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

    O agrégalo a `.mcp.json` en tu proyecto:

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

    Verifica con:

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

    <Tip>
      ¿Quieres las habilidades y MCP en un solo paso? Instala el [plugin de Helius](/docs/es/agents/claude-code-plugin). Ejecuta estos como dos comandos separados:

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

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

  <Tab title="Claude Desktop">
    Abre **Settings > Developer > Edit Config** y agrega el servidor:

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

    Reinicia Claude Desktop para aplicar los cambios.
  </Tab>

  <Tab title="Cursor">
    Abre la paleta de comandos (`Cmd/Ctrl + Shift + P`), busca **MCP: Add Server** e ingresa:

    * **Nombre:** `helius`
    * **Comando:** `npx helius-mcp@latest`

    O agrégalo a `.cursor/mcp.json` en tu proyecto:

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

  <Tab title="VS Code">
    Crea un archivo `.vscode/mcp.json` en la raíz de tu proyecto:

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

    Requiere la extensión [GitHub Copilot](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot) con la compatibilidad con MCP habilitada.
  </Tab>

  <Tab title="Windsurf">
    Abre la paleta de comandos (`Cmd/Ctrl + Shift + P`), busca **Configure MCP Servers** y agrega:

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

  <Tab title="Codex">
    Ejecuta el siguiente comando:

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

    O agrégalo a tu `~/.codex/config.toml` (o `.codex/config.toml` para limitarlo al proyecto):

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

    Verifica con:

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

## Conjunto de herramientas públicas

MCP de Helius expone **10 herramientas públicas**: 9 herramientas de dominio enrutadas más `expandResult`. Puedes acceder a cada acción de Helius y Solana mediante un argumento `action` en la herramienta enrutada correspondiente.

| Herramienta         | Alcance                                                                                  |
| ------------------- | ---------------------------------------------------------------------------------------- |
| `heliusAccount`     | Configuración de cuentas, autenticación, planes y facturación                            |
| `heliusWallet`      | Saldos de billeteras, tenencias, historial e identidad                                   |
| `heliusAsset`       | Activos, NFT, colecciones y titulares de tokens                                          |
| `heliusTransaction` | Análisis de transacciones e historial de transacciones de billeteras                     |
| `heliusChain`       | Estado de la cadena, cuentas de tokens, bloques, estado de la red y cuentas de programas |
| `heliusStreaming`   | Operaciones CRUD de webhooks y configuración de suscripciones (WebSockets, LaserStream)  |
| `heliusKnowledge`   | Documentación, guías, precios, solución de problemas, código fuente, blog y SIMD         |
| `heliusWrite`       | Transferencias: SOL y tokens SPL                                                         |
| `heliusCompression` | Pruebas de Merkle para NFT comprimidos                                                   |
| `expandResult`      | Expande resultados que priorizan el resumen mediante `resultId`                          |

<Card title="Full Tool Catalog" icon="bolt" href="/docs/es/agents/mcp/tools">
  Todas las acciones agrupadas por herramienta enrutada, con detalles sobre la estructura de las llamadas y el uso de `expandResult`
</Card>

### Estructura de las llamadas a herramientas enrutadas

Cada una de las 9 herramientas enrutadas comparte una estructura común:

* `action`: el nombre de la acción de Helius que se ejecutará, como `getBalance` o `createWebhook`
* parámetros específicos del dominio, por ejemplo, `address`, `signatures` o `webhookURL`
* `detail` opcional: `summary`, `standard` o `full`
* campos de telemetría: `_feedback`, `_feedbackTool`, `_model`

Ejemplo de llamada:

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

### Respuestas que priorizan el resumen e `expandResult`

Las respuestas pesadas **priorizan el resumen**. Las herramientas enrutadas devuelven un resumen compacto y un `resultId` cuando la respuesta completa sería grande o cuando se solicita `detail: "summary"`. Usa `expandResult` con ese `resultId` para obtener bajo demanda una sección, intervalo, página o segmento de continuación específicos.

Esto mantiene bajo el uso de tokens en las consultas exploratorias y permite que los agentes profundicen en la carga útil completa cuando sea necesario.

## Registro

Crea una cuenta de Helius desde tu herramienta de IA mediante un enlace de pago alojado o pagando USDC directamente desde un par de claves local. El flujo de registro usa la herramienta enrutada `heliusAccount`:

<Steps>
  <Step title="Generate a keypair">
    La IA llama a `heliusAccount` con `action: "generateKeypair"`; esto crea una billetera de Solana y devuelve la dirección.
  </Step>

  <Step title="Create the payment intent">
    La IA llama a `heliusAccount` con `action: "signup"` e `mode: "link"`; devuelve un `paymentUrl` (por ejemplo, `https://dashboard.helius.dev/pay/<id>`) que el usuario abre para pagar con cualquier billetera. También puedes pasar `mode: "autopay"` para enviar USDC automáticamente desde el par de claves local (la billetera debe contener \~0.001 SOL más el importe del plan en USDC).
  </Step>

  <Step title="Resume after payment">
    Después de pagar mediante el enlace, la IA llama a `heliusAccount` con `action: "signup"` e `mode: "resume"`; esto consulta periódicamente la intención de pago, finaliza el aprovisionamiento de la cuenta y configura automáticamente la clave de API.
  </Step>
</Steps>

<Note>
  **Información de contacto:** cada registro nuevo, incluido el plan Agent, requiere `email`, `firstName` e `lastName`. `upgradePlan` requiere lo mismo.
</Note>

También puedes hacer lo mismo desde la terminal con la [CLI de Helius](/docs/es/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
```

## Configuración de red

El servidor MCP usa **mainnet-beta** de forma predeterminada. Cambia a devnet mediante una variable de entorno:

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

También puedes llamar a la acción `setNetwork` en `heliusAccount` dentro de una sesión.

## Prompts del sistema

El paquete `helius-mcp` incluye prompts del sistema predefinidos que enseñan a los modelos de IA a usar eficazmente las herramientas de Helius. Se encuentran en `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
```

Cada uno contiene tres variantes:

* `openai.developer.md`: para la API OpenAI Responses/Chat Completions (mensaje `developer`)
* `claude.system.md`: para la API de Claude (prompt del sistema)
* `full.md`: autocontenido, con todas las referencias incorporadas (Cursor Rules, ChatGPT, etc.)

Consulta la guía de integración [`helius-skills/SYSTEM-PROMPTS.md`](https://github.com/helius-labs/core-ai/blob/main/helius-skills/SYSTEM-PROMPTS.md) para ver ejemplos de código.

## Habilidades

Las habilidades son conjuntos de instrucciones especializadas que enseñan a Claude a dirigir tus solicitudes a las acciones MCP y a los archivos de referencia correctos. Van más allá del acceso básico a herramientas: incluyen lógica de enrutamiento, patrones correctos del SDK y reglas que evitan errores comunes.

<Card title="Skills Overview" icon="brain" href="/docs/es/agents/skills/overview">
  Hay seis habilidades disponibles: Build (desarrollo general de Solana), Phantom (dApps de frontend), Jupiter (DeFi), DFlow (aplicaciones de trading), OKX (trading e inteligencia) y SVM (componentes internos del protocolo)
</Card>

## Más información

<CardGroup cols={2}>
  <Card title="Claude Code Plugin" icon="puzzle-piece" href="/docs/es/agents/claude-code-plugin">
    Instalación de MCP y habilidades con un solo clic
  </Card>

  <Card title="Helius CLI" icon="terminal" href="/docs/es/agents/cli">
    Administración de cuentas desde la línea de comandos
  </Card>

  <Card title="MCP Specification" icon="book" href="https://modelcontextprotocol.io/">
    Obtén información sobre el estándar Model Context Protocol
  </Card>

  <Card title="helius-mcp on npm" icon="npm" href="https://www.npmjs.com/package/helius-mcp">
    Detalles del paquete e historial de versiones
  </Card>

  <Card title="Changelog" icon="list" href="https://github.com/helius-labs/core-ai/blob/main/helius-mcp/CHANGELOG.md">
    Historial de versiones y notas de las versiones
  </Card>

  <Card title="Contribute" icon="github" href="https://github.com/helius-labs/core-ai/blob/main/helius-mcp/CONTRIBUTING.md">
    Guía para contribuir a `helius-mcp`
  </Card>
</CardGroup>