Claude Desktop — Nativer AI-Assistent

Eigenständige Desktop-Anwendung die Claude Code als Backend nutzt, mit nativem UI, Live-Übersicht und kontrolliertem OS-Zugriff.

Motivation

Claude Code in VSCodium funktioniert, hat aber Grenzen:

• Sidebar-Chat ist eng, keine eigene Fensterverwaltung
• Kein Überblick was Claude gerade tut (Dateien, Befehle, DB-Queries)
• Kein "Stopp"-Button bei laufenden Aktionen
• Keine Präsentations-Ansicht für Ergebnisse
• Keine native OS-Integration (Fenster steuern, Programme öffnen)

Vision

Variante A: Native Desktop-App (begleitend)

Claude arbeitet begleitend — der User sieht alles mit und kann jederzeit eingreifen.

┌─────────────────────────────────────────────────────┐
│ Claude Desktop                               [─][□][×]│
├──────────────┬──────────────────────────────────────┤
│              │                                      │
│  💬 Chat     │  📋 Live-Aktivität                    │
│              │                                      │
│  Du: Fixe    │  ▶ Lese product/price.php:1609       │
│  den Bug in  │  ▶ Grep "addMoreActions" in 3 Files  │
│  der Preis-  │  ▶ Edit actions_produktkarte.class.php│
│  seite       │  ✓ Deploy nach /var/www/dolibarr/... │
│              │                                      │
│  Claude:     │  ⚠ Will deployen auf PROD            │
│  Gefunden,   │    [Erlauben] [Ablehnen]             │
│  der Hook... │                                      │
│              ├──────────────────────────────────────┤
│              │  📊 Ergebnis-Präsentation             │
│              │                                      │
│              │  Vorher: list=0 (unsichtbar)         │
│              │  Nachher: list=3 (auf Karte)         │
│              │                                      │
│              │  [Diff anzeigen] [Screenshot]        │
│              │                                      │
├──────────────┴──────────────────────────────────────┤
│  [⏹ STOPP]  CPU: 2%  │  DB: claude  │  Git: main   │
└─────────────────────────────────────────────────────┘

Kernfeatures:

• Chat-Panel — Aufgaben eingeben, Antworten lesen
• Live-Aktivität — Echtzeit was Claude tut (Dateien, Befehle, Queries)
• Kritische Aktionen — Popup bei Prod-Deploy, DB-Änderungen, Git Push
• Präsentations-View — Nach einer Aufgabe: Vorher/Nachher, Diffs, Screenshots
• STOPP-Button — Sofort alles abbrechen
• Statusleiste — Aktive DB, Git-Branch, CPU/RAM

Technologie-Stack:

• Tauri 2.0 (Rust + WebView) — native App, ~5 MB statt 200 MB Electron
• SvelteKit — Frontend (gleiche Technologie wie Leckerbuch, VDE Katalog)
• Claude Code SDK (@anthropic-ai/claude-code) — AI-Backend
• Claude DB — Direkte MySQL-Anbindung (kein REST-Umweg)
• MCP-Tools — Docker, Forgejo, Wissensbasis

Variante B: Autonome VM (selbständig arbeitend)

Claude hat einen eigenen Rechner (VM) mit Desktop und arbeitet Aufgaben selbständig ab. Der User überwacht remote.

┌──────────────────────────────────────────┐
│  Unraid Server                           │
│                                          │
│  ┌────────────────────────────────────┐  │
│  │  VM: Claude Agent                  │  │
│  │                                    │  │
│  │  ┌──────────┐  ┌───────────────┐  │  │
│  │  │ Desktop  │  │ Claude Agent  │  │  │
│  │  │ (XFCE)   │←→│ Computer Use  │  │  │
│  │  │          │  │ Terminal      │  │  │
│  │  │ Dolibarr │  │ Claude DB     │  │  │
│  │  │ Browser  │  │ MCP Tools     │  │  │
│  │  │ IDE      │  │ Git/Forgejo   │  │  │
│  │  └──────────┘  └───────────────┘  │  │
│  │       ↕                           │  │
│  │   VNC/noVNC (Port 6080)           │  │
│  └────────────────────────────────────┘  │
│                                          │
│  Netzwerk: ISOLIERT von Prod!            │
│  - Eigenes VLAN / Bridge                 │
│  - Zugriff nur auf Test-DB               │
│  - Kein SSH zu Unraid                    │
│  - Kein Zugriff auf Prod-Dolibarr        │
└──────────────────────────────────────────┘
         ↕
  Eddy (Browser → VNC)
  Sieht Claude arbeiten
  Kann jederzeit eingreifen

Wie Claude Computer Use funktioniert:

1. Claude bekommt einen Screenshot des Desktops
2. Claude analysiert was er sieht
3. Claude sendet Maus-/Tastatur-Befehle
4. Nächster Screenshot → nächste Aktion
5. Kann jedes Programm bedienen das ein Mensch bedienen kann

Sicherheitskonzept für die VM:

