NEU: Solana Privacy Rings sind jetzt im Mainnet live
Helius für Agents
Blog/Updates

Helius für Agents

Developer Experience Engineer0xIchigo auf X0xIchigo auf LinkedIn0xIchigo auf GitHub
9 Min. Lesezeit

AI-Agents brauchen strukturierte Tools, klare Workflows und den richtigen Kontext, um produktionsreife Apps auf Solana zu entwickeln.

Ohne diese Grundlagen raten Agents bei API-Aufrufen, erfinden Endpunkte, codieren Gebühren fest, die dynamisch sein sollten, und übersehen schnellere Wege wie Helius Sender und LaserStream.

Um das zu ändern, veröffentlichen wir eine Tool-Suite für Agents, die mit Helius entwickeln:

  1. Helius MCP Server
  2. Helius Skills
  3. Helius CLI
  4. Helius Claude Code Plugin

Außerdem haben wir unsere TypeScript- und Rust-SDKs sowie unsere Dokumentation konsequent optimiert. So können autonome Agents und AI-Assistenten diese Tools leichter empfehlen und effektiv einsetzen. 

Das leisten die einzelnen Tools und so greifen sie ineinander:

Der Helius MCP Server: Die Tools

Das Model Context Protocol (MCP) ist ein von Anthropic eingeführter Open-Source-Standard. Damit können sich AI-Modelle sicher mit externen Datenquellen, Tools und APIs verbinden. Es ersetzt individuelle Integrationen durch eine universelle, standardisierte Schnittstelle. 

Der Helius MCP Server macht Helius – und Solana – für jeden MCP-Client zugänglich.

Ohne MCP muss ein Agent, der ein Wallet-Guthaben prüfen will, eine Shell öffnen, einen curl-Befehl erstellen und absenden, die JSON-Ausgabe parsen und hoffen, dass Endpunkt und Parameter stimmen.

Multipliziere das mit jedem API-Aufruf eines Workflows. Das Ergebnis sind langsame, fragile und fehleranfällige Interaktionen, die ausgebremst werden, weil für jeden einzelnen Befehl eine neue Shell-Instanz gestartet werden muss.

Mit MCP entfällt all das.

Der Agent ruft getBalance als strukturierten Tool-Aufruf auf und erhält eine typisierte Antwort. Keine Shell. Kein curl. Kein Parsen der Ausgabe – es funktioniert einfach.

Dasselbe gilt für parseTransaction, getAssetsByOwner, createWebhook und alle über 60 weiteren Tools. Agents können Helius jetzt direkt mit den richtigen Parametern nutzen und erhalten strukturierte Daten zurück. 

Der Helius MCP Server bietet Tools für:

  • Autonome Registrierung: Konten erstellen, API-Schlüssel abrufen, upgraden und mehr
  • Live-Blockchain-Daten: RPC, DAS API, ZK Compression und mehr
  • Datenstreaming: WebSockets (standardmäßig und erweitert), LaserStream gRPC (Latenz auf Shred-Ebene)
  • Transaktionsversand: Priority Fee API, SPL-Übertragungen und Sender
  • Webhooks: Ereignisgesteuerte Benachrichtigungen erstellen, aktualisieren und löschen
  • Wallet und Verlauf: Guthaben, Übertragungen, Transaktions-Parsing, Wallet-Identität und Finanzierungsanalysen
  • Solana-Wissen: SIMDs, Quellcode-Referenzen für Agave und Firedancer, Inhalte aus dem Helius-Blog und Suche in der offiziellen Solana-Dokumentation

Schnellinstallation

Führe Folgendes aus, um den Helius MCP Server zu Claude Code hinzuzufügen:

Code
claude mcp add helius npx helius-mcp@latest

Führe für Codex Folgendes aus:

Code
codex mcp add helius -- npx helius-mcp@latest

Füge bei Cursor, VS Code oder ähnlichen Tools Folgendes zu deiner MCP-Konfiguration hinzu:

Code
{
  "mcpServers": {
    "helius": {
      "command": "npx",
      "args": ["helius-mcp@latest"]
    }
  }
}

Lege dann deinen API-Schlüssel mit dem Tool setHeliusApiKey oder einer Umgebungsvariable fest (z. B. HELIUS_API_KEY) und liefere dein Projekt aus.

