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

> MCP-Server für Helius — 9 gerichtete Tools plus expandResult geben KI-Assistenten Solana-Abfragen, Transaktionsversand, Webhooks, Streaming und Wallet-Analyse.

Der [Helius MCP-Server](https://www.npmjs.com/package/helius-mcp) gibt KI-Tools direkten Zugang zu Helius APIs durch **10 öffentliche Tools** — 9 gerichtete Domänentools, die alle Helius- und Solana-Funktionen abdecken, plus `expandResult` für das Paging durch große Antworten.

<CardGroup cols={2}>
  <Card title="9 gerichtete Tools" icon="bolt">
    Nach Domänen gruppierte Tools (`heliusWallet`, `heliusAsset`, `heliusTransaction`, …) — jede Helius-Aktion ist über eines von ihnen erreichbar
  </Card>

  <Card title="Kontoerstellung" icon="robot">
    Erstellen Sie ein Helius-Konto von Ihrem KI-Tool aus — zahlen Sie über einen gehosteten Link oder automatisch USDC von einem lokalen Keypair
  </Card>

  <Card title="Echtzeitdaten" icon="signal-stream">
    Abonnieren Sie erweiterte WebSockets und LaserStream gRPC direkt von Ihrem KI-Tool aus
  </Card>

  <Card title="Jeder MCP-Client" icon="plug">
    Funktioniert mit Claude Code, Claude Desktop, Cursor, VS Code, Windsurf, Codex und jedem MCP-kompatiblen Tool
  </Card>
</CardGroup>

## Was ist MCP?

Das [Model Context Protocol (MCP)](https://modelcontextprotocol.io/) ist ein Open-Source-Standard, der von Anthropic eingeführt wurde und es KI-Modellen ermöglicht, sicher mit externen Datenquellen, Tools und APIs zu verbinden. Es verwendet eine Client-Server-Architektur, bei der ein Host (wie Claude) sich mit einem MCP-Server verbindet, um der KI zu ermöglichen, Datenbanken abzufragen, APIs aufzurufen oder Aktionen über eine universelle, standardisierte Schnittstelle auszuführen.

**Warum das für Helius wichtig ist:** Das MCP gibt Claude direkten Zugang zu Live-Solana-Daten und Helius-Infrastruktur — Bilanzen, Asset-Metadaten, analysierte Transaktionen, Webhook-Management, Streaming und mehr. Ohne das, muss Claude bei API-Antworten raten oder wiederholt Curl-Anfragen stellen, um Kontext zu gewinnen. Das MCP ermöglicht Claude tatsächlich mit Solana über Helius zu interagieren, indem strukturierte Tool-Aufrufe verwendet werden.

<Note>
  Die Helius-Dokumentationsseite auf [helius.dev/docs](https://www.helius.dev/docs) bietet auch einen separaten MCP-Server, der automatisch von Mintlify generiert wird. Dieser Server ist nur auf die Dokumentationssuche ausgerichtet. `helius-mcp` dokumentiert hier ist der umfassende Server, der alle Helius- und Solana-Funktionen abdeckt.
</Note>

## Schnellstart

<Steps>
  <Step title="Den MCP-Server hinzufügen">
    ```bash theme={"system"}
    claude mcp add helius npx helius-mcp@latest
    ```

    Oder fügen Sie es zur Konfiguration Ihres MCP-Hosts hinzu (Claude Desktop, Cursor, Windsurf, VS Code, etc.):

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

  <Step title="Konfigurieren Sie Ihren API-Schlüssel">
    **Wenn Sie bereits einen Schlüssel haben:**

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

    Oder setzen Sie es innerhalb von Claude, indem Sie die Aktion `setHeliusApiKey` auf `heliusAccount` aufrufen. API-Schlüssel werden in dieser Reihenfolge aufgelöst:

    1. `setHeliusApiKey` Aktionsaufruf innerhalb der Sitzung
    2. `HELIUS_API_KEY` Umgebungsvariable
    3. `~/.helius/config.json` (eingerichtet über die [Helius CLI](/docs/de/agents/cli))

    **Wenn Sie ein neues Konto benötigen:** Siehe [Anmeldung](#anmeldung) unten.
  </Step>

  <Step title="Werkzeuge verwenden">
    Stellen Sie Fragen in einfachem Englisch — das richtige Tool und die Aktion werden automatisch ausgewählt:

    * "Welche NFTs besitzt dieses Wallet?"
    * "Analysiere diese Transaktion: `5abc...`"
    * "Hol das Guthaben von `Gh9ZwEm...`"
    * "Sende 1 SOL an `7xKp...`"
    * "Erstellen Sie einen Webhook für diese Adresse"
  </Step>
</Steps>

## Verbindung mit dem Helius MCP-Server

<Tabs>
  <Tab title="Claude Code">
    Führen Sie den folgenden Befehl aus:

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

    Oder zu Ihrem Projekt hinzufügen `.mcp.json`:

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

    Überprüfen mit:

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

    <Tip>
      Möchten Sie Fähigkeiten + MCP in einem Schritt? Installieren Sie stattdessen das [Helius-Plugin](/docs/de/agents/claude-code-plugin). Führen Sie diese als zwei separate Befehle aus:

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

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

  <Tab title="Claude Desktop">
    Öffnen Sie **Einstellungen > Entwickler > Konfiguration bearbeiten** und fügen Sie den Server hinzu:

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

    Starten Sie Claude Desktop neu, um es anzuwenden.
  </Tab>

  <Tab title="Cursor">
    Öffnen Sie die Befehls-Palette (`Cmd/Ctrl + Shift + P`), suchen Sie nach **MCP: Add Server** und geben Sie ein:

    * **Name:** `helius`
    * **Befehl:** `npx helius-mcp@latest`

    Oder zu Ihrem Projekt hinzufügen `.cursor/mcp.json`:

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

  <Tab title="VS Code">
    Erstellen Sie eine `.vscode/mcp.json`-Datei im Stammverzeichnis Ihres Projekts:

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

    Erfordert die [GitHub Copilot](https://marketplace.visualstudio.com/items?itemName=GitHub.copilot)-Erweiterung mit aktivierter MCP-Unterstützung.
  </Tab>

  <Tab title="Windsurf">
    Öffnen Sie die Befehls-Palette (`Cmd/Ctrl + Shift + P`), suchen Sie nach **MCP-Server konfigurieren** und fügen Sie hinzu:

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

  <Tab title="Codex">
    Führen Sie den folgenden Befehl aus:

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

    Oder zu Ihrem `~/.codex/config.toml` (oder `.codex/config.toml` für projektbezogen):

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

    Überprüfen mit:

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

## Öffentliche Tool-Oberfläche

Helius MCP stellt **10 öffentliche Tools** bereit: 9 gerichtete Domänentools plus `expandResult`. Jede Helius- und Solana-Aktion ist als `action`-Argument auf dem entsprechenden gerichteten Tool erreichbar.

| Tool                | Bereich                                                                     |
| ------------------- | --------------------------------------------------------------------------- |
| `heliusAccount`     | Kontoerstellung, Auth, Pläne, Abrechnung                                    |
| `heliusWallet`      | Wallet-Guthaben, Bestände, Verlauf, Identität                               |
| `heliusAsset`       | Assets, NFTs, Sammlungen, Token-Inhaber                                     |
| `heliusTransaction` | Transaktionsanalyse und Wallet-Transaktionsverlauf                          |
| `heliusChain`       | Kettenzustand, Token-Konten, Blöcke, Netzwerkstatus, Programm-Accounts      |
| `heliusStreaming`   | Webhook-CRUD und Abonnementkonfiguration (WebSockets, LaserStream)          |
| `heliusKnowledge`   | Dokumente, Anleitungen, Preisgestaltung, Problemlösung, Quelle, Blog, SIMDs |
| `heliusWrite`       | Überweisungen — SOL und SPL-Token                                           |
| `heliusCompression` | Merkle-Bestätigungen für komprimierte NFTs                                  |
| `expandResult`      | Erweiterung zusammenfassungs-erster Outputs von `resultId`                  |

<Card title="Vollständiger Tool-Katalog" icon="bolt" href="/docs/de/agents/mcp/tools">
  Jede Aktion nach gerichtetem Tool gruppiert, mit Anrufdetail und `expandResult` Nutzung
</Card>

### Aufrufstruktur der gerichteten Tools

Jedes der 9 gerichteten Tools teilt eine gemeinsame Struktur:

* `action` — der auszuführende Helius-Aktionsname, wie `getBalance` oder `createWebhook`
* domänenspezifische Parameter — zum Beispiel `address`, `signatures` oder `webhookURL`
* optional `detail` — `summary`, `standard` oder `full`
* Telemetrie-Felder — `_feedback`, `_feedbackTool`, `_model`

Beispielaufruf:

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

### Zusammenfassungs-erste Antworten und `expandResult`

Schwere Antworten sind **zusammenfassungs-erste**. Gerichtete Tools geben eine kompakte Zusammenfassung plus einen `resultId` zurück, wenn die vollständige Antwort groß wäre oder wenn `detail: "summary"` angefordert wird. Verwenden Sie `expandResult` mit diesem `resultId`, um bei Bedarf einen spezifischen Abschnitt, Bereich, Seite oder Fortsetzungsabschnitt abzurufen.

Dies hält den Tokenverbrauch bei explorativen Abfragen niedrig, während es Agents gleichzeitig ermöglicht, bei Bedarf in die vollständige Nutzlast einzudringen.

## Anmeldung

Erstellen Sie ein Helius-Konto von Ihrem KI-Tool aus über einen gehosteten Zahlungs-Link oder indem Sie USDC direkt von einem lokalen Keypair bezahlen. Der Anmeldevorgang läuft über das `heliusAccount` gerichtete Tool:

<Steps>
  <Step title="Ein Keypair generieren">
    Die KI ruft `heliusAccount` mit `action: "generateKeypair"` auf — diese erstellt ein Solana-Wallet und gibt die Adresse zurück.
  </Step>

  <Step title="Die Zahlungsabsicht erstellen">
    Die KI ruft `heliusAccount` mit `action: "signup"` und `mode: "link"` auf — gibt einen `paymentUrl` zurück (z.B. `https://dashboard.helius.dev/pay/<id>`), den der Benutzer öffnet, um mit jedem Wallet zu bezahlen. Oder geben Sie `mode: "autopay"` an, um automatisch USDC vom lokalen Keypair zu senden (Wallet muss \~0.001 SOL + den Planbetrag in USDC halten).
  </Step>

  <Step title="Nach der Zahlung fortfahren">
    Nach der Bezahlung über den Link ruft die KI `heliusAccount` mit `action: "signup"` und `mode: "resume"` auf — fragt die Zahlungsabsicht ab, schließt die Konto-Provisionierung ab und konfiguriert den API-Schlüssel automatisch.
  </Step>
</Steps>

<Note>
  **Kontaktinformationen:** Jede neue Anmeldung — einschließlich des Agentenplans — erfordert `email`, `firstName` und `lastName`. `upgradePlan` erfordert dasselbe.
</Note>

Oder machen Sie dasselbe aus dem Terminal mit der [Helius CLI](/docs/de/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
```

## Netzwerkkonfiguration

Der MCP-Server verwendet standardmäßig **mainnet-beta**. Wechseln Sie über eine Umgebungsvariable zu devnet:

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

Oder rufen Sie die Aktion `setNetwork` auf `heliusAccount` innerhalb einer Sitzung auf.

## Systemaufforderungen

Das `helius-mcp`-Paket wird mit vorgefertigten Systemaufforderungen geliefert, die KI-Modelle lehren, wie man Helius-Tools effektiv einsetzt. Sie befinden sich in `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
```

Jeder enthält drei Varianten:

* `openai.developer.md` — für OpenAI Antworten/Chat-Vervollständigungs-API (`developer` Nachricht)
* `claude.system.md` — für Claude API (Systemaufforderung)
* `full.md` — eigenständig mit allen eingebetteten Referenzen (Cursor-Regeln, ChatGPT, etc.)

Siehe den [`helius-skills/SYSTEM-PROMPTS.md`](https://github.com/helius-labs/core-ai/blob/main/helius-skills/SYSTEM-PROMPTS.md) Integrationsleitfaden für Code-Beispiele.

## Fähigkeiten

Fähigkeiten sind Expertenanweisungen, die Claude beibringen, wie Anfragen an die richtigen MCP-Aktionen und Referenzdateien geroutet werden. Sie gehen über den bloßen Werkzeugzugriff hinaus — sie enthalten Routing-Logik, korrekte SDK-Muster und Regeln, die häufige Fehler verhindern.

<Card title="Fähigkeiten Übersicht" icon="brain" href="/docs/de/agents/skills/overview">
  Sechs Fähigkeiten verfügbar: Build (allgemeine Solana-Entwicklung), Phantom (Frontend-dApps), Jupiter (DeFi), DFlow (Trading-Apps), OKX (Handel und Intelligenz) und SVM (Protokollinterna)
</Card>

## Mehr erfahren

<CardGroup cols={2}>
  <Card title="Claude Code Plugin" icon="puzzle-piece" href="/docs/de/agents/claude-code-plugin">
    Ein-Klick-Installation von MCP + Fähigkeiten
  </Card>

  <Card title="Helius CLI" icon="terminal" href="/docs/de/agents/cli">
    Konto-Management über die Befehlszeile
  </Card>

  <Card title="MCP-Spezifikation" icon="book" href="https://modelcontextprotocol.io/">
    Erfahren Sie mehr über den Model Context Protocol-Standard
  </Card>

  <Card title="helius-mcp auf npm" icon="npm" href="https://www.npmjs.com/package/helius-mcp">
    Paketdetails und Versionshistorie
  </Card>

  <Card title="Changelog" icon="list" href="https://github.com/helius-labs/core-ai/blob/main/helius-mcp/CHANGELOG.md">
    Versionshistorie und Release-Notizen
  </Card>

  <Card title="Beitragen" icon="github" href="https://github.com/helius-labs/core-ai/blob/main/helius-mcp/CONTRIBUTING.md">
    Beitragshandbuch für `helius-mcp`
  </Card>
</CardGroup>