• Netzwerk-Isolation — eigenes VLAN, kein Zugriff auf Prod-Server
• Nur Test-DB — dolibarr_test auf 192.168.155.11, nie Prod-DB
• Kein SSH nach außen — keine SSH-Keys zu Unraid oder anderen Servern
• Snapshot-basiert — VM-Snapshot vor jeder Aufgabe, Rollback bei Problemen
• Audit-Log — jeder Befehl, jede Aktion wird geloggt
• Zeitlimit — maximale Laufzeit pro Aufgabe
• Kill-Switch — ein Befehl stoppt alles sofort

Use Cases für die VM:

• Dolibarr-Module entwickeln und testen (Browser + Terminal)
• Automatische Code-Reviews über mehrere Repos
• Dokumentation erstellen mit Screenshots
• UI-Tests durchführen (Dolibarr durchklicken, Fehler finden)
• Batch-Aufgaben (alle Module updaten, Lang-Dateien synchronisieren)

Empfehlung: Stufenweise vorgehen

Stufe 1: Native Desktop-App (Variante A)

• Sofort umsetzbar mit vorhandenem Wissen (Svelte, Tauri)
• Claude arbeitet begleitend, User behält Kontrolle
• Ersetzt die VSCodium-Sidebar durch bessere UX
• Geschätzter Aufwand: 2-3 Wochen Grundgerüst

Stufe 2: Autonome VM (Variante B) — später

• Erst wenn Stufe 1 stabil läuft und Vertrauen aufgebaut ist
• Guard-Rails und Audit-Log müssen wasserdicht sein
• Netzwerk-Isolation auf Unraid einrichten
• Geschätzter Aufwand: 1-2 Wochen Setup, dann iterativ

Architektur — Variante A im Detail

Projektstruktur

ClaudeDesktop/
├── src-tauri/           # Rust-Backend (Tauri)
│   ├── src/
│   │   ├── main.rs      # App-Einstiegspunkt
│   │   ├── claude.rs    # Claude SDK Integration
│   │   ├── db.rs        # Direkte MySQL-Anbindung
│   │   └── guard.rs     # Sicherheits-Regeln
│   ├── Cargo.toml
│   └── tauri.conf.json
├── src/                 # SvelteKit Frontend
│   ├── routes/
│   │   ├── +layout.svelte    # Haupt-Layout (Chat + Panels)
│   │   ├── chat/             # Chat-Ansicht
│   │   ├── activity/         # Live-Aktivität
│   │   ├── presentation/     # Ergebnis-Präsentation
│   │   └── settings/         # Einstellungen
│   ├── lib/
│   │   ├── claude-bridge.ts  # Kommunikation mit Tauri-Backend
│   │   ├── db.ts             # Claude-DB Queries
│   │   └── stores.ts         # Svelte Stores (State)
│   └── app.html
├── package.json
├── svelte.config.js
├── vite.config.ts
└── README.md

Datenfluss

User-Eingabe (Chat)
       ↓
SvelteKit Frontend
       ↓ (Tauri IPC)
Rust Backend
       ↓
Claude Code SDK (Node.js child process)
       ↓
Claude API (Anthropic)
       ↓
Tool-Ausführung (Bash, Dateien, DB, MCP)
       ↓
Ergebnis zurück an Frontend
       ↓
Live-Aktivität + Präsentation anzeigen

Claude-DB Integration

Statt REST-API (aktuell) → direkte MySQL-Verbindung im Rust-Backend:

// Direkte DB-Abfrage, kein MCP-Umweg
let results = db.query(
    "SELECT * FROM knowledge WHERE MATCH(title,content) AGAINST(? IN BOOLEAN MODE)",
    &[search_term]
).await?;

• Schneller (kein HTTP-Roundtrip)
• Keine Token-Limits bei großen Ergebnissen
• Full-Text-Search direkt in MySQL

Guard-Rails im nativen Programm

enum ActionRisk {
    Safe,       // Dateien lesen, Code schreiben → automatisch
    Moderate,   // Git commit, lokaler Deploy → Statusbar-Hinweis
    Critical,   // Prod-Deploy, DB-Schema, Git Push → Popup + Bestätigung
    Blocked,    // rm -rf, force push main → hart blockiert
}

Sprach-Interface — Reden mit Claude

Konzept

Echtes Gespräch mit Claude — reden, unterbrechen, weiterreden. Kein "Aufnahme starten/stoppen", sondern natürlicher Dialog.

┌─────────────────────────────────────────────────┐
│                                                 │
│   🎤 Du sprichst                                │
│   ↓                                             │
│   Whisper (Speech-to-Text, lokal)               │
│   ↓                                             │
│   VAD erkennt: "User hat aufgehört zu reden"    │
│   ↓                                             │
│   Text → Claude API → Antwort-Text              │
│   ↓                                             │
│   TTS (Text-to-Speech) → Lautsprecher 🔊        │
│   ↓                                             │
│   Du unterbrichst → VAD erkennt Sprache         │
│   → TTS stoppt sofort                           │
│   → Whisper nimmt deine neue Eingabe auf        │
│   → Kreislauf beginnt von vorn                  │
│                                                 │
└─────────────────────────────────────────────────┘