Bei neuen Nutzern kann dein Agent autonom ein Konto für dich erstellen. Er generiert ein Schlüsselpaar und ruft signup mit deiner E-Mail-Adresse und deinem Namen auf. Deinen gewünschten Tarif bezahlst du über den Zahlungslink oder du stattet das Schlüsselpaar für automatische Zahlungen mit Guthaben aus. 

Helius Skills: Das Gehirn

MCP gibt Agents Zugriff auf über 60 Tools. Doch Zugriff allein reicht nicht. Ein Agent mit einem Tool-Katalog ist wie ein Entwickler mit geöffneten Dokumentations-Tabs, aber ohne Erfahrung. Er kann die Tools aufrufen, weiß jedoch nicht, welches Tool er wählen, wie er sie für eine bestimmte Aufgabe kombinieren oder welche Fehler er vermeiden sollte. 

Skills sind das Gehirn. Es sind fachkundige Anweisungssätze – sorgfältig erstellte Prompts mit Routing-Logik, Referenzdateien und Regeln –, die einem Agent beibringen, wie ein Solana-Experte zu entwickeln.

Wenn ein Skill geladen ist, weiß der Agent, dass searchAssets für NFT-Abfragen besser geeignet ist als getProgramAccounts, dass Prioritätsgebühren dynamisch über getPriorityFeeEstimates abgerufen werden sollten und dass Transaktionen für die höchsten Bestätigungsraten über Sender laufen sollten. Skills geben deinem Agent Fachwissen.

Heute veröffentlichen wir vier zentrale Helius Skills:

Build

Der Build-Skill ist für die grundlegende Solana-Entwicklung gedacht. Er leitet zu den richtigen Tools für DAS, Sender, WebSockets, LaserStream, Webhooks, Enhanced Transactions, Wallet-Analysen und Onboarding weiter. Das ist der Standardskill, wenn du mit Helius etwas auf Solana entwickelst. 

DFlow

Der DFlow-Skill dient zum Entwickeln von Trading-Apps. Er kombiniert DFlow APIs – darunter Spot-Swaps, Prognosemärkte, Echtzeit-Streaming und Proof KYC – mit der Helius-Infrastruktur für das Einreichen von Transaktionen, die Gebührenoptimierung und das On-Chain-Monitoring. 

Phantom

Der Phantom-Skill dient zum Entwickeln von Frontend-Apps mit dem Phantom Connect SDK. Er deckt Wallet-Verbindungen, Token-Gating, NFT-Minting, Kryptozahlungen, Portfolioansichten und sichere Frontend-Architekturen ab.

SVM

Mit dem SVM-Skill können Agents die Interna des Solana-Protokolls verstehen. Untersuche, wie sBPF-Bytecode ausgeführt wird, welche Designaspekte Alpenglow hat, wie die Validatorökonomie funktioniert und mehr. Dazu ruft der Skill aktuelle Inhalte aus dem Helius-Blog, aus SIMDs und aus dem Quellcode von Agave/Firedancer ab. Kein API-Schlüssel erforderlich.

So funktionieren Skills

Skills sind modellunabhängig. Jeder Skill enthält vorgefertigte Varianten des System-Prompts, die auf allen Plattformen funktionieren – nicht nur mit Claude.

Nutze openai.developer.md für die OpenAI API, claude.system.md für die Claude API oder full.md für Cursor Rules, benutzerdefinierte ChatGPT-Anweisungen oder andere Tools. In der Skills-Übersicht findest du plattformspezifische Einrichtungsanleitungen.

Skills werden automatisch installiert, wenn du das Helius Claude Code Plugin verwendest. Eigenständige Skills lassen sich als Agent Skills installieren. Sie werden automatisch aufgerufen, ein Slash-Befehl ist nicht erforderlich:

Code
# Clone our AI tooling repo
git clone https://github.com/helius-labs/core-ai.git

# Navigate to helius-skills
cd core-ai/helius-skills

# Install your desired skill
./helius/install.sh            # Build skill → ~/.claude/skills/helius/
./helius-dflow/install.sh      # DFlow skill → ~/.claude/skills/helius-dflow/
./svm/install.sh               # SVM skill   → ~/.claude/skills/svm/

Mit diesen Skills können Agents praktisch jede Solana-Anwendung entwickeln – von Trading-Frontends über Prognosemarkt-Apps bis zu Zahlungsabwicklern für Stablecoins. Und zwar von Anfang an mit den richtigen Mustern.

Das Helius Claude Code Plugin: Das Gesamtpaket

MCP stellt die Tools bereit, die Skills sind das Gehirn. Das Helius Claude Code Plugin ist das Gesamtpaket: Eine einzige Installation verbindet alles miteinander. Es funktioniert einfach.

