ULTRON Control Center

Was ist das?

Dein KI-Assistent vergisst alles, sobald du das Fenster schließt: die Entscheidungen, die ihr getroffen habt, die Fehler, die ihr bereits gelöst habt, wie dein Projekt aufgebaut ist. Am nächsten Tag erklärst du ihm alles wieder.

ULTRON gibt ihm Gedächtnis. Während du arbeitest, speichert es das Wichtige auf deinem eigenen Rechner; wenn du eine neue Unterhaltung öffnest, erinnert es die KI automatisch daran. Du tust nichts: du arbeitest wie immer und dein Assistent lernt dich mit der Zeit immer besser kennen. Du entscheidest, was gespeichert wird (alles durchläuft ein Genehmigungsfach) und nichts verlässt deinen Rechner.

Lokaler Event-Sourced-Speicher (brain.db, SQLite) mit semantischem Index (Qdrant + E5 1024d), der in jede Sitzung mittels Hooks zurückinjiziert wird — hybrider Sub-Sekunden-Recall mit einem residenten Daemon. Außerdem: AI Router mit mehreren Anbietern, Orchestrator für Skills/Agenten und Desktop-Cockpit (Tauri 2 + React 19). Der gesamte Zustand sind lokale, überprüfbare Dateien. Spezifikation: docs/memory-spec.md.

Related MCP server: MCP Memory Server

Mit und ohne ULTRON

Im Vergleich zu anderen Speichersystemen (Cloud-Dienste wie Mem0 und ähnliche) sind die Unterschiede konzeptionell, nicht marketingtechnisch: hier ist der Speicher 100 % lokal (ohne Konto, ohne Abonnement, ohne deinen Code an Dritte zu senden), gesteuert (die KI schlägt vor, du genehmigst; jeder Schreibvorgang hinterlässt ein Prüfereignis), ehrlich (wenn sie es nicht weiß, enthält sie sich, anstatt Füllmaterial einzuspritzen – gemessen) und offen (SQLite + Markdown + ein standardmäßiger MCP-Server, den jeder Assistent abfragen kann).

Tägliches Tutorial (Mensch + KI): docs/TUTORIAL.md · Vollständige Spezifikation des Speichersystems: docs/memory-spec.md · Komponentenweise Installation: INSTALL.md · MIT-Lizenz.

Wie der Speicher fließt

flowchart LR
    A[Prompt en Claude Code] -->|hook UserPromptSubmit| B[daemon ultron-memory<br/>E5 residente]
    B --> C[(brain.db<br/>SQLite + FTS5)]
    B --> D[(Qdrant<br/>E5 1024d)]
    C -->|BM25| E[Fusion RRF + cross-encoder]
    D -->|dense| E
    E -->|pack de memorias| A
    F[Fin de sesion] -->|hook Stop| G[Captura -> inbox de candidatos]
    G -->|aprobacion| C
    H[Cualquier cliente MCP<br/>Codex, Gemini CLI...] -->|MCP server| B

Reale Zahlen (gemessen, nicht simuliert)

Gemessen am realen Korpus des Maintainers (~3.300 aktive Erinnerungen) mit einem Orakel von 29 handgelabelten Abfragen – deine Installation startet leer und die Recall-Zahlen hängen von deinem Korpus ab. Reproduzierbar mit ultron-memory eval --golden und den Skripten im Repo.

