WebAssembly für KI-Fähigkeiten: Luminarys AI

Luminarys AI: Eine modulare Plattform für isolierte KI-Fähigkeiten in WebAssembly

Luminarys AI ist eine Plattform zur Bereitstellung von KI-Agenten mit Fähigkeiten, die in WebAssembly-Sandboxen isoliert sind. Sie unterstützt das Schreiben von Fähigkeiten in Go, Rust und AssemblyScript, Clustering auf heterogenen Architekturen und das MCP-Protokoll. Sie adressiert Sicherheits-, Mehrsprachen- und Skalierungsherausforderungen in der Produktion.

Fähigkeitsisolierung in Sandboxen

Fähigkeiten werden in WebAssembly kompiliert und basierend auf der Konfiguration streng isoliert ausgeführt. Der Zugriff auf Dateisystem, Shell und HTTP ist über Allowlists eingeschränkt – die Fähigkeit kann physisch ihre Grenzen nicht überschreiten. Die Überprüfung erfolgt beim Laden: Konfigurationsabweichungen blockieren die Ausführung.

Beispielkonfiguration für Hardware-Monitoring:

# Beispiel: Fähigkeit für Hardware-Interaktion
id: hardware-monitor
permissions:
  fs:
    enabled: true
    dirs:
      - "/sys/class:ro"               # sysfs lesen (Sensoren, Geräte)
      - "/dev/serial:rw"              # Zugriff auf serielle Schnittstellen
  shell:
    enabled: true
    allowlist:
      - "lsusb **"                    # nur aufgeführte Befehle
      - "i2cget **"
      - "cat /proc/cpuinfo"
    allowed_dirs:
      - "/tmp/hw-monitor"

Eine Fähigkeit für CPU-Temperatur sieht nur /sys/class/thermal, für GPIO – /sys/class/gpio. Keine Befehlsketten, kein Sandbox-Escape.

Mehrsprachige Fähigkeiten mit SDK

Fähigkeiten werden in Go, Rust oder AssemblyScript geschrieben. Der lmsk-Codegenerator erstellt WASM-Module aus annotiertem Code: Routing, Serialisierung, Validierung.

• AssemblyScript: Kompakte Module (~100 KB), TS-Syntax. Für HTTP, Dateisystem, Text.
• Rust: Leistung, native Bibliotheken. Parsen von Protobuf/PCAP, ONNX-Inferenz, Tree-Sitter.
• Go: Standardbibliothek, Einbettung von JS/Python-VM.

Beispiel-Fähigkeit in Go:

// @skill:id      ai.example.hello
// @skill:name    "Hello Skill"
// @skill:version 1.0.0
// @skill:desc    "Einfache Begrüßungsfähigkeit."
package main

import sdk "github.com/LuminarysAI/sdk-go"

// @skill:method greet "Gibt eine Begrüßung zurück."
// @skill:param  name required "Personenname"
// @skill:result "Begrüßungsstring"
func Greet(_ *sdk.Context, name string) (string, error) {
    return "Hallo, " + name + "!", nil
}

Rust-Version:

/// @skill:id      ai.example.hello
/// @skill:name    "Hello Skill"
/// @skill:version 1.0.0
/// @skill:desc    "Einfache Begrüßungsfähigkeit."

use luminarys_sdk::prelude::*;

/// @skill:method greet "Gibt eine Begrüßung zurück."
/// @skill:param  name required "Personenname"
/// @skill:result "Begrüßungsstring"
pub fn greet(_ctx: &mut Context, name: String) -> Result<String, SkillError> {
    Ok(format!("Hallo, {}!", name))
}

AssemblyScript:

/**
 * @skill:id      ai.example.hello
 * @skill:name    "Hello Skill"
 * @skill:version 1.0.0
 * @skill:desc    "Einfache Begrüßungsfähigkeit."
 */
import { Context } from "@luminarys/sdk-as";

// @skill:method greet "Gibt eine Begrüßung zurück."
// @skill:param  name required "Personenname"
// @skill:result "Begrüßungsstring"
export function greet(_ctx: Context, name: string): string {
  return "Hallo, " + name + "!";
}

Fähigkeiten in verschiedenen Sprachen laden in einen einzigen Host, rufen sich gegenseitig auf, teilen Zustand.

Clustering auf heterogenen Knoten

Master-Knoten leitet Aufrufe an Slave-Knoten auf x86, ARM, RISC-V und IoT-Geräten weiter. Fähigkeiten bemerken das Cluster nicht – die API ist lokal.

Szenarien:

• CI/CD: Tests auf Linux-Slave, Build von Windows-Binärdatei auf Windows-Slave.
• Hardware: Raspberry Pi für I2C, Jetson für Video, x86 für serielle Schnittstellen.
• IoT-Flotte: Master in der Cloud, Slaves am Edge mit GPIO/SPI/UART.
• Monitoring: sysfs, SMART, CPU/GPU in Sandboxen.

Relay-Server gewährleistet verschlüsselte Dateiübertragung. Bei Slave-Ausfall – automatische Tool-Updates.

Multi-LLM und Agentenmodus

Modell-Routing nach Aufgabe/Sprache: deepseek-coder für Code, rust-specialist für Rust. Konfiguration ohne Neustart.

Agentenmodus (Entwicklung):

• Batches: Synchrone/asynchrone Aufrufe an mehrere Fähigkeiten.
• Autonomie: Callbacks bei Ereignissen (Timer, Sensoren, MQTT).
• Interaktion: Fähigkeit-zu-Fähigkeit-Aufrufe mit Tiefen-/Timeout-Kontrolle.

MCP-Kompatibilität

Unterstützung für Model Context Protocol: Claude, Cursor, Open WebUI. Transporte – Streamable HTTP, SSE, stdio, OpenAPI.

Wichtige Punkte

• Fähigkeiten in WebAssembly-Sandboxen verhindern Berechtigungsüberschreitungen.
• Mehrsprachige Unterstützung (Go/Rust/AS) mit einheitlichen Annotationen und Codegenerator.
• Clustering verteilt Last über Architekturen ohne API-Änderungen.
• MCP-Kompatibilität für Integration mit Claude/Cursor/Open WebUI.
• Callback-Modell für Echtzeit- und autonome Agenten.

— Editorial Team