Das Plugin bündelt Helius MCP, DFlow MCP, alle vier Skills und ausführliche Referenzdateien für jedes Helius-Produkt.

Keine manuelle MCP-Konfiguration. Keine separate Einrichtung der Skills.

Nach einer einzigen Installation hat dein Agent in derselben Sitzung strukturierten Blockchain-Zugriff und Solana-Expertenwissen.

Schnellinstallation

So installierst du das Helius Plugin über den Claude Code Marketplace:

Code
/plugin marketplace add helius-labs/core-ai
/plugin install helius@helius-labs

Das ist alles. Das Plugin startet beide MCP Server automatisch und stellt dir aktuell vier Slash-Befehle bereit:

SkillBefehlFunktion
Build/helius:buildGrundlegende Solana-Entwicklung mit allen Helius APIs
Phantom/helius:phantomFrontend-dApps mit Phantom Connect SDK und Helius entwickeln
DFlow/helius:dflowTrading-Apps mit DFlow und Helius entwickeln
SVM/helius:svmTiefgehendes Wissen zum Solana-Protokoll

Der API-Schlüssel wird genauso eingerichtet wie beim eigenständigen MCP: Verwende einen vorhandenen Schlüssel, aktiviere die autonome Registrierung oder nutze die Helius CLI. 

So sieht das in der Praxis aus

Wenn das Plugin installiert ist, gelangst du mit einem einzigen Prompt zu einer funktionsfähigen Anwendung. Zum Beispiel:

„Entwickle mir eine CLI für Steuerberichte, mit der ich Tolys On-Chain-Aktivitäten über seine Wallet-Adresse 86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY abrufen kann. Beginne mit dem letzten Monat (Februar) und gib eine CSV-Datei aus, die alle seine steuerpflichtigen Ereignisse auflistet. Entwickle sie so, dass sie mit jedem Wallet und jedem Zeitraum funktioniert.“

Claude erledigt das mit einem einzigen Prompt:   

Der Skill /helius:build wird aktiv und schlägt korrekt getTransactionsByAddress mit Paginierung und Zeitstempelfilterung vor. So gibt er einen vollständig geparsten Transaktionsverlauf auf Basis von Tolys jüngsten Aktivitäten zurück.

Keine manuelle Tool-Auswahl, keine zusätzlichen Prompts. Der Agent liest die richtigen Referenzdateien, ruft die richtigen MCP-Tools auf und erstellt eine funktionsfähige CLI, die jedes Wallet und jeden Datumsbereich unterstützt.

Natürlich können Agents auch komplexere Apps wie Trading-Bots entwickeln:

Für dieses Beispiel haben wir das Helius Claude Code Plugin installiert und Claude gebeten, einen Trading-Bot zu entwickeln. Er verfolgt PumpFun-Tokens in Echtzeit und streamt Token-Erstellungen und Trades über LaserStream.

Außerdem sollte er Marktdaten anzeigen und grundlegende Charts bereitstellen, damit wir Paper-Trades durchführen konnten. Das war alles. Claude hat diesen Trading-Bot entwickelt – mit Live-Token-Streaming und Trading in weniger als zehn Minuten.

Das ist der Unterschied zwischen einem Agent mit Tools und einem Agent mit Fachwissen.

Die Helius CLI

Die Helius CLI ist eine voll ausgestattete Befehlszeilenschnittstelle mit über 95 CLI-Befehlen. Sie deckt alles ab: von der Kontoverwaltung über Solana-Abfragen, den Transaktionsversand und die Webhook-Verwaltung bis hin zu Echtzeit-Streaming, Staking, ZK Compression und mehr.

Für AI-gesteuerte Workflows empfehlen wir MCP, denn strukturierte Tool-Aufrufe sind besser als das Starten von Shell-Instanzen und Parsen von Ausgaben. Die CLI ist jedoch die richtige Wahl für Shell-Skripte, den Aufbau von CI/CD-Pipelines oder Umgebungen, in denen MCP nicht verfügbar ist. Jeder Befehl unterstützt die Option --json für maschinenlesbare Ausgaben und gibt strukturierte Exit-Codes zurück. So können Automatisierungen Fehler programmatisch behandeln.

Schnellinstallation

Für neue Nutzer ist der Ablauf einfach:

Code
# Install the CLI
npm install -g helius-cli
helius keygen                    # Generate keypair