Wenn der Korpus die Antwort nicht kennt, enthält sich das System, anstatt Füllmaterial einzuspritzen – die Ehrlichkeit des Recalls ist ebenfalls gemessen (Kategorie „abstain" des eigenen Benchmarks).

Schnellstart

Vollständiges System (App + Skills + Hooks + semantischer Speicher) – der empfohlene Weg; es ist idempotent und fragt, bevor es etwas anfasst:

git clone https://github.com/SkiTemplar/ultron-control-center.git $env:USERPROFILE\.ultron
cd $env:USERPROFILE\.ultron
powershell -ExecutionPolicy Bypass -File .\install.ps1   # Linux: ./install.sh

Komponentenweise Installation (ohne Assistent, deterministisch; -DryRun listet den Plan auf, ohne etwas anzufassen):

.\install.ps1 -Core            # app + memoria + hooks (el set por defecto)
.\install.ps1 -All             # core + skills + tones + agents
.\install.ps1 -Skills -Tones   # a la carta
.\install.ps1 -Core -DryRun    # solo listar que haria
# Linux: ./install.sh --core | --all | --skills | --tones | --agents | --dry-run

Nur die Desktop-App (ohne Skills/Hooks/Sidecar für Speicher):

git clone https://github.com/SkiTemplar/ultron-control-center.git ~/.ultron && cd ~/.ultron/control-center
cp ../.env.example ../.env   # opcional: claves de proveedores LLM (todas vacias por defecto)
npm install
npm run build:app            # = kill-app + tauri build -> ejecutable de escritorio

Vollständige Anleitung (Bootstrap-One-Liner aus Release, Flags, Fehlerbehebung): INSTALL.md.

Qdrant ist optional (der Recall degradiert ohne Qdrant zu reinem Sparse); siehe den Qdrant-Abschnitt von docs/INSTALL-ADVANCED.md. Die maschinenspezifischen Pfade sind dokumentiert in config/paths.example.toml.

Funktionen

• Gesteuerter Speicher — brain.db (SQLite) als einzige Quelle der Wahrheit; jede Änderung durchläuft einen einzigen Dienst, der ein Prüfereignis anhängt.

• Hybrider Recall — dicht (E5 1024d / Qdrant) + sparse (FTS5/BM25) fusioniert mit Reciprocal Rank Fusion; degradiert ohne Qdrant zu reinem Sparse.

• Inbox für Kandidaten — die automatischen Erfassungen schlagen vor, der Mensch genehmigt; nie wird aktiv Speicher selbstständig geschrieben.

• Redaktion + Deduplizierung im Schreibpfad — Geheimnisse/PII raus, Duplikate per content_hash raus, vor dem Persistieren oder Einbetten.

• AI Router — Kette primär -> Fallbacks pro Zone, Schlüsselerkennung und Nutzungs-/Einsparungstelemetrie; direktes Routing in Rust (ohne Sidecar LiteLLM).

• Regelbasierter Orchestrator — bildet Prompt -> Absicht -> Workflow -> Agenten -> Erinnerungen ab; reserviert das große Modell nur für die mehrdeutige Warteschlange.

• Töne / Persönlichkeiten — deterministische Erkennung des Chat-Tons (lexikalische Signale + explizite Aufforderung) innerhalb des Orchestrate; die Töne werden in Library -> Tones bearbeitet. Die echte Konfiguration (~/.ultron/personality.json) ist lokal und gitignored; das Repo veröffentlicht nur die kompilierten Seeds (orchestrator/personality.rs). Der Ton kleidet ausschließlich die Unterhaltung: niemals Commits, Dokumente oder Artefakte.

Was ist es

ULTRON Control Center ersetzt Claude Code nicht: es umhüllt ihn. Es gibt ihm persistenten und gesteuerten Speicher, leitet Anfragen an verschiedene LLM-Anbieter je nach Kosten und Verfügbarkeit weiter und erkennt automatisch, welcher spezialisierte Skill/Agent für einen Prompt geeignet ist. Der gesamte Zustand lebt in lokalen Dateien (SQLite + JSON + Markdown), die du überprüfen, versionieren und manuell bearbeiten kannst.

Backend-Architektur (real)

Das Rust-Backend lebt in control-center/src-tauri/src/. Das zentrale Speichermodul befindet sich in control-center/src-tauri/src/memory/.

Speicher: SQLite als Quelle der Wahrheit

• ~/.ultron/brain.db (SQLite, WAL-Modus) ist die kanonische Quelle der Wahrheit. Das kanonische Schema lebt in memory/schema_v3.rs (Speicher) + memory/schema_v4.rs (historische Migration v4: Tabellen edges / unresolved_refs, heute inaktiv – der Codegraph wird vom externen MCP CodeGraph bereitgestellt) / memory/migrations.rs, mit Modellen in memory/model.rs (MemoryItem, MemoryCandidate, MemoryEvent und die Governance-Enums Status, Scope, Sensitivity, Source usw.).

• MemoryService (memory/service.rs) ist der einzige persistente Schreiber. Governance-Invariante: Jede Mutation durchläuft diesen Dienst und hängt ein MemoryEvent zur Prüfung an. Hooks und Agenten schreiben niemals direkt in memory_items; sie schlagen nur MemoryCandidates vor, die ein Mensch (oder eine Richtlinie zur automatischen Genehmigung) befördert.

• Im Schreibpfad werden Schutzmaßnahmen angewendet: Redaktion von Geheimnissen/PII (memory/redaction.rs) vor dem Persistieren oder Einbetten, exakte Deduplizierung per content_hash (memory/texthash.rs) und lexikalische Deduplizierung per FTS.

Qdrant: abgeleiteter Index (keine Quelle der Wahrheit)

• Die Sammlung ultron_memory (Qdrant) indexiert die ACTIVE-Elemente mit MultilingualE5Large, 1024 Dimensionen (memory/qdrant_index.rs). Es ist ein abgeleiteter Index: kann jederzeit mit reindex_all neu aufgebaut werden, und brain.db bleibt die Wahrheit.

• Nach jedem genehmigten/bearbeiteten/wiederhergestellten Schreibvorgang hält sync_index Qdrant auf dem neuesten Stand der Quelle der Wahrheit (Best-Effort; jede Abweichung ist über reconcile erkennbar/reparierbar).

• Die alte Sammlung ultron_sessions (384d BGE) ist eingestellt; Qdrant ist hier immer ein Index, niemals die Wahrheit.

Hybrider Recall dicht + sparse mit RRF

• Der einzige Befehl recall (commands/memory/recall_unified.rs) fusioniert mit Reciprocal Rank Fusion (RRF_K = 60):

  • DICHT: E5-Vektoren in ultron_memory (Qdrant).

  • SPARSE: FTS5/BM25 über memory_items (nur status=active).

• Gibt ein kompaktes Context Pack von Zusammenfassungen unter Token-Budget (TOKEN_BUDGET = 1500) zurück, mit Spuren, warum diese Erinnerung (Bereiche pro Quelle, Scores, Verwerfungen) für den Retrieval Inspector.

• Der einzige Recall-Pfad ist der einheitliche Befehl recall mit RRF; die Quellen sind Qdrant (dicht) + SQLite/FTS5 (sparse). Es werden keine externen Speicherdienste verwendet.

Automatische Erfassung via Stop-Hook

• Im Stop übergibt der Hook das Sitzungstranskript an memory/capture.rs::capture_session. Dieser:

  1. fordert ein LLM (via ai_router::route, Zone chat) auf, einige wenige dauerhafte Fakten/Entscheidungen zu extrahieren;

  2. wandelt jeden Fakt in einen MemoryCandidate um (durch Redaktion + Deduplizierung) und legt ihn im kontrollierten Posteingang zur menschlichen Genehmigung ab — er wird niemals automatisch auf aktiv gesetzt.

• Fail-Safe: Wenn der Router keinen nutzbaren Anbieter hat, wird auf eine günstige lokale Heuristik zurückgegriffen, damit der Stop-Hook niemals fehlschlägt.

• Der Posteingang wird über commands/memory/inbox.rs verwaltet (memory_inbox_list, approve_candidate, reject_candidate).

AI Router: Zonen, Anbieter, Fallback und Telemetrie

• Backend im Modul ai_router/ (mod.rs + exec.rs + providers/ + seed.rs + store.rs). Zustand in drei JSON-Dateien unter ~/.ultron/cockpit/ai-router/: providers.json (Katalog), zones.json (Zonen mit primary + fallbacks), metrics.json (Zähler + Einsparungen).

• route(zone, prompt) durchläuft die Kette primär -> Fallbacks, überspringt Anbieter ohne nutzbaren API-Schlüssel, zeichnet Latenz/Tokens/Einsparungen in der Telemetrie auf und gibt Result<String, String> zurück (Fehler wörtlich, niemals panic, Zeitlimit 10s).

• Wrapper pro Anbieter: anthropic (claude-haiku), codex (OpenAI-kompatibel), gemini, groq, ollama (lokal, ohne Schlüssel), deepseek. Health Checks verwenden günstige Sonden und verbrauchen keine Tokens; Testaufrufe hingegen schon.

• Standardzonen umfassen chat, code-edit, code-review, research-web, code-fast-local und andere.

Orchestrator: Automatische Erkennung von Skills/Agenten

• Das Modul orchestrator/ (rules.rs + ranking.rs + orchestrate.rs) bildet prompt -> intent -> workflow -> zu delegierende Agenten -> Erinnerungen -> Einschränkungen ab. Die Intent-Klassifizierung ist regelbasiert (zweisprachig es/en); das große Modell bleibt für die mehrdeutige Warteschlange reserviert.

• Wiederverwendung (keine Duplikation): der Agentenkatalog (memory/catalog.rs), der einheitliche Recall und die integrierten Workflows (agent_orchestration.rs). Schreibt niemals persistente Erinnerungen und delegiert an echte Agenten in ~/.claude/agents (nicht auf der Festplatte vorhandene „Geisteragenten“ werden bereinigt).

Code-Graph: MCP CodeGraph (extern)

• Den Code-Graphen (welche Symbole existieren, wer wen aufruft, Auswirkungsanalyse) liefert CodeGraph (@colbymchenry/codegraph, MIT), installiert als MCP-Server und von den Agenten via codegraph_explore / codegraph_callers / codegraph_impact abgefragt. Indiziert das Repository mit tree-sitter (AST) in .codegraph/ (lokales SQLite, inkrementell) — 20+ Sprachen.

Plugin-Updates: Überprüfung auf Plugin-Aktualisierungen

• Unter-Tab Updates innerhalb der Bibliothek (src/components/library/PluginUpdates.tsx), das die Backend-Befehle plugin_check_updates_bulk(force) und plugin_changelog_summary(coordinate, installed_sha?) konsumiert.

• Vergleicht den installierten SHA mit dem letzten SHA des Marktplatzes für jedes Plugin, markiert, welche ein Update verfügbar haben, und zeigt die letzte Commit-Nachricht / Zusammenfassung des Changelogs an.

Stack

Sidecar-Binärdateien deklariert in control-center/src-tauri/Cargo.toml: ultron-memory (erfordert die Feature qdrant).

Build

# desde control-center/
npm install
npm run build:app   # = kill-app + tauri build (genera el ejecutable de escritorio)

Andere nützliche Skripte (in control-center/package.json):

npm run dev    # vite dev server (frontend)
npm run tauri  # CLI de Tauri
npm test       # vitest (frontend)

Windows-Hinweis: build:app führt zuerst kill-app aus, um alle laufenden Instanzen zu schließen; eine veraltete Binärdatei ist die übliche Ursache für „Die Änderung wurde nicht übernommen“: Schließe die App und kompiliere neu.

Ordnerstruktur

~/.ultron/
├── brain.db                  # SQLite — fuente de verdad de la memoria
├── qdrant-native/            # binario nativo de Qdrant (indice denso derivado)
├── qdrant_storage/           # datos persistidos por Qdrant
├── control-center/           # la app Tauri 2 + React 19
│   ├── src/                  # frontend React/TS (componentes, tabs)
│   │   └── components/       # Dashboard, AIRouter, Library, Projects, ...
│   └── src-tauri/
│       └── src/
│           ├── memory/       # kernel de memoria (service, sqlite_store,
│           │                 # qdrant_index, capture, redaction, texthash, ...)
│           ├── commands/     # comandos Tauri por dominio (memory, ai_router,
│           │                 # projects, system_ops, ...)
│           ├── ai_router/    # AI Router (mod/exec/health/providers/seed/store/types)
│           ├── orchestrator/ # mod/orchestrate/ranking/rules/types_model
│           └── bin/          # sidecar ultron-memory
├── cockpit/                  # config + estado en JSON/markdown
│   └── ai-router/            # providers.json, zones.json, metrics.json
├── personality.json          # tonos del usuario (LOCAL, gitignored; se
│                             # auto-siembra desde los seeds compilados)
├── hooks/                    # hooks de ciclo de vida
├── skills/                   # skills core (SKILL.md; catalogo curado no se publica)
├── plans/  projects/         # planes y proyectos
├── sessions/                 # logs de sesion / telemetria de routing
└── docs/                     # documentacion ampliada

Aktueller Stand

• Speicher: kanonischer Kernel aktiv. SoT = brain.db; dichter Index ultron_memory (E5 1024d) schreibsynchronisiert; einheitlicher dichter+spärlicher Recall mit RRF betriebsbereit (degradiert zu spärlich-only ohne Qdrant). Write-Pfad mit Geheimnisredaktion und Deduplizierung per content_hash verdrahtet und getestet.

• Automatische Erfassung: Stop-Hook -> capture_session -> Kandidaten in den kontrollierten Posteingang; menschliche Genehmigung/Ablehnung via Posteingangsbefehle.

• AI Router: echtes Routing mit primär/Fallback-Kette, Schlüsselerkennung und Nutzungs-/Einsparungstelemetrie; ohne Sidecar LiteLLM.

• Töne: deterministische Erkennung im Orchestrate (JS/Rust-Parität des Detektors mit Gate 16/16 verifiziert); visueller Editor in Library -> Tones und Erkennungs-Playground. Lokale personality.json (gitignored) mit kompilierten veröffentlichbaren Seeds; harte Grenze: der Ton gilt nur für den Chat, niemals für Artefakte.

• KI-Textdetektor: PostToolUse-Hook, der warnt, wenn geschriebene Prosa „nach KI klingt“ + Labor für deterministische Muster über den Forschungskatalog; Matcher mit CLI und Testfällen. Zeigt an, schreibt nicht um.

• UI (Control Center, v2.7.1): Seitenleiste mit Dashboard, Usage, AI Router, System (mit Unter-Tabs Hooks/Schedules), MCPs, Library (Unter-Tabs Skills/Agents/Rules/Updates), Memory, Notes, Learn, Sessions, Projects, Finance (nur lokaler Build mit VITE_FINANCE=1), Settings und Notifications. Der Tab Memory ist aktiv (wieder hinzugefügt am 2026-06-04, Sidebar.tsx): zeigt den Posteingang der Kandidaten (genehmigen/ablehnen/bearbeiten) und den Zustand von brain.db; der Speicherkernel bleibt reines Backend, aber seine Human-in-the-Loop-Steuerung erfolgt über diesen Tab (zusätzlich zu den Befehlen).

Lizenz

MIT — siehe LICENSE. Copyright (c) 2026 Rodrigo Fernandez.