Technologie

Komponente	Technologie	Läuft wo
Speech-to-Text	OpenAI Whisper (whisper.cpp)	Lokal auf NixOS, kein Cloud-Upload
Voice Activity Detection	Silero VAD oder WebRTC VAD	Lokal, erkennt Sprache vs. Stille
Text-to-Speech	OpenAI TTS API oder ElevenLabs	Cloud (Streaming)
Interrupt-Erkennung	VAD + sofortiger TTS-Stopp	Lokal

Gesprächs-Modi

Freies Gespräch — wie mit einem Kollegen reden:

• Du redest, Claude hört zu (Whisper transkribiert live)
• Pause > 1,5 Sekunden → Claude antwortet
• Du unterbrichst → Claude stoppt sofort, hört dir zu
• Claude kann nachfragen wenn etwas unklar ist

Diktier-Modus — Claude führt aus was du sagst:

• "Fixe den Bug in der Preisseite, der Umrechnungsfaktor wird nicht berücksichtigt"
• Claude arbeitet, kommentiert per Sprache was er tut
• Du kannst jederzeit "Stopp" oder "Warte mal" sagen

Präsentations-Modus — Claude erklärt was er gemacht hat:

• "Zeig mir was du geändert hast"
• Claude öffnet Diff-View und erklärt per Sprache die Änderungen
• Du kannst zwischenfragen: "Warum hast du das so gemacht?"

Stimmen-Optionen

OpenAI TTS API:

• 6 Stimmen (alloy, echo, fable, onyx, nova, shimmer)
• Sehr natürlich, Streaming-fähig (~200ms Latenz)
• Kosten: ~$15 pro 1M Zeichen

ElevenLabs:

• Hunderte Stimmen, eigene Stimmen klonbar
• Noch natürlicher, emotionaler
• Deutsch-Support gut
• Kosten: ab $5/Monat (30 Min)

Lokal (Piper TTS):

• Kostenlos, keine Cloud
• Deutsche Stimmen verfügbar
• Qualität gut aber nicht so natürlich wie Cloud
• Keine Latenz durch Netzwerk

Latenz-Budget (Ziel: < 2 Sekunden)

VAD erkennt Stille:        ~300ms
Whisper transkribiert:     ~500ms (lokal, whisper.cpp mit GPU)
Claude API Antwort:        ~800ms (erstes Token, Streaming)
TTS erstes Audio:          ~200ms (Streaming)
─────────────────────────────────
Gesamt bis erste Silbe:    ~1.800ms

Mit Streaming: Claude beginnt zu "reden" während er noch denkt — wie ein Mensch der anfängt zu antworten bevor der Gedanke fertig ist.

Integration in die Desktop-App

┌─────────────────────────────────────────────────────┐
│ Claude Desktop                               [─][□][×]│
├──────────────┬──────────────────────────────────────┤
│              │                                      │
│  💬 Chat     │  📋 Live-Aktivität                    │
│              │                                      │
│  (Text wird  │  ▶ Lese product/price.php            │
│  live mit-   │  ▶ Edit actions_produktkarte.class.php│
│  geschrieben │  ✓ Deploy nach /var/www/dolibarr/... │
│  während     │                                      │
│  gesprochen) │                                      │
│              │                                      │
├──────────────┴──────────────────────────────────────┤
│  🎤 ████████░░░░░░  Zuhören...    [🔇 Stumm] [⏹]   │
└─────────────────────────────────────────────────────┘

• Mikrofon-Leiste unten zeigt Pegel
• Gesprochenes wird als Text im Chat mitgeschrieben (Transkript)
• Claudes Antwort wird gleichzeitig als Text angezeigt und vorgelesen
• Stumm-Taste schaltet Mikrofon aus (nur Text-Modus)

Whisper lokal auf NixOS

# In configuration.nix
environment.systemPackages = with pkgs; [
  whisper-cpp          # C++ Port, schnell, CPU/GPU
  # oder
  openai-whisper       # Original Python, braucht mehr RAM
];

Whisper "small" oder "medium" Modell reicht für Deutsch — ~500 MB RAM, Echtzeit auf CPU.

Voraussetzungen

Für Variante A (Desktop-App)

• NixOS: rustc, cargo, nodejs, tauri-cli in der Nix-Config
• Anthropic API Key (bereits vorhanden)
• Claude Code SDK npm-Paket
• MySQL-Client-Library für Rust (sqlx oder mysql_async)

Für Variante B (VM)

• Unraid: VM mit Linux + Desktop (Ubuntu/Debian + XFCE)
• VNC-Server in der VM
• noVNC-Container auf Unraid für Browser-Zugriff
• Isoliertes Netzwerk (VLAN oder Bridge)
• Claude API Key + Computer Use Beta-Zugang

Offene Fragen

• Anthropic API Key Kosten für Computer Use (Screenshot-intensiv)?
• Tauri 2.0 auf NixOS — Nix-Paket verfügbar?
• Claude Code SDK — stabil genug für Production?
• VM auf Unraid — genug RAM/CPU frei?