
ironclaw ironclaw-v1.0.0
Sicheres, privates KI-Agenten-Betriebssystem mit lokalem verschlüsseltem Speicher, OAuth/SSO-Authentifizierung, richtlinienbasierter Zugriffskontrolle und einem erweiterbaren Tool-Building-Framework für persönliche und Produktionsbereitstellungen.
IronClaw
Ihr sicherer persönlicher KI-Assistent, immer an Ihrer Seite
English | 简体中文 | Русский | 日本語 | 한국어
Reborn-Schnellstart • Philosophie • Funktionen • Installation • Konfiguration • Sicherheit • Architektur
IronClaw Reborn Schnellstart
IronClaw Reborn ist die eigenständige Laufzeit auf dem Branch reborn-integration.
Es verwendet das separate ironclaw-reborn-Binary aus dem Paket ironclaw_reborn_cli und ein separates Reborn-Zustandsverzeichnis. Es verwendet nicht das alte ironclaw-Zustandsverzeichnis als Konfigurationsstammverzeichnis.
Für das ältere ironclaw-Binary siehe Installation und Legacy IronClaw Verwendung.
Binary erstellen oder ausführen
Vom Repository-Stammverzeichnis aus:```bash cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- --help
Oder baue es zuerst:```bash
cargo build -p ironclaw_reborn_cli --bin ironclaw-reborn
./target/debug/ironclaw-reborn --help
Das standardmäßige Reborn-Verzeichnis ist $HOME/.ironclaw/reborn. Überschreiben Sie es mit einem absoluten Pfad, wenn Sie einen isolierten Zustand wünschen:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- config path
`config path` und `doctor` sind sichere Diagnosebefehle; sie geben das ermittelte Home, Profil, `config.toml`, `providers.json` und `v1_state: not-used` aus.
Sie erstellen keinen Reborn-Status und keine Seed-Konfigurationsdateien.
### Modellroute konfigurieren
Der CLI-native Weg, um Reborns Standard-Modellroute zu konfigurieren, ist:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- models set-provider openai --model gpt-5-mini
Das schreibt $IRONCLAW_REBORN_HOME/config.toml mit [llm.default] und dem Namen der Umgebungsvariable für die Anmeldeinformationen des Anbieters. Überprüfen Sie es mit:```bash
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- models status
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- models list openai
Für OpenAI setzen Sie den geheimen Wert in der Umgebungsvariable, bevor Sie starten:```bash
export OPENAI_API_KEY="sk-..."
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- run --message "hello"
Lassen Sie --message weg oder verwenden Sie repl für eine interaktive stdin-Sitzung:```bash
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- repl
### `config.toml` Form
`config init` erstellt bearbeitbare Startdateien:```bash
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- config init
Es schreibt:
$IRONCLAW_REBORN_HOME/config.toml$IRONCLAW_REBORN_HOME/providers.json
Eine minimal konfigurierte Modellroute sieht wie folgt aus:```toml [llm.default] provider_id = "openai" model = "gpt-5-mini" api_key_env = "OPENAI_API_KEY"
`config.toml` kann auch optionale Abschnitte wie `[boot]`,
`[identity]`, `[runner]` und `[skills]` enthalten; `config init` schreibt kommentierte
Anleitungen für die unterstützten Felder.
Fehlt `config.toml`, erstellt der erste zustandsbehaftete Laufzeitstart mittels `run`,
`repl` oder `serve` eine dünnbesetzte Datei mit `api_version` und dem sicheren
`local-dev` Boot-Profil. Schreibgeschützte Befehle und `run --dry-run` bleiben
nebenwirkungsfrei. Einmalige Umgebungsauswahlen wie
`IRONCLAW_REBORN_PROFILE=local-dev-yolo` werden nicht in die erstellte Datei übernommen.
Wichtig: `api_key_env` ist der Name einer Umgebungsvariablen, nicht das Geheimnis
selbst. Reborn lehnt Inline-Geheimniswerte in `config.toml` und
`providers.json` ab.
Der Produktionsspeicher verwendet das gleiche reine-Umgebungsvariablen-Muster. Eine Produktions-Reborn-Konfiguration
kann die PostgreSQL-URL-Variable benennen, darf aber die rohe URL nicht enthalten:```toml
[storage]
backend = "postgres"
url_env = "IRONCLAW_REBORN_POSTGRES_URL"
secret_master_key_env = "IRONCLAW_REBORN_SECRET_MASTER_KEY"
# Optional; defaults to 2. Keep below the PostgreSQL server or managed
# session-pool cap after reserving capacity for restarts and operator sessions.
pool_max_size = 2
[policy]
deployment_mode = "hosted_multi_tenant"
default_profile = "secure_default"
Setzen Sie IRONCLAW_REBORN_POSTGRES_URL in der Prozessumgebung und setzen Sie IRONCLAW_REBORN_SECRET_MASTER_KEY auf unabhängiges kryptografisches Schlüsselmaterial.
Verwaltete entfernte PostgreSQL-Anbieter müssen TLS verwenden, beispielsweise durch Anhängen von sslmode=require.
Der Produktions-run erfordert auch einen expliziten [policy]-Abschnitt. Der erste Produktionsstart-Slice unterstützt Laufzeitrichtlinien, die keine Tenant-Sandbox-Prozessbindung erfordern.
Sobald [llm.default] existiert, wählt diese Konfiguration den Anbieter aus. LLM_BACKEND ist nur ein Umgebungs-Fallback, wenn kein standardmäßiger LLM-Slot konfiguriert ist. Um nach dem Schreiben der Konfiguration den Anbieter zu wechseln, verwenden Sie models set-provider <provider> oder bearbeiten Sie [llm.default].provider_id.
Nur-Umgebungs-Modellauswahl
Wenn $IRONCLAW_REBORN_HOME/config.toml fehlt oder kein [llm.default] enthält, kann Reborn das LLM aus Umgebungsvariablen auflösen. Eine spärliche, beim ersten Start bereitgestellte Konfiguration enthält kein [llm.default], sodass die Nur-Umgebungs-Modellauswahl weiterhin funktioniert:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-env-only"
export LLM_BACKEND=openai
export OPENAI_API_KEY="sk-..."
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- run --message "hello"
Gemeinsame Anbieter-Umgebungsvariablen:
| Anbieter | Selektor | Erforderliche Umgebungsvariable |
| --- | --- | --- |
| OpenAI | `LLM_BACKEND=openai` | `OPENAI_API_KEY`; optional `OPENAI_MODEL`, `OPENAI_BASE_URL` |
| Anthropic | `LLM_BACKEND=anthropic` | `ANTHROPIC_API_KEY`; optional `ANTHROPIC_MODEL`, `ANTHROPIC_BASE_URL` |
| OpenAI-kompatibel | `LLM_BACKEND=openai_compatible` | `LLM_BASE_URL`; optional `LLM_API_KEY`, `LLM_MODEL` |
| OpenRouter | `LLM_BACKEND=openrouter` | `OPENROUTER_API_KEY`; optional `OPENROUTER_MODEL` |
| Ollama | `LLM_BACKEND=ollama` | kein Schlüssel; optional `OLLAMA_BASE_URL`, `OLLAMA_MODEL` |
| Codex-Auth | `LLM_BACKEND=openai_codex` | `LLM_USE_CODEX_AUTH=true` oder `CODEX_AUTH_PATH`; optional `OPENAI_CODEX_MODEL` |
Verwende `models list <anbieter>`, um die genauen in den aktuellen Branch kompilierten Anbieter-Metadaten zu sehen.
### Startvariablen
| Variable | Zweck |
| --- | --- |
| `IRONCLAW_REBORN_HOME` | Absolutes Reborn-Status-Wurzelverzeichnis. Standardmäßig `$HOME/.ironclaw/reborn`. Der Resolver lehnt unsichere Pfade und v1-Status-Wurzel-Aliase wie `$HOME/.ironclaw` ab. |
| `IRONCLAW_REBORN_PROFILE` | Boot-Profil-Auswahl. Unterstützte Werte: `local-dev`, `local-dev-yolo`, `hosted-single-tenant`, `hosted-single-tenant-volume`, `production`, `migration-dry-run`. |
| `IRONCLAW_REBORN_POSTGRES_URL` | Produktive PostgreSQL-Speicher-URL, wenn `[storage].backend = "postgres"` und `[storage].url_env` diese Variable benennt. Halte sie aus `config.toml` heraus; entfernte Anbieter müssen TLS verwenden. |
| `IRONCLAW_REBORN_POSTGRES_POOL_MAX_SIZE` | Optionale Überschreibung der PostgreSQL-Client-Pool-Größe für Reborn. Verwende dies, wenn ein verwalteter Anbieter eine kleine Sitzungspool-Obergrenze erzwingt. |
| `IRONCLAW_FILESYSTEM_POSTGRES_MIGRATION_CONNECT_MAX_WAIT_SECS` | Optionales Wartezeitfenster beim Start für Wiederholungsversuche der Postgres-Dateisystem-Migrationsverbindung. Standardmäßig 300 Sekunden. |
| `IRONCLAW_REBORN_SECRET_MASTER_KEY` | Produktiver Reborn-Geheim-Hauptschlüssel, wenn `[storage].secret_master_key_env` diese Variable benennt. Halte ihn unabhängig von der Datenbank-URL und außerhalb von `config.toml`. |
| `IRONCLAW_REBORN_LOG` | Tracing-Filter für die Reborn-Binärdatei, zum Beispiel `debug,ironclaw_runner=trace`. |
`run` und `repl` unterstützen derzeit lokale Laufzeit-Komposition über `local-dev`, `local-dev-yolo` und `hosted-single-tenant-volume`.
`hosted-single-tenant-volume` verwendet das lokale libSQL-Substrat unter `$IRONCLAW_REBORN_HOME/hosted-single-tenant-volume`, löst die gehostete sichere Standard-Laufzeitrichtlinie auf und deaktiviert prozessgestützte Werkzeuge wie Shell. Es ist für Preview-Bereitstellungen mit einem einzelnen Mandanten auf einem persistenten Volume gedacht, nicht als vollständige PostgreSQL-Produktionskomposition.
`local-dev-yolo` gewährt vertrauenswürdigen Laptop-Host-Zugriff und muss explizit bestätigt werden:```bash
export IRONCLAW_REBORN_PROFILE=local-dev-yolo
cargo run -q -p ironclaw_reborn_cli --bin ironclaw-reborn -- repl --confirm-host-access
WebUI-Dienst
Der Reborn WebUI wird mit dem Cargo-Feature webui-v2-beta kompiliert. Builds mit diesem Feature erfordern Node.js 22 mit Corepack/pnpm, damit Cargo das SPA-Bundle generieren und einbetten kann. Erstellen oder führen Sie die Binärdatei mit diesem Feature aus, um den Befehl serve zu aktivieren:```bash
cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve --help
cargo build -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn
Der WebUI-Listener hört standardmäßig auf `127.0.0.1:3000`. Der Dienst benötigt beim Start einen env-bearer Token und eine Benutzer-ID. Er benötigt außerdem die Modell-Route aus dem vorherigen Abschnitt, einschließlich der Credential-Umgebungsvariable dieses Anbieters:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"
cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve
Äquivalente config.toml-Listener-Konfiguration:```toml
[webui]
listen_host = "127.0.0.1"
listen_port = 3000
env_token_var = "IRONCLAW_REBORN_WEBUI_TOKEN"
env_user_id_var = "IRONCLAW_REBORN_WEBUI_USER_ID"
allowed_origins = ["http://127.0.0.1:3000", "http://localhost:3000"]
canonical_host = "127.0.0.1:3000"
`env_token_var` und `env_user_id_var` sind Umgebungsvariablen-Namen. Bewahren Sie das eigentliche Token und die Benutzer-ID in der Umgebung.
Erforderliche WebUI-Umgebungsvariablen:
| Variable | Zweck |
| --- | --- |
| `IRONCLAW_REBORN_WEBUI_TOKEN` | Bearer-Token für WebUI-Anfragen. Wenn SSO aktiviert ist, signiert dies auch Sitzungen und muss mindestens 32 Bytes lang sein. |
| `IRONCLAW_REBORN_WEBUI_USER_ID` | Reborn-Besitzer-/Benutzer-ID für Env-Bearer-Anfragen. Wenn `[identity].default_owner` konfiguriert ist, muss es mit diesem Wert übereinstimmen. |
Optionale WebUI-OAuth-Umgebungsvariablen:
| Variable | Zweck |
| --- | --- |
| `IRONCLAW_REBORN_WEBUI_BASE_URL` | Öffentliche Basis-URL, die für WebUI-Login und Produkt-Auth-OAuth-Callbacks verwendet wird. Nicht-Loopback-Bereitstellungen müssen `https://` verwenden. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_ID` | Aktiviert Google SSO, wenn gesetzt. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_SECRET` | Erforderlich, wenn Google SSO aktiviert ist. |
| `IRONCLAW_REBORN_WEBUI_GOOGLE_ALLOWED_HD` | Optionale Google-gehostete-Domain-Einschränkung. |
| `IRONCLAW_REBORN_WEBUI_GITHUB_CLIENT_ID` | Aktiviert GitHub SSO, wenn gesetzt. |
| `IRONCLAW_REBORN_WEBUI_GITHUB_CLIENT_SECRET` | Erforderlich, wenn GitHub SSO aktiviert ist. |
| `IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS` | Erforderlich, wenn ein SSO-Anbieter aktiviert ist. Kommagetrennte verifizierte E-Mail-Domains. |
| `IRONCLAW_REBORN_WEBUI_OAUTH_HTTP_TIMEOUT_SECS` | Optionaler OAuth-HTTP-Timeout-Override. |
Für Google SSO erstellen Sie einen Google OAuth-Web-Client und registrieren Sie die Reborn WebUI-Weiterleitungs-URI als:```text
{IRONCLAW_REBORN_WEBUI_BASE_URL}/auth/callback/google
Zum Beispiel mit IRONCLAW_REBORN_WEBUI_BASE_URL=https://ironclaw.example.com ist die autorisierte Weiterleitungs-URI in Google Cloud:```text
https://ironclaw.example.com/auth/callback/google
Notion MCP und andere Produkt-Auth OAuth-Setup-Flows verwenden dieselbe öffentliche WebUI-Basis-URL, wenn sie Anbieter-Callback-URLs registrieren. Fügen Sie keinen abschließenden Schrägstrich in `IRONCLAW_REBORN_WEBUI_BASE_URL` ein; Reborn entfernt ihn vor dem Aufbau der Callback-URLs. Wenn die Basis-URL weggelassen wird, verwendet Reborn die tatsächliche Listener-Adresse, wie `http://127.0.0.1:3000`, die nur für Loopback/lokale OAuth-Tests geeignet ist. Öffentliche oder nicht-Loopback-OAuth-Bereitstellungen müssen eine `https://`-Basis-URL festlegen.
Vollständige Google SSO-Startup-Umgebung:```bash
export IRONCLAW_REBORN_HOME="/var/lib/ironclaw-reborn"
export IRONCLAW_REBORN_PROFILE=local-dev
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"
export IRONCLAW_REBORN_WEBUI_BASE_URL="https://ironclaw.example.com"
export IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS="example.com,team.example.com"
export IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_ID="..."
export IRONCLAW_REBORN_WEBUI_GOOGLE_CLIENT_SECRET="..."
cargo run -q -p ironclaw_reborn_cli --features webui-v2-beta --bin ironclaw-reborn -- serve --host 0.0.0.0 --port 3000
IRONCLAW_REBORN_WEBUI_ALLOWED_EMAIL_DOMAINS ist die eigentliche Zulassungsliste. Google hd ist nur ein optionaler, anbieterseitiger Hinweis auf die gehostete Domäne; verlassen Sie sich nicht darauf anstelle der Reborn-Liste der erlaubten Domänen. IRONCLAW_REBORN_HOME wählt das Status-/Konfigurationsstammverzeichnis für diesen Dienst. IRONCLAW_REBORN_PROFILE hat den Standardwert local-dev; local-dev-yolo gewährt vertrauenswürdigen Laptop-Hostzugriff und kann nicht auf einem Nicht-Loopback-Host bereitgestellt werden.
Verwenden Sie serve --host <ip> --port <port>, um den Listener von der CLI aus zu überschreiben. Das Binden an einen Nicht-Loopback-Host ist produktionssensitiv. Der Serve-Modus local-dev-yolo erfordert außerdem --confirm-host-access und lehnt Nicht-Loopback-Hosts ab.
Slack-Dienst
Die Slack-Unterstützung ist hinter dem Cargo-Feature slack-v2-host-beta kompiliert. Dieses Feature enthält webui-v2-beta, sodass Slack mit demselben Befehl serve ausgeführt wird:```bash
export IRONCLAW_REBORN_HOME="$PWD/.reborn-home"
export OPENAI_API_KEY="sk-..." # or the required env var for your configured provider
export IRONCLAW_REBORN_WEBUI_TOKEN="$(openssl rand -hex 32)"
export IRONCLAW_REBORN_WEBUI_USER_ID="reborn-cli"
export IRONCLAW_REBORN_SLACK_ENABLED="true"
cargo run -q -p ironclaw_reborn_cli --features slack-v2-host-beta --bin ironclaw-reborn -- serve
Aktivieren Sie Slack, indem Sie `IRONCLAW_REBORN_SLACK_ENABLED=true` setzen oder einen `[slack]`-Abschnitt zu `config.toml` hinzufügen:```toml
[slack]
enabled = true
Die Umgebungsvariable überschreibt nur das Slack-Routen-Aktivierungsgate: true/1 montiert Slack, während false/0 als Bereitstellungs-Kill-Switch fungiert. Nach dem Serverstart konfigurieren Sie die Slack-App-IDs, Bot-Token, Signing-Secret und Channel-Zuordnungen über die WebUI-Channel-Einrichtung.
Erforderliche Slack-Einstellungen:
| Name | Zweck |
|---|---|
[slack].enabled = true oder IRONCLAW_REBORN_SLACK_ENABLED=true | Montiert die Slack-Route während serve. |
| WebUI Slack Workspace-Einrichtung | Speichert Slack-Installations-IDs, Channel-Zuordnungen sowie Slack-Bot-/Signing-Secrets. |
Ausführlichere Hinweise zur Slack-Einrichtung finden Sie in
docs/reborn/setup-slack-for-reborn-binary.md.
Philosophie
IronClaw basiert auf einem einfachen Prinzip: Ihr KI-Assistent sollte für Sie arbeiten, nicht gegen Sie.
In einer Welt, in der KI-Systeme zunehmend undurchsichtig in der Datenverarbeitung sind und an Unternehmensinteressen ausgerichtet werden, verfolgt IronClaw einen anderen Ansatz:
- Ihre Daten gehören Ihnen – Alle Informationen werden lokal gespeichert, verschlüsselt und verlassen niemals Ihre Kontrolle
- Transparenz von Grund auf – Open Source, überprüfbar, keine versteckte Telemetrie oder Datensammlung
- Sich selbst erweiternde Fähigkeiten – Neue Tools spontan erstellen, ohne auf Updates des Anbieters warten zu müssen
- Mehrschichtige Verteidigung – Mehrere Sicherheitsebenen schützen vor Prompt-Injection und Datenexfiltration
IronClaw ist der KI-Assistent, dem Sie Ihr privates und berufliches Leben tatsächlich anvertrauen können.
Funktionen
Sicherheit steht an erster Stelle
- WASM-Sandbox – Nicht vertrauenswürdige Tools laufen in isolierten WebAssembly-Containern mit berechtigungsbasierten Berechtigungen
- Credential-Schutz – Geheimnisse werden niemals Tools ausgesetzt; werden an der Host-Grenze mit Erkennung von Lecks injiziert
- Prompt-Injection-Abwehr – Mustererkennung, Inhaltsbereinigung und Richtliniendurchsetzung
- Endpoint-Allowlisting – HTTP-Anfragen nur an explizit genehmigte Hosts und Pfade
Immer verfügbar
- Mehrkanal – REPL, HTTP-Webhooks, WASM-Kanäle (Telegram, Slack) und Web-Gateway
- Docker-Sandbox – Isolierte Container-Ausführung mit tokens pro Auftrag und Orchestrator/Worker-Muster
- Web-Gateway – Browser-UI mit Echtzeit-SSE/WebSocket-Streaming
- Routinen – Cron-Zeitpläne, Ereignis-Trigger, Webhook-Handler für Hintergrundautomatisierung
- Herzschlag-System – Proaktive Hintergrundausführung für Überwachungs- und Wartungsaufgaben
- Parallele Aufträge – Gleichzeitige Bearbeitung mehrerer Anfragen mit isolierten Kontexten
- Selbstreparatur – Automatische Erkennung und Wiederherstellung hängengebliebener Vorgänge
Selbstexpandierend
- Dynamisches Tool-Building – Beschreiben Sie, was Sie brauchen, und IronClaw erstellt es als WASM-Tool
- MCP-Protokoll – Verbindung zu Model Context Protocol-Servern für zusätzliche Fähigkeiten
- Plugin-Architektur – Neue WASM-Tools und Kanäle ohne Neustart einbinden
Beständiger Speicher
- Hybride Suche – Volltext- + Vektorsuche mit Reciprocal Rank Fusion
- Workspace-Dateisystem – Flexibler pfadbasierter Speicher für Notizen, Logs und Kontext
- Identitätsdateien – Konsistente Persönlichkeit und Präferenzen über Sitzungen hinweg beibehalten
Installation
Voraussetzungen
- Rust 1.96+
- PostgreSQL 15+ mit pgvector-Erweiterung
- Node.js 22+ mit Corepack/pnpm für Quellcode-Builds, die das
webui-v2-beta-Feature aktivieren - NEAR AI-Konto (Authentifizierung erfolgt über den Setup-Assistenten)
libclangund eine funktionierende C-Toolchain, wenn Sie den WeChat-Voice-/SILK-Pfad aus dem Quellcode erstellen
Herunterladen oder Erstellen
Besuchen Sie die Releases-Seite, um die neuesten Aktualisierungen zu sehen.
Installieren über Windows Installer (Windows)
Laden Sie den Windows Installer herunter und führen Sie ihn aus.
Installieren über PowerShell-Skript (Windows)
```sh irm https://github.com/nearai/ironclaw/releases/latest/download/ironclaw-installer.ps1 | iex ```Installation per Shell-Skript (macOS, Linux, Windows/WSL)
```sh curl --proto '=https' --tlsv1.2 -LsSf https://github.com/nearai/ironclaw/releases/latest/download/ironclaw-installer.sh | sh ```Installation via Homebrew (macOS/Linux)
```sh brew install ironclaw ```Kompilieren Sie den Quellcode (Cargo unter Windows, Linux, macOS)
Installieren Sie es mit cargo; stellen Sie sicher, dass Sie Rust auf Ihrem Computer installiert haben.```bash
Clone the repository
git clone https://github.com/nearai/ironclaw.git cd ironclaw
Build
cargo build --release
Run tests
cargo test
Für **vollständige Version** (nach Änderung der Kanalquellen) führen Sie `./scripts/build-all.sh` aus, um die Kanäle zuerst neu zu erstellen.
> **Optional:** WeChat-Sprachnotizen (`audio/silk`) benötigen das eigenständige
> `ironclaw-silk-decoder`-Hilfsprogramm, um transkribierbar zu sein. Es ist vom
> Standard-Workspace-Build ausgeschlossen, da `silk-codec` `bindgen`/`libclang`
> erfordert. Erstellen Sie es separat mit `./crates/ironclaw_silk_decoder/build.sh`
> (benötigt libclang + eine C-Toolchain) und legen Sie die resultierende
> Binärdatei in `$PATH`, neben der `ironclaw`-Binärdatei, oder verweisen Sie
> darauf mit `IRONCLAW_SILK_DECODER`. Ohne sie werden Sprachnachrichten weiterhin
> zugestellt — jedoch als rohe `audio/silk`-Blobs.
</details>
### Datenbank-Setup```bash
# Create database
createdb ironclaw
# Enable pgvector
psql ironclaw -c "CREATE EXTENSION IF NOT EXISTS vector;"
Konfiguration
Führen Sie den Setup-Assistenten aus, um IronClaw zu konfigurieren:```bash ironclaw onboard
Der Assistent kümmert sich um die Datenbankverbindung, die NEAR AI-Authentifizierung (über Browser-OAuth) und die Verschlüsselung von Geheimnissen (mithilfe Ihrer Systemsicherung). Einstellungen werden in der verbundenen Datenbank gespeichert; Bootstrap-Variablen (z. B. `DATABASE_URL`, `LLM_BACKEND`) werden in `~/.ironclaw/.env` geschrieben, sodass sie verfügbar sind, bevor die Datenbank verbunden wird.
### Alternative LLM-Anbieter
IronClaw standardmäßig NEAR AI, unterstützt aber viele LLM-Anbieter sofort. Zu den integrierten Anbietern gehören **Anthropic**, **OpenAI**, **GitHub Copilot**, **Google Gemini**, **MiniMax**, **Mistral** und **Ollama** (lokal). OpenAI-kompatible Dienste wie **OpenRouter** (300+ Modelle), **Together AI**, **Fireworks AI** und selbst gehostete Server (**vLLM**, **LiteLLM**) werden ebenfalls unterstützt.
Wählen Sie Ihren Anbieter im Assistenten aus oder setzen Sie Umgebungsvariablen direkt:```env
# Example: MiniMax (built-in, 204K context)
LLM_BACKEND=minimax
MINIMAX_API_KEY=...
# Example: OpenAI-compatible endpoint
LLM_BACKEND=openai_compatible
LLM_BASE_URL=https://openrouter.ai/api/v1
LLM_API_KEY=sk-or-...
LLM_MODEL=anthropic/claude-sonnet-4
Siehe docs/capabilities/llm-providers.md für eine vollständige Anleitung zu den Anbietern.
Sicherheit
IronClaw setzt auf eine mehrschichtige Verteidigung, um Ihre Daten zu schützen und Missbrauch zu verhindern.
WASM Sandbox
Alle nicht vertrauenswürdigen Tools werden in isolierten WebAssembly-Containern ausgeführt:
- Fähigkeitsbasierte Berechtigungen - Explizites Opt-in für HTTP, Secrets und Tool-Aufrufe
- Endpunkt-Allowlisting - HTTP-Anfragen nur an genehmigte Hosts/Pfade
- Credential-Injection - Secrets werden an der Host-Grenze injiziert, niemals dem WASM-Code ausgesetzt
- Leckerkennung - Scannt Anfragen und Antworten auf Geheimnis-Exfiltrationsversuche
- Ratenbegrenzung - Pro-Tool-Anfragegrenzen, um Missbrauch zu verhindern
- Ressourcenbeschränkungen - Einschränkungen für Arbeitsspeicher, CPU und Ausführungszeit``` WASM ──► Allowlist ──► Leak Scan ──► Credential ──► Execute ──► Leak Scan ──► WASM Validator (request) Injector Request (response)
### Schutz vor Prompt-Injection
Externe Inhalte durchlaufen mehrere Sicherheitsebenen:
- Musterbasierte Erkennung von Injectionsversuchen
- Inhaltsbereinigung und Escape-Verarbeitung
- Richtlinienregeln mit Schweregraden (Blockieren/Warnen/Prüfen/Bereinigen)
- Tool-Ausgabeumhüllung für sichere LLM-Kontext-Injektion
### Datenschutz
- Alle Daten werden lokal in Ihrer PostgreSQL-Datenbank gespeichert
- Geheimnisse mit AES-256-GCM verschlüsselt
- Keine Telemetrie, Analyse oder Datenweitergabe
- Vollständiges Prüfprotokoll aller Tool-Ausführungen
## Architektur```
┌────────────────────────────────────────────────────────────────┐
│ Channels │
│ ┌──────┐ ┌──────┐ ┌─────────────┐ ┌─────────────┐ │
│ │ REPL │ │ HTTP │ │WASM Channels│ │ Web Gateway │ │
│ └──┬───┘ └──┬───┘ └──────┬──────┘ │ (SSE + WS) │ │
│ │ │ │ └──────┬──────┘ │
│ └─────────┴──────────────┴────────────────┘ │
│ │ │
│ ┌─────────▼─────────┐ │
│ │ Agent Loop │ Intent routing │
│ └────┬──────────┬───┘ │
│ │ │ │
│ ┌──────────▼────┐ ┌──▼───────────────┐ │
│ │ Scheduler │ │ Routines Engine │ │
│ │(parallel jobs)│ │(cron, event, wh) │ │
│ └──────┬────────┘ └────────┬─────────┘ │
│ │ │ │
│ ┌─────────────┼────────────────────┘ │
│ │ │ │
│ ┌───▼─────┐ ┌────▼────────────────┐ │
│ │ Local │ │ Orchestrator │ │
│ │Workers │ │ ┌───────────────┐ │ │
│ │(in-proc)│ │ │ Docker Sandbox│ │ │
│ └───┬─────┘ │ │ Containers │ │ │
│ │ │ │ ┌───────────┐ │ │ │
│ │ │ │ │Worker / CC│ │ │ │
│ │ │ │ └───────────┘ │ │ │
│ │ │ └───────────────┘ │ │
│ │ └─────────┬───────────┘ │
│ └──────────────────┤ │
│ │ │
│ ┌───────────▼──────────┐ │
│ │ Tool Registry │ │
│ │ Built-in, MCP, WASM │ │
│ └──────────────────────┘ │
└────────────────────────────────────────────────────────────────┘
Kernkomponenten
| Komponente | Zweck |
|---|---|
| Agent Loop | Hauptnachrichtenverarbeitung und Job-Koordination |
| Router | Klassifiziert Benutzerabsicht (Befehl, Abfrage, Aufgabe) |
| Scheduler | Verwaltet parallele Job-Ausführung mit Prioritäten |
| Worker | Führt Jobs mit LLM-Argumentation und Tool-Aufrufen aus |
| Orchestrator | Container-Lebenszyklus, LLM-Proxy, Authentifizierung pro Job |
| Web Gateway | Browser-UI mit Chat, Speicher, Jobs, Logs, Erweiterungen, Routinen |
| Routines Engine | Geplante (Cron) und reaktive (Ereignis, Webhook) Hintergrundaufgaben |
| Workspace | Persistenter Speicher mit hybrider Suche |
| Safety Layer | Prompt-Injection-Abwehr und Inhaltsbereinigung |
IronClaw Verwendung```bash
First-time setup (configures database, auth, etc.)
ironclaw onboard
Start interactive REPL
cargo run
REPL with debug logging
RUST_LOG=ironclaw=debug cargo run
## Entwicklung```bash
# Format code
cargo fmt
# Lint
cargo clippy --all --benches --tests --examples --all-features
# Run tests
createdb ironclaw_test
cargo test
# Run specific test
cargo test test_name
- Channels: Siehe docs/channels/overview.mdx für die Einrichtung von Telegram, Discord und anderen Kanälen.
- Changing channel sources: Führen Sie
./channels-src/telegram/build.shvorcargo buildaus, damit die aktualisierte WASM eingebunden wird.
OpenClaw Erbe
IronClaw ist eine Rust-Neuimplementierung, inspiriert von OpenClaw. Siehe FEATURE_PARITY.md für die vollständige Tracking-Matrix.
Wesentliche Unterschiede:
- Rust vs TypeScript - Native Leistung, Speichersicherheit, einzelne Binärdatei
- WASM-Sandbox vs Docker - Leichtgewichtig, capability-basierte Sicherheit
- PostgreSQL vs SQLite - Produktionsreife Persistenz
- Security-first-Design - Mehrere Verteidigungsebenen, Schutz von Anmeldeinformationen
Lizenz
Lizenziert unter einer der folgenden Lizenzen:
- Apache License, Version 2.0 (LICENSE-APACHE)
- MIT License (LICENSE-MIT)
nach Ihrer Wahl.