WebAssembly dla umiejętności AI: Luminarys AI

Luminarys AI: modułowa platforma dla izolowanych umiejętności AI w WebAssembly

Luminarys AI to platforma do wdrażania agentów AI z umiejętnościami izolowanymi w piaskownicach WebAssembly. Obsługuje tworzenie umiejętności w Go, Rust, AssemblyScript, klastrowanie na heterogenicznych architekturach oraz protokół MCP. Rozwiązuje problemy bezpieczeństwa, wielojęzyczności i skalowania w środowisku produkcyjnym.

Izolacja umiejętności w piaskownicy

Umiejętności są kompilowane do WebAssembly i wykonywane ze ścisłą izolacją zgodnie z konfiguracją. Dostęp do FS, shell, HTTP jest ograniczony białymi listami — umiejętność fizycznie nie wychodzi poza granice. Weryfikacja odbywa się przy ładowaniu: niezgodność z konfiguracją blokuje uruchomienie.

Przykład konfiguracji do monitorowania sprzętu:

# Przykład: umiejętność do pracy ze sprzętem
id: hardware-monitor
permissions:
  fs:
    enabled: true
    dirs:
      - "/sys/class:ro"               # odczyt sysfs (czujniki, urządzenia)
      - "/dev/serial:rw"              # dostęp do portów szeregowych
  shell:
    enabled: true
    allowlist:
      - "lsusb **"                    # tylko wymienione komendy
      - "i2cget **"
      - "cat /proc/cpuinfo"
    allowed_dirs:
      - "/tmp/hw-monitor"

Umiejętność dla temperatury CPU widzi tylko /sys/class/thermal, dla GPIO — /sys/class/gpio. Brak łańcuchów komend, brak ucieczki z piaskownicy.

Wielojęzyczne umiejętności z SDK

Umiejętności pisane są w Go, Rust lub AssemblyScript. Generator kodu lmsk tworzy moduły WASM z adnotowanego kodu: routing, serializację, walidację.

• AssemblyScript: kompaktowe moduły (~100 KB), składnia TS. Dla HTTP, FS, tekstu.
• Rust: wydajność, natywne biblioteki. Parsowanie protobuf/PCAP, inferencja ONNX, tree-sitter.
• Go: stdlib, osadzanie VM JS/Python.

Przykład umiejętności w Go:

// @skill:id      ai.example.hello
// @skill:name    "Hello Skill"
// @skill:version 1.0.0
// @skill:desc    "Prosta umiejętność powitalna."
package main

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

// @skill:method greet "Zwraca powitanie."
// @skill:param  name required "Imię osoby"
// @skill:result "Ciąg powitalny"
func Greet(_ *sdk.Context, name string) (string, error) {
    return "Hello, " + name + "!", nil
}

Wariant w Rust:

/// @skill:id      ai.example.hello
/// @skill:name    "Hello Skill"
/// @skill:version 1.0.0
/// @skill:desc    "Prosta umiejętność powitalna."

use luminarys_sdk::prelude::*;

/// @skill:method greet "Zwraca powitanie."
/// @skill:param  name required "Imię osoby"
/// @skill:result "Ciąg powitalny"
pub fn greet(_ctx: &mut Context, name: String) -> Result<String, SkillError> {
    Ok(format!("Hello, {}!", name))
}

AssemblyScript:

/**
 * @skill:id      ai.example.hello
 * @skill:name    "Hello Skill"
 * @skill:version 1.0.0
 * @skill:desc    "Prosta umiejętność powitalna."
 */
import { Context } from "@luminarys/sdk-as";

// @skill:method greet "Zwraca powitanie."
// @skill:param  name required "Imię osoby"
// @skill:result "Ciąg powitalny"

export function greet(_ctx: Context, name: string): string {
  return "Hello, " + name + "!";
}

Umiejętności w różnych językach ładowane są w jednym hoście, wywołują się nawzajem, dzielą stan.

Klastrowanie na heterogenicznych węzłach

Węzeł master routuje wywołania do slave na x86, ARM, RISC-V, IoT. Umiejętności nie zauważają klastra — API jest lokalne.

Scenariusze:

• CI/CD: testy na Linux-slave, kompilacja binarki Windows na Windows-slave.
• Sprzęt: Raspberry Pi dla I2C, Jetson dla wideo, x86 dla serial.
• Park IoT: master w chmurze, slaves na edge z GPIO/SPI/UART.
• Monitorowanie: sysfs, SMART, CPU/GPU w piaskownicach.

Serwer relay zapewnia transfer plików z szyfrowaniem. Przy awarii slave — automatyczna aktualizacja narzędzi.

Multi-LLM i tryb agentowy

Routing modeli według zadania/języka: deepseek-coder dla kodu, rust-specialist dla Rust. Konfiguracja bez restartu.

Tryb agentowy (rozwój):

• Batch: synchroniczne/asynchroniczne wywołania wielu umiejętności.
• Autonomia: callbacki na zdarzenia (timery, czujniki, MQTT).
• Interakcja: wywołania umiejętność→umiejętność z kontrolą głębokości/timeoutów.

Kompatybilność z MCP

Obsługa Model Context Protocol: Claude, Cursor, Open WebUI. Transporty — Streamable HTTP, SSE, stdio, OpenAPI.

Co jest ważne

• Umiejętności w piaskownicach WebAssembly wykluczają ucieczki poza uprawnienia.
• Wielojęzyczność (Go/Rust/AS) z jednolitymi adnotacjami i generatorem kodu.
• Klastrowanie rozkłada obciążenie po architekturach bez zmian API.
• Kompatybilność MCP dla integracji z Claude/Cursor/Open WebUI.
• Model callbacków dla czasu rzeczywistego i autonomicznych agentów.

— Editorial Team