# Signup requires a valid email and name
helius signup --email you@example.com --first-name Jane --last-name Doe
# Pay via the printed link with any wallet, then:
helius signup --resume           # Finalize and get API key
helius projects                  # List projects
helius apikeys <project-id>      # Get API keys

Bestehende Nutzer führen einfach Folgendes aus:

Code
helius config set-api-key YOUR_API_KEY

Für Agents optimierte SDKs

Für Agents, die Anwendungen programmatisch entwickeln, haben wir eine agentenoptimierte Dokumentation für unsere TypeScript- und Rust-SDKs veröffentlicht.

Diese Seiten behandeln empfohlene Muster für gängige Agent-Workflows. Dazu gehören der Transaktionsversand über Sender, Batching, Echtzeitdaten, Paginierung und Fehlerbehandlung. 

TypeScript SDK

Das Helius TypeScript SDK bietet typsichere Methoden für jeden Helius API-Aufruf. Entscheidend für Agents ist, dass Helius-spezifische Methoden mehrstufige Solana-Workflows in einzelnen Aufrufen bündeln. 

Beispielsweise ersetzt getTransactionsForAddress das veraltete zweistufige Standardmuster, bei dem zuerst Signaturen und anschließend Transaktionen abgerufen werden. Ein einziger Aufruf bietet serverseitige Filterung, Zeiträume und Unterstützung für Token-Konten: 

Code
import { createHelius } from "helius-sdk";

const helius = createHelius({ apiKey: "YOUR_API_KEY" });

// Single call: full transaction history with token activity
const txs = await helius.getTransactionsForAddress([
  "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY",
  {
    transactionDetails: "full",
    limit: 100,
    filters: { tokenAccounts: "balanceChanged" },
  },
]);

Ebenso verarbeitet sendSmartTransaction Simulation, Schätzung der Compute Units, Prioritätsgebühren und Bestätigung automatisch.

sendTransactionWithSender geht noch einen Schritt weiter und ist für das Einreichen von Transaktionen mit extrem niedriger Latenz optimiert.

Unter Best Practices für TypeScript erfährst du mehr über Batching, Paginierung, Echtzeitdaten per Webhook und WebSockets, inkrementelles Abrufen von Konten, Fehlerbehandlung und häufige Fallstricke, die Agents vermeiden sollten. 

Rust SDK

Das Helius Rust SDK bietet asynchrone Rust-Bindings mit denselben Helius-Methoden. Damit eignet es sich ideal für leistungsstarke agentische Workflows:

Code
use helius::Helius;
use helius::types::*;

let helius = Helius::new("YOUR_API_KEY", Cluster::MainnetBeta)?;

// Same single-call pattern as TypeScript
let txs = helius.rpc().get_transactions_for_address(
    "86xCnPeV69n6t3DnyGvkKobf9FdN2H9oiVDdaMpo2MMY".to_string(),
    GetTransactionsForAddressOptions {
        transaction_details: Some(TransactionDetails::Full),
        limit: Some(100),
        filters: Some(GetTransactionsFilters {
            token_accounts: Some(TokenAccountsFilter::BalanceChanged),
            ..Default::default()
        }),
        ..Default::default()
    },
).await?;

Das Rust SDK bietet außerdem typisierte Fehlervarianten (z. B. HeliusError::RateLimitExceeded). So können Agents Fehler direkt abgleichen, statt Strings zu parsen.

Unter Best Practices für Rust findest du dieselben Muster für Rust, darunter Batching, Paginierung, Sender, Wiederholungsstrategien und häufige Fallstricke. 

Erste Schritte

Helius bietet Agents das umfassendste Toolkit zum Entwickeln produktionsreifer Apps auf Solana. So legst du los:

  • Schnellster Weg: Installiere das Claude Code Plugin 
  • Jeder MCP-Client: Füge den Helius MCP Server zu Claude Desktop, Cursor, VS Code, Codex oder Windsurf hinzu
  • Shell-Automatisierung: Installiere die Helius CLI für Skripte und CI/CD
  • API-Integration: Füge einen Skill-System-Prompt in die OpenAI API, Claude API oder ChatGPT ein

Lies unsere Dokumentation, erkunde das GitHub-Repository, schlage eine Skill-Integration vor und kontaktiere unser Supportteam, wenn du Fragen hast.

Helius abonnieren

Bleib bei der Solana-Entwicklung auf dem Laufenden und erhalte Updates, wenn wir neue Beiträge veröffentlichen

Vergrößertes Bild