Hitonabi/mission-control-v2
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

docs: sync status, hermes setup, and cutover docs with box reality

Browse Source
This commit is contained in:
Hitonabi
2026-06-25 21:41:03 +02:00
parent 2536d91430
commit 807c2c6194
3 changed files with 136 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files
docs/CUTOVER.md
+37 -30
View File
@@ -2,37 +2,44 @@
## Was auf der Box LÄUFT (verifiziert) ## Was auf der Box LÄUFT (verifiziert)
- **MC2** auf `:9001` (sudo-freier User-Dienst, `~/mission-control-v2`). Update: `deploy/deploy.sh`. - **MC2** auf `:9001` (sudo-freier User-Dienst, `~/mission-control-v2`). Update: `deploy/deploy.sh`.
- **Modelle:** `fast` = Qwen3.6-35B-A3B (21 GB, lädt in ~6 s) + `heavy` = Qwen3.5-122B-A10B (77 GB, - **Modelle/Rollen:** `fast` = Qwen3.6-35B-A3B, `heavy` = Qwen3.5-122B-A10B, `coder` = Qwen3-Coder-30B,
lädt in ~32 s). Beide tool-fähig (`--jinja`). Plus die bestehenden coder/vision/scout. `vision` = Qwen3-VL-8B, `scout` = Qwen3-8B, `hermes` = Hermes-4-14B (immer warm, ttl 99999). Alle
tool-fähig (`--jinja` wo nötig). Legacy `manager`/`reviewer` entfernt.
- **Gateway (eingebaut, `:9001/v1`, OpenAI-kompatibel):** `model: auto` → kurz/Standard = `fast`, - **Gateway (eingebaut, `:9001/v1`, OpenAI-kompatibel):** `model: auto` → kurz/Standard = `fast`,
lang/komplex = `heavy`. End-to-End verifiziert (short→fast, keyword→heavy lädt + antwortet). lang/komplex = `heavy`. End-to-End verifiziert.
- **Hermes:** Brain = `model: auto` über den Gateway (provider `custom`, `:9001/v1`). MCP verdrahtet: - **Hermes:** **eigenes festes Hirn = Hermes-4-14B** (`model.model: hermes`) + **Delegation an `heavy`**.
`mission-control-memory` + `mission-control-stack` (mcp_mc). Antwortet. `model:auto` ist NUR für Vibe Coding/IDEs, nicht Hermes. MCP verdrahtet: `mission-control-memory` +
- **Gedächtnis vereinheitlicht:** MC2 nutzt die bestehende v1-DB (`mission-control-memory.db`, `mission-control-stack`. Verifiziert: „bist du da?" → 3s, sauber, kein Thrash.
16 Einträge) — eine geteilte „Verfassung" für Cockpit, Hermes, IDEs. - **Gedächtnis vereinheitlicht:** MC2 nutzt die bestehende DB (`mission-control-memory.db`) — geteilte
„Verfassung" für Cockpit, Hermes, IDEs.
- **Cockpit-Features:** HF-Link/Suche-Install (W2), Rollen/ctx/löschen-UX (W3), Wartung (W8: OS/Engine-
Update, Restart, Reboot, Logs, dyn. Modell-Upgrades), Bedien-Anleitung (BEDIENUNG.md + Hilfe-Link).
## Bekannte Tuning-Punkte (vor „rundem" Cutover sinnvoll, kein Blocker) ## Thrash-Fix (war der „Hermes ist dumm"-Grund)
1. **Hermes-Thrash → BEHOBEN (W1).** Ursache war eine **vergiftete Dauer-Session** (mein Test hatte sie Ursache war NICHT das Modell/die Session, sondern **kaputte/Cloud-Tools im Toolset** (browser ohne Chrome
mit einem Vision-Fehl-Lauf verseucht; Hermes fütterte sie jeden Zug erneut → ~249k Tokens, Vision-auf- → Loop, vision auf Text, natives memory falsch aufgerufen). Global abgeschaltet über
Text, Such-Schleifen). **Verifiziert:** frische Session = sauber & kohärent, **34k statt 249k**, `agent.disabled_toolsets` in `~/.hermes/config.yaml` (Achtung: `hermes tools disable` greift nur cli,
keine Fehl-Tools. Maßnahmen: `code_execution.max_tool_calls` 50→20 (Schleifen-Bremse); **History NICHT den api_server). Natives memory zusätzlich aus (`memory.memory_enabled:false`); geteiltes
unangetastet** (64 Sessions/1048 Msgs bleiben — Hermes' Gedächtnis). Sessions reseten ohnehin täglich Gedächtnis bleibt via MCP. Behaltene Tools: web/terminal/file/code_execution/skills/todo/session_search/
(4 Uhr) / nach 24 h idle; das WebUI nutzt pro Chat eine eigene Session. **Speed:** Gateway schaltet clarify/delegation/cronjob + 2 MCP.
auf der `fast`-Spur **Thinking aus** (Qwen3.6) → bare Gateway-Antwort ~10 s, direkt.
**Rest-Tuning (mit dir, optional):** Hermes' erste Nachricht dauert noch ~60–90 s wegen **34k Basis-
Kontext** (Tool-Schemas + 26 Skills) + Agent-Loop. Hebel: unnötige Toolsets/Skills prunen
(`config toolsets`/`platform_toolsets`, 26 Skills sichten) → schlankerer Prompt = schnellerer Agent.
2. **SSH→Windows (voller PC-Zugriff):** Windows-seitig OpenSSH-Server aktivieren + Key
`id_ed25519_hermes_agent` autorisieren (vom Box-Host aus). Erst dann erreicht Hermes' Shell den PC.
3. **hermes-webui (nesquena) standalone:** optional — aktuell läuft das eingebaute `hermes-dashboard`.
Für die reichere Oberfläche `docs/HERMES_SETUP.md` §3 (Port 8787, Passwort).
## Cutover-Schritte (wenn v2 dir reicht) ## Cutover-Schritte
1. v2 läuft bereits auf `:9001` parallel — teste alles dort: `http://192.168.178.151:9001`. 1. v2 läuft bereits auf `:9001` parallel — alles dort testen: `http://192.168.178.151:9001`.
2. Vibe-Coding-Tools auf den Gateway zeigen (Verbinden-Tab liefert Snippets → `:9001/v1`, `model: auto`). 2. Vibe-Coding-Tools auf den Gateway zeigen (Verbinden-Tab → `:9001/v1`, `model: auto`).
3. **v1 stilllegen:** `systemctl --user stop hermes-dashboard` (nur wenn nesquena/anderes übernimmt) und 3. **v1 stilllegen** — bereits erledigt: `hermes-dashboard` (:9119) disabled (killte 4 v1-MCP-Zombies).
den alten Mission-Control-Dienst deaktivieren. llama-swap + hermes-gateway bleiben (von beiden genutzt). **Noch offen (braucht dein sudo, NOPASSWD deckt nur `restart`):**
4. Optional v2 auf den „Haupt"-Port legen (z.B. 9000) — `MC_PORT` im Unit ändern. ```
5. Backup vorher: Cockpit → System → „Backup jetzt" (sichert Memory-DB + Configs). sudo systemctl disable --now mission-control # v1-Cockpit :9000 aus
```
`llama-swap` (System) + `hermes-gateway` (User) bleiben — die nutzt v2 weiter.
4. Optional v2 auf den „Haupt"-Port legen — `MC_PORT` in der mc2-Unit.
5. Backup vorher: Cockpit → System → „Backup jetzt".
> v1 bleibt bis dahin unangetastet und lauffähig — Cutover ist reversibel. ## Offene Tuning-/Setup-Punkte (kein Blocker)
1. **nesquena hermes-webui** (:8787) installieren (Plan Block C) → „Hermes öffnen" zeigt darauf statt :9119.
2. **Ko-Residenz** `hermes`+`fast` (swap:false, Plan Block E) — GTT beobachten, bei OOM-Nähe zurück.
3. **SSH→Windows** (voller PC-Zugriff): OpenSSH-Server am Windows-PC + Key `id_ed25519_hermes_agent`.
4. **sudoers erweitern** (`apt-get`, `reboot`) → OS-Update/Reboot klicki-bunti (Zeilen in BEDIENUNG.md).
5. **Delegation an heavy** ist konfiguriert; triggert modell-diskretionär bei echt harten Teilaufgaben.
> v1 bleibt bis zum `disable` lauffähig — Cutover ist reversibel (`sudo systemctl enable --now mission-control`).
docs/HERMES_SETUP.md
+57 -40
View File
@@ -1,65 +1,82 @@
# Hermes-Schicht — Box-Runbook (Phase 4) # Hermes-Schicht — Box-Runbook
> Diese Schritte laufen **auf der Bosgame** (`192.168.178.151`, User `hitonabi`). > Diese Schritte laufen **auf der Bosgame** (`192.168.178.151`, User `hitonabi`).
> MC betreibt Hermes nicht — es zeigt nur Status + verlinkt das WebUI. Hier wird die > MC betreibt Hermes nicht — es zeigt nur Status + verlinkt das WebUI. Hier wird die
> eigentliche **volle Verdrahtung** gemacht (das war in v1 der „Hermes ist dumm"-Grund). > eigentliche **volle Verdrahtung** gemacht (das war in v1 der „Hermes ist dumm"-Grund).
## Reihenfolge der Dienste ## Reihenfolge der Dienste
`llama-swap (:8080)` → `LiteLLM-Gateway (:4000)` → `hermes-gateway (:8642)` → `hermes-webui (:8787)` `llama-swap (:8080)` → **builtin Gateway (`:9001/v1`, Teil von MC2)** → `hermes-gateway (:8642)` →
`hermes-webui (:8787, nesquena)`
## 1. LiteLLM-Gateway starten + Auto-Routing prüfen ## 1. Gateway = builtin (kein LiteLLM)
LiteLLM scheitert auf Python 3.14 (uvloop/orjson). MC2 bringt einen **eingebauten** OpenAI-kompatiblen
Gateway auf `:9001/v1` mit: `model: auto` (kurz→`fast`, komplex→`heavy`) + explizite Aliase
(`fast`/`heavy`/`coder`/`vision`/`hermes`). Verifizieren:
```bash ```bash
uv pip install "litellm[proxy]" # oder pipx curl -s http://127.0.0.1:9001/v1/models
litellm --config /opt/mission-control-2/gateway/config.yaml --port 4000
curl -s http://127.0.0.1:4000/v1/models # fast/heavy/vision/coder/auto?
# 'auto' testen: einfacher Prompt → fast; harter/zu langer → Fallback heavy.
```
⚠️ **Complexity-Auto-Router** (model:auto wählt nach Schwierigkeit) ist versionsabhängig — gegen die
installierte LiteLLM-Version verifizieren (docs.litellm.ai/docs/proxy/auto_routing). Baseline =
fast + Fallback heavy ist bereits in `gateway/config.yaml`.
## 2. Engine: Hirne + Ko-Residenz (llama-swap groups)
In MC (Modelle & Routing) bzw. direkt: Qwen3.6-35B-A3B (Alias `fast`, `--jinja`!) und
Qwen3.5-122B-A10B (Alias `heavy`) eintragen, Gruppe `brains` mit `swap:false` (ko-resident).
```bash
curl -s http://127.0.0.1:9001/api/groups # MC2 (Phase 0/1 API)
``` ```
## 3. hermes-webui installieren (standalone) ## 2. Engine: Rollen (llama-swap)
Aliase sauber: `fast` (Qwen3.6-35B-A3B), `heavy` (Qwen3.5-122B-A10B), `coder`, `vision`, `scout`,
`hermes` (Hermes-4-14B, `ttl 99999` = immer warm). Verwaltung im Cockpit (Modelle & Routing).
**Ko-Residenz** (optional): Gruppe `swap:false` für `hermes`+`fast` → beide warm; `heavy`/`vision`
on-demand. GTT beobachten (~124 GB Limit).
## 3. hermes-webui installieren (nesquena, standalone)
```bash ```bash
cd ~ && git clone https://github.com/nesquena/hermes-webui && cd hermes-webui cd ~ && git clone https://github.com/nesquena/hermes-webui && cd hermes-webui
python3 bootstrap.py # erkennt hermes-agent, installiert Abhängigkeiten python3 bootstrap.py # erkennt hermes-agent, baut venv, installiert Deps
# Dienst: deploy/hermes-webui.service → ~/.config/systemd/user/, Passwort setzen:
mkdir -p ~/.config/environment.d mkdir -p ~/.config/environment.d
echo 'HERMES_WEBUI_PASSWORD=<dein-passwort>' > ~/.config/environment.d/hermes-webui.conf echo 'HERMES_WEBUI_PASSWORD=<dein-passwort>' > ~/.config/environment.d/hermes-webui.conf
# Unit deploy/hermes-webui.service → ~/.config/systemd/user/ (HOST=0.0.0.0, PORT=8787)
systemctl --user enable --now hermes-webui systemctl --user enable --now hermes-webui
loginctl enable-linger hitonabi loginctl enable-linger hitonabi
``` ```
Zugriff vom Windows-PC: `http://192.168.178.151:8787` (mit Passwort). Zugriff vom Windows-PC: `http://192.168.178.151:8787` (mit Passwort). MC2-Unit
`HERMES_WEBUI_URL=http://192.168.178.151:8787` setzen → „Hermes öffnen" zeigt darauf.
**Danach das alte offizielle Dashboard stilllegen** (eine WebUI):
`systemctl --user disable --now hermes-dashboard` (:9119).
## 4. Hermes-Brain = `model: auto` über den Gateway ## 4. Hermes-Hirn = dediziertes Hermes-4-14B + Delegation (NICHT model:auto)
In `~/.hermes/config.yaml` (bzw. via `hermes`-CLI/WebUI-Settings) das Modell auf den **Gateway** zeigen: In `~/.hermes/config.yaml`:
```yaml ```yaml
model: model:
provider: openai # NICHT 'custom' → Hänger-Bug #26489 default: Hermes-4-14B
base_url: http://127.0.0.1:4000/v1 provider: custom
base_url: http://127.0.0.1:9001/v1
api_key: local api_key: local
name: auto # schnell im Alltag, eskaliert auf heavy model: hermes # Hermes' eigenes Hirn (Alias→Hermes-4-14B), NICHT 'auto'
delegation:
model: heavy # harte Teilaufgaben → Qwen3.5-122B
provider: custom
base_url: http://127.0.0.1:9001/v1
api_key: local
orchestrator_enabled: true
subagent_auto_approve: true
``` ```
`model:auto` bleibt ausschließlich Gateway-Funktion für Vibe Coding/IDEs.
## 5. Tools/MCP verdrahten (der eigentliche Fix) ## 5. Tools/MCP verdrahten — UND kaputte Tools abschalten (Thrash-Fix!)
Hermes' Tools sind by-default AUS. Aktivieren: - **Kaputte/Cloud-Tools global abschalten** (sonst Endlos-Loops, siehe Memory `hermes-thrash-rootcause-fix`):
- **Built-in:** terminal/shell, read_file/search_files, file-ops. `approvals: auto` (rein lokal). ```yaml
- **MCP-Server** (`hermes mcp` oder config `mcp_servers`): agent:
- geteiltes Gedächtnis: `python /opt/mission-control-2/mcp/mcp_memory.py` (Env `MC_URL=http://127.0.0.1:9001`) disabled_toolsets: [browser, vision, computer_use, image_gen, tts, video, video_gen, memory]
- Stack-Management: `python /opt/mission-control-2/mcp/mcp_mc.py` (Env `MC_URL=http://127.0.0.1:9001`) memory:
- **SSH→Windows-PC** (voller Zugriff auf deinen PC): OpenSSH-Server auf Windows aktiv + Key memory_enabled: false
`~/.ssh/id_ed25519_hermes_agent` autorisiert; Hermes nutzt sein Shell-Tool für `ssh TobisPC@<win-ip> …`. user_profile_enabled: false
- **100 % lokal:** Hermes' eingebauter web_search/browser laufen über Nous Portal (Cloud). Für rein ```
lokal stattdessen einen **lokalen Browser-/Such-MCP** binden (optional, später). ⚠️ `hermes tools disable <x>` wirkt nur für die cli-Plattform, **nicht den api_server** — nutze
`agent.disabled_toolsets` (gilt für ALLE Plattformen).
- **Behalten:** terminal/shell, file, code_execution, skills, todo, session_search, clarify,
delegation, cronjob, web. `approvals: auto` (rein lokal).
- **MCP-Server** (`mcp_servers` in config) — laufen über die v1-venv (hat das `mcp`-Modul):
- geteiltes Gedächtnis: `/opt/mission-control/.venv/bin/python ~/mission-control-v2/mcp/mcp_memory.py` (Env `MC_URL=http://127.0.0.1:9001`)
- Stack-Management: `… ~/mission-control-v2/mcp/mcp_mc.py` (Env `MC_URL=http://127.0.0.1:9001`)
- **SSH→Windows-PC** (voller Zugriff): OpenSSH-Server auf Windows aktiv + Key
`~/.ssh/id_ed25519_hermes_agent` autorisiert; Hermes nutzt sein terminal-Tool für `ssh TobisPC@<win-ip>`.
## 6. Verifikation ## 6. Verifikation
- WebUI öffnet vom Windows-PC, Chat antwortet (Brain via Gateway). - `curl :8642/v1/chat/completions` „bist du da?" → kurze Antwort in wenigen Sekunden, **kein** Tool-Loop
- Hermes kann via `mcp_mc` ein Modell listen/Routing ändern (`list_models`, `set_route`). im `journalctl --user -u hermes-gateway`; llama-swap `/running` zeigt `Hermes-4-14B`.
- Hermes erreicht den Windows-PC (SSH-Kommando) und das Netz. - WebUI öffnet vom Windows-PC, Chat antwortet.
- 14B-Loop weg (Guard-Beschreibungen in mcp_memory + tool-fähiges Brain). - Hermes kann via `mcp_mc` Modelle listen/Routing ändern; erreicht (nach §5-SSH) den Windows-PC.
docs/STATUS.md
+42 -62
View File
@@ -6,72 +6,52 @@
## Wo das Projekt lebt ## Wo das Projekt lebt
- **Code:** `F:\Coding Stuff\mission-control-2` (Windows-Dev-PC) + Gitea-Remote - **Code:** `F:\Coding Stuff\mission-control-2` (Windows-Dev-PC) + Gitea-Remote
`https://git.tobisniceshomelab.ddnsfree.com/Hitonabi/mission-control-v2` (Branch `main`). `https://git.tobisniceshomelab.ddnsfree.com/Hitonabi/mission-control-v2` (Branch `main`).
- **v1** (`F:\Coding Stuff\mission-control`) bleibt unangetastet bis zum Cutover. - **v1** (`F:\Coding Stuff\mission-control`) wird abgelöst (Cutover läuft, s.u.).
- **Box** (Bosgame, `192.168.178.151`): **MC2 LIVE auf :9001** als sudo-freier systemd-USER-Dienst - **Box** (Bosgame, `192.168.178.151`): **MC2 LIVE auf :9001** als sudo-freier systemd-USER-Dienst
(`~/mission-control-v2`, Update via `deploy/deploy.sh`). Verifiziert gegen echtes llama-swap: (`~/mission-control-v2`, Update via `deploy/deploy.sh`).
6 Modelle inkl. Caps, **GPU/GTT (133 GB) + Temps**, Services-Health. Parallel zu v1 (unangetastet).
## Gateway = builtin (NICHT LiteLLM)
LiteLLM verlangt Python <3.14; die Box hat nur 3.14 (uvloop+orjson scheitern). Der **eingebaute
Gateway** (`:9001/v1`, OpenAI-kompatibel) liefert `model:auto` (kurz→`fast`, komplex→`heavy`) +
Streaming und ist E2E verifiziert. Vertrag (OpenAI-API) bleibt austauschbar.
## Phasen-Fortschritt ## Phasen-Fortschritt
- [x] **Phase 0 — Gerüst:** FastAPI (`/api/health`,`/api/models`) + React/shadcn-Shell (Cmd+K, Dark, PWA). Verifiziert. - [x] **Phase 0 — Gerüst:** FastAPI + React/shadcn-Shell (Cmd+K, Dark, PWA). Live auf Box.
- [x] **Phase 1 — Engine + Routing:** Compute-Module (fit/caps/sources), Discover (live HF), Engine-Write - [x] **Phase 1 — Engine + Routing:** Compute (fit/caps/sources), Discover (live HF), Engine-Write
(register + groups/Ko-Residenz), LiteLLM-Gateway-Config + Service, Frontend Modelle&Routing (register + groups), **builtin Gateway** `model:auto`, Modelle&Routing-UI. Box-verifiziert.
(Caps-Chips, Fit, Discover-Tab, Routing-View). Lokal verifiziert (Backend-Smoke + Frontend-Build + Browser). - [x] **Phase 2 — System/OS + Connect:** Metriken, Dienste, Self-Update, Connect-Snippets → Gateway.
- [x] **Phase 2 — System/OS + Connect:** System-Status (psutil CPU/RAM/Disk, sysfs GPU/Temp guarded), - [x] **Phase 3 — Memory + MCP:** Memory-UI, `mcp_memory.py` + `mcp_mc.py` (Stack-Management).
Wartung (restart/self-update als systemd-USER-Dienst, sudo-frei), Connect-Snippets (Cline/OpenCode/ - [x] **Phase 4 — Hermes-Schicht:** Agent-Status + AgentView; **Box: Hermes verdrahtet** (eigenes Hirn,
Zed/Continue/Claude Code/Memory-MCP → Gateway `model:auto` + LAN-IP-Override). Lokal verifiziert. MCP memory+stack). hermes-webui (nesquena) = Block C offen.
- [x] **Phase 3 — Memory + MCP:** Memory-Service (SQLite/WAL, 5 Kategorien, Dedupe-Kurator), Router - [x] **Phase 5 — Betrieb/Politur:** Backup, Services-Health, Observability-Links, Theme-Toggle.
(CRUD/export/dedupe), `mcp/mcp_memory.py` (Guard-Beschreibungen gegen Loop) + `mcp/mcp_mc.py` NEU - [x] **W1–W8** (Audit-Arbeitspaket): Thrash-Fix, HF-Install, Rollen-UX, BEDIENUNG.md, Wartung. ✅
(Stack-Management-Tools für Hermes: list/discover/register/route/restart/status). Frontend - [~] **Phase 6 — Cutover:** läuft (s.u.). v1-Dashboard+Zombies weg; v1 :9000 Stop offen (User-sudo).
MemoryView (Add/Filter/Suche/Delete/Aufräumen). Lokal verifiziert (CRUD+Dedupe; MCP syntax-OK).
- [~] **Phase 4 — Hermes-Schicht:** MC-Seite ✅ (services/agent.py + /api/agent/status, AgentView mit ## Hermes-Hirn (Entscheidung 2026-06-25)
Status-Tiles + „Hermes öffnen"), `deploy/hermes-webui.service`, **Runbook `docs/HERMES_SETUP.md`**. Hermes hat ein **eigenes festes Hirn = Hermes-4-14B** (`model.model: hermes`, ttl 99999 = immer warm)
**Box-Ausführung offen** (hermes-webui installieren, Brain=auto, Tools/MCP verdrahten — Runbook). + **interne Delegation an `heavy`** (Qwen3.5-122B) für harte Teilaufgaben. **`model:auto` ist NUR
- [x] **Phase 5 — Betrieb/Observability/Politur:** Backup (Memory-SQLite + Configs, retain 7; Gateway/Vibe-Coding**, nicht Hermes. Verifiziert: „bist du da?" → **3s, sauber, kein Thrash**.
`/api/system/backup` + `deploy/backup.sh`), Services-Health (`/api/system/services`), Observability-
Links (llama-swap /ui, Gateway), **Theme-Toggle Hell/Dunkel**. Lokal verifiziert. ## Box-Stand (Session 2026-06-25)
- [ ] **Phase 6 — Cutover** (/opt → v2, v1 aus). **Braucht Box.** - **8 Modelle**, Rollen sauber: `fast` (Qwen3.6-35B-A3B), `heavy` (Qwen3.5-122B-A10B), `coder`
- Offen aus Phase 0/1: **Box-Deploy** (Gitea-Repo da; Box-Setup als systemd-USER-Dienst noch offen), (Qwen3-Coder-30B), `vision` (Qwen3-VL-8B), `scout` (Qwen3-8B), `hermes` (Hermes-4-14B). Legacy
LiteLLM **Complexity-Auto-Router** gegen installierte Version verifizieren. `manager`/`reviewer`-Aliase entfernt (Modelle bleiben per Realname ladbar).
- **Thrash behoben** (war NICHT die Session): kaputte Tools global via `agent.disabled_toolsets`
abgeschaltet (browser/vision/computer_use/image_gen/tts/video*/memory). Details: Memory
`hermes-thrash-rootcause-fix`. **`hermes tools disable` greift NICHT am api_server** — nur die config.
- **Cutover teilweise:** `hermes-dashboard` (:9119) disabled (killte 4 v1-MCP-Zombies);
**v1 `mission-control.service` (:9000) läuft noch** → `sudo systemctl disable --now mission-control`.
- MCP nutzt `/opt/mission-control/.venv/bin/python` (hat `mcp`-Modul) für v2-Skripte → /opt-Dir bleibt.
## Nächste Schritte (siehe Plan „Nächste Schritte" + docs/CUTOVER.md)
- **Block C:** nesquena hermes-webui (:8787) installieren → „Hermes öffnen" zeigt darauf.
- **Block E:** Ko-Residenz `hermes`+`fast` (swap:false) testen, GTT beobachten.
- **User-sudo:** v1 :9000 stoppen; sudoers für apt-get/reboot erweitern (OS-Update/Reboot).
- Offen/user-seitig: SSH→Windows (OpenSSH am PC), v1-Passwort-Hygiene (Git-Historie).
## Lokal entwickeln/verifizieren ## Lokal entwickeln/verifizieren
```bash ```bash
# Backend cd backend && .venv/Scripts/python -m uvicorn app:app --port 9000 # Backend
cd backend && .venv/Scripts/python -m uvicorn app:app --port 9000 cd frontend && npm run dev # http://localhost:5173
# Frontend (Dev) cd frontend && npm run build # Prod-Build (committet)
cd frontend && npm run dev # http://localhost:5173 (proxyt /api → :9000)
# Frontend (Build → wird vom Backend ausgeliefert, committet)
cd frontend && npm run build
``` ```
## API (Stand Phase 1)
- `GET /api/health` — Status + engine/gateway reachable
- `GET /api/models` — installierte Modelle inkl. `capabilities`
- `GET /api/discover[?force=1]` — beste Modelle je Kategorie (live HF, Fit, Caps, ⭐recommended)
- `GET /api/fit?params_b=&quant=&ctx=&name=` — Hardware-Fit-Schätzung
- `POST /api/models/register` — GGUF als llama-swap-Modell eintragen (cmd + Rolle-Alias, optional jinja)
- `GET/PUT /api/groups` — llama-swap-`groups` (Ko-Residenz `swap:false`)
- `GET /api/routing`, `PUT /api/routing/route` — LiteLLM-Gateway-Mapping
- `GET /api/system/status` — CPU/RAM/GPU/Disk/Temp
- `POST /api/system/restart` (Whitelist), `POST /api/system/self-update` — Wartung (Box, sudo-frei)
- `GET /api/connect?host=` — IDE-/Agent-Snippets (Gateway + Memory-MCP)
- `GET/POST/PUT/DELETE /api/memory[...]` + `/api/memory/export` + `/api/memory/dedupe` — geteiltes Gedächtnis
- `mcp/mcp_memory.py` (geteiltes Memory) + `mcp/mcp_mc.py` (Stack-Management für Hermes) — stdio-MCP
- `GET /api/agent/status` — Hermes Gateway/WebUI-Erreichbarkeit + Verdrahtungs-Hinweise
## Box-Stack LIVE (Phase 6 ausgeführt) — Stand & Cutover: siehe `docs/CUTOVER.md`
- Modelle `fast` (Qwen3.6-35B-A3B) + `heavy` (Qwen3.5-122B-A10B) geladen & lauffähig.
- Eingebauter Gateway `:9001/v1` `model: auto` (fast↔heavy) — E2E verifiziert.
- Hermes: Brain via Gateway, MCP (memory+stack) verdrahtet, Memory vereinheitlicht (v1-DB, 16 Einträge).
- Offene Tuning-Punkte (kein Blocker): Hermes-Agent-Brain für die Loop (Qwen3.6 thrasht → `coder`
empfohlen), SSH→Windows (Windows-seitig), nesquena-WebUI optional. Details: `docs/CUTOVER.md`.
## Nächster sinnvoller Schritt (user-gated — braucht dich / Downloads / Entscheidungen)
Phasen 0–5 sind fertig **und MC2 läuft live auf der Box** (`:9001`). Es bleiben **bewusst von dir
auszulösende** Schritte (schwere Downloads, Passwörter, Eingriff in die laufende v1/Hermes-Produktion):
1. **Hirne laden (~90 GB):** Qwen3.6-35B-A3B (`fast`, `--jinja`) + Qwen3.5-122B-A10B (`heavy`) eintragen
+ Gruppe `brains` (`swap:false`). UI: Modelle & Routing → `http://192.168.178.151:9001`.
2. **LiteLLM-Gateway** installieren/starten (`docs/HERMES_SETUP.md` §1), `model:auto` verifizieren.
3. **Hermes-Schicht** verdrahten (`docs/HERMES_SETUP.md`): hermes-webui + Passwort, Brain=auto, Tools/MCP
(`mcp_mc`+`mcp_memory`), SSH→Windows.
4. **Cutover (Phase 6):** wenn v2 dir reicht — v1 stilllegen, v2 ggf. auf den Hauptport. (Aktuell läuft
v2 risikofrei parallel auf :9001, v1 unangetastet.)