ACME — Technischer Setup-Guide

Eine Ein-Personen-Firma von Grund auf aufbauen — mit Hermes als KI-Assistent, kostenloser Cloud-Infrastruktur und voller Transparenz.

✅ 12 Phasen 🔧 20+ Komponenten 💰 5–30 €/Monat

ACME — Technischer Setup-Guide#

Eine Ein-Personen-Firma von Grund auf aufbauen — mit Hermes als KI-Assistent#

Einleitung#

Stell dir vor, du gründest allein eine Firma. Nennen wir sie ACME.

Ein Laptop, ein Cloud-Server, eine KI-Assistentin — und am Ende weißt du jederzeit: Was kostet das alles? Was hat die KI getan? Läuft alles?

Dieser Guide baut ACME Schritt für Schritt auf. Das Besondere: Hermes kommt als Erstes. Noch bevor es einen Server gibt, installierst du Hermes auf deinem Laptop und legst ein Profil namens „IT" an. Ab diesem Moment berät dich Hermes bei jedem weiteren Schritt — und erledigt viele Aufgaben selbstständig auf dem Server, den du später aufsetzt.

Der Guide ist so geschrieben, dass auch Nicht-ITler folgen können. Technische Begriffe werden erklärt, wenn sie das erste Mal auftauchen.

Was du hier bekommst#

  • Einen Bauplan für eine komplette Firmen-IT mit kostenlosem oder günstigem Hosting
  • Hermes als ersten Mitarbeiter — die KI-Assistentin ist vom ersten Tag an dabei und baut die Firma mit dir auf
  • Vollständige Transparenz — du kannst jederzeit sehen, was Hermes getan hat, was es kostet, und ob alles gesund ist
  • Optionale Bausteine klar markiert — das Minimum reicht für den Start; Optional kann jederzeit ergänzt werden

Was „Hermes" ist#

Hermes ist ein KI-Agent. Das bedeutet: Es ist nicht nur ein Chatbot, sondern eine Software, die Werkzeuge benutzen kann. Hermes kann:

  • E-Mails lesen und schreiben
  • Dateien durchsuchen und bearbeiten
  • Befehle auf Servern ausführen (via SSH)
  • Kalender und Aufgaben verwalten
  • Dashboards und Berichte erstellen
  • Und vieles mehr — durch „Skills" (Fähigkeiten, die man ihr beibringen kann)

Hermes läuft auf einem Laptop oder Server, verbindet sich mit einem LLM (Large Language Model — der „Gehirn"-Teil, z. B. über OpenRouter), und arbeitet als persönliche Assistenz.

Kosten-Philosophie#

ACME nutzt konsequent kostenlose oder sehr günstige Bausteine:

Baustein Kosten
OCI Server (Oracle Free Tier) 0 € / Monat
Grafana Cloud Free Tier 0 € / Monat
Laptop mit Windows + WSL einmalig
OpenRouter (LLM-Zugang, Cloud) nach Verbrauch, ~0,50–5 €/Tag
Lokales LLM auf Mac (ab M1, 32 GB) 0 € (einmalig Mac-Anschaffung)
Vaultwarden (Passwort-Manager) 0 € (selbst gehostet)
Nextcloud (Kollaboration) 0 € (selbst gehostet)
Raspberry Pi (optional, NFS-Storage) ~50–80 € einmalig

Geschätzte monatliche Betriebskosten: 5–30 € (je nach LLM-Nutzung; 0 € wenn ausschließlich lokales LLM auf dem Mac genutzt wird)

Sicherheits-Grundregeln — ab Tag 1#

Bevor wir mit der Technik beginnen, hier die wichtigsten Regeln, die von der ersten Minute an gelten. Sie kosten nichts, sind aber die wichtigste Investition in die Sicherheit deiner Firma.

Regel 1: Eigene E-Mail-Adresse nur für ACME#

Die wichtigste Regel. Erstelle eine dedizierte E-Mail-Adresse ausschließlich für ACME — für alle Registrierungen, alle Konten, alle dienstlichen Kommunikation.

Was bedeutet „dediziert"? Die Adresse wird nur für ACME genutzt. Nicht für private Sachen, nicht für Newsletter, nicht für Online-Shops. Keine Ausnahme.

Warum?

  1. Trennung von Privat und Firma: Wenn du die Firma später verkaufst, schließt oder abgibst, bleibt dein privates Postfach unberührt.
  2. Sicherheit bei Kompromittierung: Wenn die ACME-Adresse durch einen Datenverlust bei einem Dienst geleakt wird, sind deine privaten Konten nicht betroffen — und umgekehrt.
  3. Übersichtlichkeit: Alle firmenbezogenen E-Mails an einem Ort.
  4. Professionalität: Eine Adresse wie [email protected] wirkt seriöser als eine private Adresse.

Wie? Nutze z. B. das E-Mail-Konto, das bei deiner Nextcloud- Installation dabei ist (Nextcloud Mail). Alternativ ein kostenloser Anbieter wie ProtonMail oder Tutanota. Wichtig: Diese Mail-Adresse wird zur „Reset-Adresse" für alle Konten — sie ist also besonders schützenswert.

Regel 2: Für jede Registrierung ein eigenes, langes Passwort#

Nie wieder dasselbe Passwort zweimal. Jeder Dienst — Cloudflare, Njalla, Oracle, OpenRouter, LM Studio, etc. — bekommt sein eigenes, einzigartiges Passwort.

Was macht ein gutes Passwort?

  • Länge statt Komplexität: Ein 30-stelliges Passwort aus Wörtern (z. B. Kaffee-Tasse-Berg-Neblig-47-Fenster) ist sicherer als ein kurzes mit Sonderzeichen (Ab3!xY)
  • Einzigartig: Nicht woanders wiederverwendet
  • Zufällig: Nicht erratbar (keine Geburtsdaten, Namen, etc.)

Wie schafft man das? Niemand kann sich 50 verschiedene lange Passwörter merken. Die Lösung: einen Passwort-Manager (Vaultwarden, den wir in Phase 5 installieren). Bis dahin: Notiere Passwörter temporär in einer verschlüsselten Datei und übertrage sie später.

Die Bitwarden-App und Browser-Erweiterung: Vaultwarden ist Bitwarden-kompatibel. Das bedeutet, du kannst die offizielle Bitwarden-App (für dein Handy) und die Browser-Erweiterung (für Chrome, Firefox, Safari) nutzen. Sobald alle Passwörter in Vaultwarden sind, funktioniert das so:

  1. Du gehst zu einer Login-Seite (z. B. cloud.acme.firm)
  2. Die Bitwarden-Browser-Erweiterung erkennt die Seite
  3. Mit einem Klick füllt sie Benutzername und Passwort aus
  4. Du musst dir kein einziges Passwort merken — außer dem Master-Passwort für Vaultwarden selbst

Das Master-Passwort ist das einzige, das du auswendig wissen musst. Es sollte besonders lang und sicher sein — es schützt schließlich alle anderen.

Regel 3: 2FA überall, wo es geht#

Was ist 2FA? Two-Factor Authentication — eine zweite Sicherheitsebene neben dem Passwort. Beim Login gibst du nicht nur das Passwort ein, sondern bestätigst zusätzlich mit einem Code aus einer App (z. B. Aegis, 2FAS) oder einem Hardware-Key.

Aktiviere 2FA mindestens bei: - Vaultwarden (das Master-Passwort allein reicht sonst) - Cloudflare - Oracle Cloud - OpenRouter - Njalla

Regel 4: Die ACME-Identität ist Firmeneigentum#

Alle Accounts, die du für ACME erstellst, gehören der Firma — nicht dir persönlich. Das bedeutet:

  • Nutze die ACME-E-Mail-Adresse bei jeder Registrierung
  • Trage als Namen die Firma ein, nicht dich privat
  • Wenn du jemals die Firma abgibst: Alle Zugänge gehen an den Nachfolger über
  • Dokumentiere jeden Account in Vaultwarden mit Ordner „ACME/Services"

Architektur-Überblick#

Das komplette Bild — eine Sicht#

┌──────────────────────────────────────────────────────────────────┐
│                          INTERNET                                  │
└──────┬───────────────────────────────────────┬────────────────────┘
       │                                       │
       ▼                                       ▼
┌──────────────┐                      ┌───────────────┐
│  Cloudflare   │                      │  OpenRouter   │
│  WAF + CDN    │                      │  (LLM-API)    │
│  Free Plan    │                      └──────┬────────┘
└──────┬────────┘                             │
       │                                       │
       ▼                                       │
┌──────────────┐                               │
│  Njalla DNS   │                               │
│  acme.firm    │                               │
└──────┬────────┘                               │
       │                                       │
       ▼                                       │
┌───────────────────────────────────────────────┴───────────────────┐
│            OCI CLOUD SERVER (Oracle Free Tier, ARM)                 │
│            Ubuntu · Docker · Watchtower (Auto-Updates)             │
│                                                                    │
│  ┌─────────┐ ┌───────────┐ ┌───────────┐ ┌───────────────────────┐ │
│  │ Caddy   │ │Vaultwar-  │ │Nextcloud  │ │ Hermes Agent          │ │
│  │(HTTPS)  │ │  den      │ │(Teams-    │ │ ┌───────────────────┐ │ │
│  │         │ │(Passwörter)│ │ Ersatz)   │ │ │ Profil: IT        │ │ │
│  └────┬────┘ └───────────┘ │ + Talk    │ │ │ Profil: Büro       │ │ │
│       │                    │ + TURN    │ │ │ Profil: Projekt-A  │ │ │
│       │                    │ + Office  │ │ │ Profil: Buchhaltung│ │ │
│       │                    └─────┬─────┘ │ └───────────────────┘ │ │
│       │                          │        └───────────┬───────────┘ │
│       │                    ┌─────▼─────┐              │             │
│       │                    │ NFS Mount │              │             │
│       │                    │ (Nextcloud │              │             │
│       │                    │  Daten)   │              │             │
│       │                    └─────┬─────┘              │             │
│       │                          │                    │             │
│  ┌────▼──────────────────────────▼────────────────────▼──────────┐ │
│  │              WireGuard VPN (Port 51820)                         │ │
│  └────────┬───────────────────────────────────────┬────────────────┘ │
│           │                                       │                  │
│  ┌────────▼──────────────┐         ┌──────────────▼──────────────┐  │
│  │ [Optional] Zitadel    │         │  [Optional] Monitoring       │  │
│  │ (IAM / OIDC Login)    │         │  Prometheus + Exporter       │  │
│  └───────────────────────┘         │  [Optional] Elasticsearch    │  │
│                                    │  + Kibana (Audit-Logs)      │  │
│                                    │  [Optional] Grafana OSS      │  │
│                                    │  Filebeat                    │  │
│                                    └──────────────────────────────┘  │
│                                                                    │
│  ┌──────────────────────┐  ┌────────────────────────────────────┐  │
│  │ [Optional] Matrix     │  │ [Optional] OpenWebUI + MCPO       │  │
│  │ (Element-Server,      │  │ (Browser-Firmensteuerung via       │  │
│  │  sicherer Kanal)      │  │  Chat-Oberfläche + Tool-Gateway)  │  │
│  └──────────────────────┘  └────────────────────────────────────┘  │
└──────────┬───────────────────────────────────────────┬─────────────┘
           │                                           │
           │ WireGuard                                 │ WireGuard
           │ Tunnel                                    │ Tunnel (NFS)
           │                                           │
┌──────────▼──────────────────┐         ┌──────────────▼──────────────┐
│       LAPTOP (Windows)       │         │    RASPBERRY PI (optional)   │
│                              │         │    2 TB microSD als NFS-     │
│  ┌──────────┐ ┌───────────┐ │         │    Storage für Nextcloud     │
│  │WireGuard │ │ Hermes    │ │         │    und Elasticsearch          │
│  │ Client   │ │ Workspace │ │         │                               │
│  ├──────────┤ ├───────────┤ │         │  ┌─────────────┐             │
│  │  WSL2    │ │ Profil:   │ │         │  │ WireGuard   │             │
│  │ (Linux)  │ │   IT      │ │◄────────┤  │ Client/NFS  │             │
│  ├──────────┤ │ (erstes   │ │  NFS    │  │ Server      │             │
│  │ Docker   │ │  Profil)  │ │  Mount  │  └─────────────┘             │
│  │ Desktop  │ └───────────┘ │         └───────────────────────────────┘
│  └──────────┘                │
│                              │
│  ┌──────────────────────────┐│
│  │ [Optional] Hermes        ││
│  │ Desktop App              ││
│  └──────────────────────────┘│
└──────────────────────────────┘

┌──────────────────────────────────────────────────────────────────┐
│                  GRAFANA CLOUD (Free Tier)                         │
│                                                                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐             │
│  │ Dashboard:   │  │ Dashboard:   │  │ Dashboard:   │             │
│  │ Kosten-      │  │ System-      │  │ Audit-       │             │
│  │ kontrolle    │  │ Gesundheit   │  │ Übersicht    │             │
│  └──────────────┘  └──────────────┘  └──────────────┘             │
│  (Metriken werden vom OCI-Server hierher gesendet — Remote Write)  │
└────────────────────────────────────────────────────────────────────┘

Wie das alles zusammenhängt — einfach erklärt#

Der Laptop ist dein Arbeitsgerät. Darauf läuft Windows, und innerhalb von Windows eine Linux-Umgebung (WSL2). In WSL2 läuft Docker Desktop — das ist die Plattform, auf der Container (isolierte Software-Boxen) laufen. Und in Docker läuft Hermes Workspace — die erste Instanz von Hermes, noch lokal auf deinem Laptop. Das erste Profil, das du anlegst, heißt „IT". Dieses Profil wird später den gesamten Server-Aufbau miterledigen.

Falls du einen Mac (ab M1, 32 GB RAM) hast, kann auf demselben Gerät zusätzlich ein lokales LLM (z. B. Qwen 3) laufen — dann arbeitet Hermes komplett kostenlos und offline, ohne Cloud-Anbindung.

Der OCI-Server ist das „Firmen-Rechenzentrum" — ein kleiner Cloud-Server bei Oracle, der dauerhaft kostenlos zur Verfügung steht. Hier laufen alle zentralen Dienste: Passwort-Manager, Dateiablage, Chat, die KI-Assistentin, Monitoring. Watchtower hält alle Docker-Container automatisch auf dem neuesten Stand.

Der Raspberry Pi (optional, empfohlen) ist eine kleine Erweiterung: Er hat eine 2-TB-microSD-Karte und dient als Speicher-Erweiterung für den OCI-Server. Die Verbindung läuft über WireGuard (verschlüsselter Tunnel) und NFS (Network File System — ein Protokoll, um Festplatten übers Netzwerk einzubinden). So hat Nextcloud reichlich Platz, ohne dass man teuren Cloud-Speicher mieten muss.

Grafana Cloud ist die „Zentrale Steuerkonsole" — ein kostenloser Cloud-Dienst, der alle Metriken visualisiert. Hier siehst du auf einen Blick: Läuft alles? Was kostet es?

WireGuard ist der sichere Tunnel zwischen Laptop, Raspberry Pi und Server. Ohne VPN ist der Server von außen erreichbar; mit VPN nur für autorisierte Geräte.

Die Audit-Logs sind das „Überwachungssystem" — Elasticsearch sammelt alle Ereignisse (wer hat sich eingeloggt? Was hat Hermes getan?), Kibana macht daraus durchsuchbare Berichte. Du kannst jederzeit nachvollziehen, was die KI-Assistentin erledigt hat.

Komponenten-Übersicht#

Was jeder Baustein macht — und warum ACME ihn braucht#

Baustein Was es ist Warum ACME es braucht Pflicht?
Laptop (Windows + WSL2 + Docker Desktop) Dein Arbeitsgerät Arbeitsplatz + Hermes-Entwicklungsumgebung ✅ Pflicht
Hermes Workspace (lokal) Web-Oberfläche für Hermes Erstes Profil „IT" wird hier angelegt — noch vor dem Server ✅ Pflicht
OCI Free Tier Kostenloser Cloud-Server (4 ARM-Cores, 24 GB RAM) Firmen-Rechenzentrum — läuft 24/7, kostet nichts ✅ Pflicht
Docker Container-Plattform Lässt mehrere Dienste isoliert auf einem Server laufen ✅ Pflicht
Watchtower Auto-Update für Docker-Container Hält alle Dienste automatisch aktuell — kein manuelles Update nötig ✅ Pflicht
Caddy Webserver / Reverse Proxy HTTPS-Verschlüsselung automatisch, routet Traffic ✅ Pflicht
Vaultwarden Passwort-Manager Sichere Ablage aller Passwörter ✅ Pflicht
Nextcloud Kollaborationsplattform Dateien, Chat, Video, Office — alles in einem ✅ Pflicht
Nextcloud Talk + TURN Video/Chat + TURN-Server für NAT-Traversal Teams-Ersatz; TURN nötig für Video hinter Router ✅ Pflicht
Nextcloud Office Online-Office-Paket Word/Excel/PowerPoint-Ersatz im Browser ✅ Pflicht
WireGuard VPN Sichere, verschlüsselte Verbindung zwischen Laptop/Pi und Server ✅ Pflicht
Hermes Agent (OCI) KI-Assistentin auf dem Server Erledigt Aufgaben, verwaltet Dokumente, überwacht Systeme ✅ Pflicht
OpenRouter LLM-API-Gateway (Cloud) Zugang zu KI-Modellen (Claude, GPT, GLM, etc.) — pay-per-use ✅ Pflicht (Option A)
Lokales LLM (Mac) KI-Modell lokal auf dem Mac 0 € laufende Kosten, volle Datenhoheit — Qwen 3, Llama 4, etc. ⬜ Optional (Option B)
Grafana Cloud Dashboard-Plattform (gehostet) Visualisiert Metriken, Alerting, kostenlos ✅ Pflicht
Prometheus + Exporter Metrik-System Sammelt Zahlen: CPU, RAM, Token-Verbrauch, Kosten ✅ Pflicht
Raspberry Pi + 2 TB microSD Mini-Computer als NFS-Storage Erweitert OCI-Speicher billig auf 2 TB ⬜ Optional (empfohlen)
Zitadel Identity Provider (IAM) Zentrales Login — ein Passwort für alle Dienste ⬜ Optional
Elasticsearch + Kibana Such- und Analyse-Engine Audit-Logs durchsuchbar („Was hat Hermes getan?") ⬜ Optional
Filebeat Log-Sammler Sammelt System- und Hermes-Logs für Elasticsearch ⬜ Optional
Grafana OSS Lokale Grafana-Instanz Alternative zu Grafana Cloud, mehr Kontrolle ⬜ Optional
OpenWebUI + MCPO Browser-Chat + Tool-Gateway Chat-Oberfläche im Browser, steuert Hermes-Tools ⬜ Optional
Matrix / Element Messenger-Plattform Sicherer Kanal (Browser + App) zu Hermes-Profilen ⬜ Optional
Docker Desktop (lokal) Container-Verwaltung Lässt Hermes lokal auf dem Laptop testen ✅ Pflicht
Njalla DNS / Domain Privater Domain-Registrierer ✅ Pflicht
Cloudflare CDN + WAF Schützt Server vor Angriffen, beschleunigt ✅ Pflicht

Der wichtige Unterschied: Pflicht vs. Optional#

Das Minimum für ACME besteht aus: Laptop mit Hermes, OCI-Server mit Caddy/Vaultwarden/Nextcloud/WireGuard, OpenRouter, Grafana Cloud.

Optionale Bausteine können jederzeit später ergänzt werden. Sie bringen Mehrwert, sind aber für den Start nicht zwingend:

  • Raspberry Pi — wenn der OCI-Speicher (200 GB) nicht reicht
  • Zitadel — wenn mehrere Personen mitmachen und zentrales Login wichtig wird
  • Elasticsearch + Kibana — wenn detaillierte Audit-Logs gewünscht sind
  • OpenWebUI + MCPO — wenn du Hermes lieber im Browser bedienst statt Telegram
  • Matrix/Element — wenn ein zweiter, sicherer Messenger-Kanal neben Nextcloud Talk gewünscht ist
  • Grafana OSS — wenn du statt Grafana Cloud eine lokale Instanz willst

Phasenplan — Der Aufbau in 12 Schritten#

Phase Was passiert Dauer (geschätzt)
Phase 1 Hermes auf dem Laptop installieren + Profil „IT" anlegen 2 Stunden
Phase 2 Domain & DNS (mit Hermes-Beratung) 1 Stunde
Phase 3 OCI-Server vorbereiten (Hermes richtet sich selbst ein) 2 Stunden
Phase 4 Sicherheit: WireGuard, Firewall 2 Stunden
Phase 5 Basis-Dienste: Caddy, Vaultwarden, Watchtower 2 Stunden
Phase 6 NFS-Storage: Raspberry Pi einbinden (optional) 2 Stunden
Phase 7 Nextcloud als Teams-Ersatz + TURN-Server 3 Stunden
Phase 8 Hermes Agent auf OCI installieren + Profile migrieren 2 Stunden
Phase 9 Monitoring: Prometheus, Grafana Cloud, Dashboards 3 Stunden
Phase 10 [Optional] Elasticsearch, Zitadel, OpenWebUI, Matrix 4 Stunden
Phase 11 Knowledge Base & Skills aufbauen 3 Stunden
Phase 12 Inbetriebnahme, Tests, Dokumentation 2 Stunden

Gesamtaufwand: ~28 Stunden (über mehrere Tage/Wochen verteilt)

Das wichtige Prinzip: Ab Phase 2 ist Hermes bereits aktiv. Du besprichst alles mit dem IT-Profil, und Hermes erledigt viele Konfigurationsschritte selbstständig auf dem Server — via SSH, sobald er Zugang hat.

PHASE 1 — Hermes auf dem Laptop installieren + Profil „IT" anlegen#

Was wir hier tun#

Hermes kommt zuerst. Noch bevor es einen Server gibt, eine Domain, oder irgendwelche Dienste — installierst du Hermes auf deinem Laptop. Du legst das erste Profil an: „IT". Dieses Profil wird später den gesamten Server-Aufbau miterledigen.

Stell dir vor, du stellst als Erstes deinen IT-Administrator ein. Bevor es ein Büro gibt, sitzt er am Küchentisch und plant alles mit. Genau das macht das IT-Profil.

Schritt 1.1: WSL2 einrichten#

Was ist WSL2? WSL2 (Windows Subsystem for Linux, Version 2) lässt ein vollwertiges Linux direkt unter Windows laufen — ohne virtuelle Maschine, ohne Dual-Boot. Du hast ein normales Windows, und darin ein Linux-Terminal, das nahtlos mit Windows-Dateien arbeiten kann.

  1. Öffne PowerShell als Administrator
  2. Führe aus: 
    wsl --install
  3. Windows installiert WSL2 und Ubuntu
  4. Starte den Laptop neu
  5. Öffne Ubuntu (Startmenü → „Ubuntu")
  6. Lege einen Linux-Benutzernamen und ein Passwort fest

Ab jetzt hast du ein Linux-Terminal unter Windows. Alle folgenden Befehle, die mit sudo beginnen, führst du in diesem Ubuntu-Terminal aus.

Schritt 1.2: Docker Desktop installieren#

Was ist Docker? Docker ist wie ein Schiffsfrachter für Software: Jedes Programm läuft in einem „Container" — einer isolierten Box, die alles enthält, was das Programm braucht. Dadurch geraten Programme nicht miteinander in Konflikt und lassen sich leicht installieren und aktualisieren.

  1. Gehe zu docker.com → „Docker Desktop for Windows"
  2. Lade herunter und installiere
  3. Bei der Installation: „Use WSL 2 instead of Hyper-V" ankreuzen
  4. Starte Docker Desktop
  5. Gehe zu Settings → Resources → WSL Integration → Ubuntu aktivieren
  6. Öffne das Ubuntu-Terminal und teste: 
    docker --version
docker run hello-world
    Wenn „Hello from Docker!" erscheint, funktioniert es.

Schritt 1.3: Hermes Workspace installieren#

Was ist Hermes Workspace? Hermes Workspace ist die Web-Oberfläche für Hermes. Es ist kein Chat-Programm — es ist ein Dashboard, über das du Profile verwaltest, Skills konfigurierst, Memories einsehst und Hermes beauftragst. Es läuft lokal auf deinem Laptop (in Docker).

# Im Ubuntu-Terminal:
mkdir -p ~/hermes-workspace && cd ~/hermes-workspace

# Hermes Workspace Docker-Image laden
docker run -d \
  --name hermes-workspace \
  -p 9119:9119 \
  -v $(pwd)/data:/data \
  -v /var/run/docker.sock:/var/run/docker.sock \
  --restart unless-stopped \
  ghcr.io/nousresearch/hermes-workspace:latest

Öffne im Browser: http://localhost:9119

Beim ersten Öffnen wirst du nach einem Passwort gefragt. Wähle ein sicheres Passwort und notiere es (später in Vaultwarden).

Schritt 1.4: LLM-Backend einrichten — OpenRouter (Cloud) oder lokal (Mac)#

Was ist ein LLM-Backend? Das LLM (Large Language Model) ist das „Gehirn" von Hermes. Hermes selbst ist die Hände — sie führt Befehle aus, liest Dateien, bedient Tools. Aber das Denken, Formulieren, Entscheiden macht das LLM. Dafür braucht Hermes Zugriff auf ein solches Modell.

ACME hat hier zwei Optionen, die sich jederzeit ergänzen oder austauschen lassen:

Option A: OpenRouter (Cloud — einfach, pay-per-use)#

Was ist OpenRouter? OpenRouter ist wie ein Vermittler: Du fragst bei OpenRouter an, und OpenRouter leitet deine Anfrage an das KI-Modell deiner Wahl weiter. Ein Account reicht für Zugang zu allen Modellen (Claude, GPT, GLM, DeepSeek, etc.).

Vorteile: Keine Hardware nötig, sofort startklar, Zugang zu den besten Modellen weltweit, zahlt nur was du verbrauchst.

Nachteile: Laufende Kosten (wenig, aber vorhanden), Daten verlassen den eigenen Rechner.

  1. Gehe zu openrouter.ai und erstelle einen Account
  2. Gehe zu „Keys" → erstelle einen API-Key
  3. Lade den Key mit Guthaben auf (z. B. 20 € — reicht für Wochen)
  4. Wähle ein Modell — für ACME empfohlen:
Modell Preis pro 1M Token Wann nutzen?
z-ai/glm-5.2 ~0,95 € / 3,00 € Standard (gut + günstig)
anthropic/claude-sonnet-4 ~3,00 € / 15,00 € Komplexe Aufgaben
deepseek/deepseek-chat ~0,09 € / 0,18 € Sehr günstig, einfache Aufgaben

Option B: Lokales LLM auf einem Mac (ab M1, 32 GB RAM)#

Was ist ein lokales LLM? Statt die KI-Anfragen ins Internet zu schicken, lässt du das Modell direkt auf deinem eigenen Mac laufen. Nichts verlässt deinen Rechner — voller Datenschutz, null laufende Kosten.

Voraussetzung: Ein Mac mit Apple Silicon (M1, M2, M3, M4 oder höher) und mindestens 32 GB RAM. Das Modell braucht viel Arbeitsspeicher — mit 16 GB ist nur ein sehr kleines Modell nutzbar.

Empfohlene Modelle für den Mac:

Modell RAM-Bedarf Qualität Wann nutzen?
Qwen 3 8B ~6 GB Gut für einfache Aufgaben Normale Büro-Aufgaben
Qwen 3 32B (quantisiert) ~20 GB Sehr gut Standard, sparsam
Llama 4 Scout 17B ~12 GB Gut Alternative zu Qwen
DeepSeek R1 Distill 32B ~20 GB Gut für Logik/Code Analytische Aufgaben

Einrichtung mit LM Studio (empfohlen für Nicht-ITler):

  1. Lade LM Studio von lmstudio.ai herunter und installiere es
  2. Öffne LM Studio → „Search" → suche z. B. „Qwen 3 32B GGUF"
  3. Wähle eine quantisierte Version (z. B. Q4_K_M — das ist die komprimierte Form, die weniger RAM braucht)
  4. Lade das Modell herunter (ca. 5–20 GB, je nach Modell)
  5. Gehe zum Tab „Local Server" → „Start Server"
  6. LM Studio läuft nun auf http://localhost:1234 und bietet eine OpenAI-kompatible API

So verbindest du Hermes mit dem lokalen Modell:

In der Hermes-Konfiguration (siehe Schritt 1.5) trägst du statt OpenRouter einfach die lokale Adresse ein:

llm:
  provider: openai-compatible
  base_url: http://localhost:1234/v1
  model: qwen-3-32b
  api_key: not-needed  # LM Studio verlangt keinen echten Key

Vorteile: Keine laufenden Kosten, volle Datenhoheit, offline-fähig. Nachteile: Nur auf dem Mac nutzbar (nicht auf dem OCI-Server), langsamer als Cloud-Modelle bei sehr komplexen Aufgaben, modellseitig begrenzt auf das, was in 32 GB RAM passt.

Option C: Beide parallel (empfohlen)#

Die beste Lösung für ACME: Du nutzt beide — und kannst jederzeit wechseln, ohne Hermes neu zu konfigurieren.

Szenario Welches Backend?
Am Mac sitzend, einfache Büro-Aufgaben Lokal (Qwen 3) — kostenlos, privat
Unterwegs, per Telegram OpenRouter (Cloud) — von überall
Komplexe Programmier-Aufgaben OpenRouter (Claude) — höchste Qualität
Vertrauliche Kundendaten Lokal (Qwen 3) — Daten verlassen nicht den Mac

Hermes unterstützt Fallback-Ketten: Wenn das lokale Modell nicht verfügbar ist (z. B. Mac ausgeschaltet), fällt Hermes automatisch auf OpenRouter zurück. So bist du immer abgedeckt.

llm:
  primary:
    provider: openai-compatible
    base_url: http://localhost:1234/v1
    model: qwen-3-32b
  fallback:
    provider: openrouter
    model: z-ai/glm-5.2
    api_key: ${OPENROUTER_API_KEY}

Token sind die „Währung" der KI — ein Token ist etwa ein Wort. Wenn Hermes eine Aufgabe erledigt, verbraucht sie Token (beim lokalen Modell kostenlos, bei OpenRouter kostenpflichtig). Das Kosten-Tracking (Phase 9) zeigt genau, wie viele Token pro Tag verbraucht werden und welches Backend sie verursacht hat.

Schritt 1.5: Hermes konfigurieren#

Erstelle die Konfigurationsdatei:

mkdir -p ~/.hermes
nano ~/.hermes/config.yaml

Inhalt:

# LLM-Konfiguration
llm:
  provider: openrouter
  model: z-ai/glm-5.2
  api_key: ${OPENROUTER_API_KEY}

# Gateway (Web-API für Hermes)
gateway:
  enabled: true
  port: 8642

# Workspace (Web-Dashboard)
workspace:
  enabled: true
  port: 9119
  password_hash: <hash-von-deinem-passwort>

Umgebungsvariablen (API-Key sicher speichern):

nano ~/.hermes/.env
OPENROUTER_API_KEY=sk-or-v1-...dein-key...

Schritt 1.6: Das erste Profil anlegen — „IT"#

Was ist ein Profil? Ein Profil ist eine eigenständige Hermes-Instanz mit eigenen Skills, eigenen Erinnerungen (Memories), eigenem Chat-Verlauf und eigener Persönlichkeit. Verschiedene Profile sind wie verschiedene Mitarbeiter: Jeder hat seine Aufgabe, sein Wissen und seine Gesprächshistorie.

Das erste Profil ist „IT" — der IT-Administrator von ACME.

# Profil erstellen
hermes profile create IT

# Profil aktivieren
hermes profile use IT

Jetzt konfigurieren wir das IT-Profil mit einer Persönlichkeit und einem klar definierten Aufgabenbereich:

nano ~/.hermes/profiles/IT/config.yaml
# Profil: IT — Der IT-Administrator von ACME
name: IT
description: >
  IT-Administrator für die Firma ACME. Verantwortlich für den
  technischen Aufbau und Betrieb der gesamten Infrastruktur.
  Berät den Inhaber bei technischen Entscheidungen und führt
  Konfigurationsaufgaben auf dem Server selbstständig durch.

# System-Prompt (wer Hermes "ist" in diesem Profil)
system_prompt: >
  Du bist der IT-Administrator der Firma ACME.
  Deine Aufgabe ist es, den Inhaber bei allen IT-Themen zu beraten
  und praktische Arbeiten auf dem Server durchzuführen.
  Du arbeitet sorgfältig, dokumentierst alle Schritte und fragst
  nach, bevor du etwas Zerstörisches tust.
  Du sprichst Deutsch, erklärst technische Zusammenhänge verständlich
  und gibst Empfehlungen ab.

# Tools, die dieses Profil nutzen darf
tools:
  - terminal       # Befehle ausführen (lokal + SSH)
  - web_search     # im Web suchen
  - web_extract    # Webseiten lesen
  - write_file     # Dateien schreiben
  - read_file      # Dateien lesen
  - patch          # Dateien bearbeiten
  - memory         # sich Dinge merken

Schritt 1.7: Mit dem IT-Profil sprechen#

Öffne Hermes Workspace im Browser: http://localhost:9119

Wähle das Profil „IT" und beginne das erste Gespräch:

Du: Hallo. Ich gründe eine Firma namens ACME. Ich bin allein. Du bist mein IT-Administrator. Wir fangen bei null an — ich habe nur diesen Laptop. Was schlägst du als Erstes vor?

Hermes (IT): Willkommen! Bevor wir irgendetwas kaufen oder installieren, sollten wir uns organisieren. Hier ist mein Vorschlag für die nächsten Schritte:

  1. Domain besorgen — eine Internet-Adresse für ACME
  2. Cloud-Server mieten — ich empfehle Oracle Free Tier (kostenlos)
  3. Passwort-Manager aufsetzen — bevor wir Passwörter haben, brauchen wir einen sicheren Tresor
  4. Sichere Verbindung (VPN) — damit nur du auf den Server kommst
  5. Kollaborationsplattform — Nextcloud als Ersatz für Microsoft Teams

Sobald du den Server hast, kann ich viele dieser Schritte selbst übernehmen. Fangen wir mit der Domain an?

Das ist das Prinzip: Ab jetzt besprichst du jeden Schritt mit dem IT-Profil. Hermes berät, plant, und sobald der Server existiert, erledigt er die Konfiguration selbstständig.

Schritt 1.8: Skills für das IT-Profil#

Was sind Skills? Skills sind Fähigkeiten, die Hermes beibringen, wie wiederkehrende Aufgaben erledigt werden. Ein Skill ist eine Markdown-Datei mit Schritt-für-Schritt-Anleitungen.

Lege folgende Skills für das IT-Profil an:

mkdir -p ~/.hermes/profiles/IT/skills

Skill: acme-server-setup#

---
name: acme-server-setup
description: Richtet einen neuen OCI-Server für ACME ein
---

# OCI-Server einrichten

1. Verbinde dich per SSH: `ssh -i <key> ubuntu@<ip>`
2. System aktualisieren: `sudo apt update && sudo apt upgrade -y`
3. Zeitszone setzen: `sudo timedatectl set-timezone Europe/Berlin`
4. Docker installieren: `curl -fsSL https://get.docker.com | sudo sh`
5. Auto-Updates aktivieren: Watchtower einrichten
6. Verzeichnisstruktur erstellen: `mkdir -p ~/acme/{caddy,vaultwarden,nextcloud,...}`
7. Firewall konfigurieren: UFW, nur 443, 80, 51820
8. Hermes-Benutzer anlegen: `sudo adduser hermes`
9. SSH-Key für Hermes hinterlegen
10. Bericht an Inhaber: „Server ist bereit"

Skill: acme-service-deploy#

---
name: acme-service-deploy
description: Stellt einen Docker-Dienst auf dem ACME-Server bereit
---

# Dienst bereitstellen

1. docker-compose.yml erstellen oder aus Vorlage laden
2. Auf dem Server ablegen: `scp docker-compose.yml ubuntu@<ip>:~/acme/<service>/`
3. Starten: `ssh ubuntu@<ip> "cd ~/acme/<service> && docker compose up -d"`
4. Status prüfen: `docker ps`
5. Health-Check durchführen (HTTP-Request)
6. Caddy-Reverse-Proxy-Eintrag hinzufügen
7. In Vaultwarden Passwort eintragen
8. In Hermes config den Dienst eintragen
9. Bericht an Inhaber

Diese Skills legen wir jetzt schon an — auch bevor der Server existiert. Wenn der Server dann steht, kann Hermes diese Skills abrufen und ausführen, ohne dass du jeden Schritt einzeln erklären musst.

Ergebnis nach Phase 1: Hermes läuft auf deinem Laptop, das IT-Profil ist angelegt und mit OpenRouter verbunden. Du hast deinen ersten „Mitarbeiter" — den IT-Administrator. Jetzt geht es darum, ihm einen Arbeitsplatz (den Server) zu geben.

PHASE 2 — Domain & DNS (mit Hermes-Beratung)#

Was wir hier tun#

Wir besorgen ACME eine Internet-Adresse (Domain) und rufen ein, dass Anfragen an diese Adresse an unseren (späteren) Server weitergeleitet werden. Und: Wir lassen uns dabei von Hermes beraten.

Stell dir vor, du mietest eine Geschäftsadresse. Du brauchst eine Straße, ein Schild an der Tür und ein Telefonbuch, damit Kunden dich finden. Im Internet ist das die Domain (die Adresse), DNS (das Telefonbuch) und der Server (das Büro).

Schritt 2.1: Domain bei Njalla registrieren#

Warum Njalla? Njalla ist ein privacy-fokussierter Domain-Registrierer. Anders als bei vielen anderen Anbietern werden deine persönlichen Daten nicht im WHOIS-Verzeichnis veröffentlicht. Für eine Firma bedeutet das: Deine private Adresse ist nicht öffentlich sichtbar.

  1. Öffne Hermes Workspace und frage das IT-Profil:

    „Ich brauche eine Domain für ACME. Welche Endung empfiehlst du?"

  2. Hermes berät dich (z. B. .se, .firms, .consulting)
  3. Gehe zu njalla.org und suche eine Domain
  4. Wähle eine Domain aus und kaufe sie (ca. 15–20 €/Jahr)
  5. Wichtig: Notiere dir die Login-Daten — sie kommen später in Vaultwarden

Schritt 2.2: Cloudflare einrichten#

Warum Cloudflare? Cloudflare sitzt wie ein Türsteher vor deinem Server. Es blockt Angriffe, beschleunigt die Seite durch Caching und bietet kostenloses HTTPS. Der „Free Plan" reicht für ACME.

  1. Gehe zu cloudflare.com und erstelle einen kostenlosen Account
  2. Klicke „Add a Site" → gib deine Domain ein
  3. Cloudflare zeigt dir zwei Nameserver:
  4. alice.ns.cloudflare.com
  5. bob.ns.cloudflare.com
  6. Gehe zurück zu Njalla → Domain-Einstellungen → Nameserver
  7. Ersetze die Njalla-Nameserver durch die Cloudflare-Nameserver
  8. Warte ca. 1–24 Stunden (DNS braucht Zeit)

Schritt 2.3: DNS-Einträge erstellen#

Wenn Cloudflare aktiv ist, erstellst du dort die DNS-Einträge. Das sind die „Wegweiser", die sagen: „Wenn jemand acme.firm aufruft, gehe zu dieser IP-Adresse."

Typ Name Wert Proxy Bedeutung
A @ <OCI-Server-IP> Proxied (orange Wolke) Hauptdomain → Server
A vault <OCI-Server-IP> Proxied vault.acme.firm → Vaultwarden
A cloud <OCI-Server-IP> Proxied cloud.acme.firm → Nextcloud
A hermes <OCI-Server-IP> Proxied hermes.acme.firm → Hermes
A turn <OCI-Server-IP> DNS only (grau) TURN-Server für Nextcloud Talk
A kibana <OCI-Server-IP> Proxied [Optional] Kibana
A grafana <OCI-Server-IP> Proxied [Optional] Grafana OSS
A login <OCI-Server-IP> Proxied [Optional] Zitadel
A matrix <OCI-Server-IP> Proxied [Optional] Matrix
A chat <OCI-Server-IP> Proxied [Optional] OpenWebUI

„Proxied" (orange Wolke): Cloudflare steht vor dem Dienst und schützt ihn. Der Server ist direkt im Internet nur über Cloudflare erreichbar.

„DNS only" (graue Wolke): Cloudflare leitet nur weiter, schützt aber nicht. Das nutzen wir für Dienste, die Cloudflare nicht vertragen (z. B. WireGuard VPN oder TURN-Server, die direkten Traffic brauchen).

Tipp: Frag Hermes, welche DNS-Einträge du anlegen solltest. Das IT-Profil kann dir eine komplette Liste generieren, sobald du ihm die Server-IP mitteilst.

Ergebnis nach Phase 2: ACME hat eine Domain, die über Cloudflare geschützt wird. DNS ist vorbereitet — jetzt brauchen wir den Server.

PHASE 3 — OCI-Server vorbereiten (Hermes richtet sich selbst ein)#

Was wir hier tun#

Wir mieten einen kostenlosen Cloud-Server bei Oracle. Sobald der Server steht, geben wir Hermes (dem IT-Profil) SSH-Zugriff. Ab diesem Moment kann Hermes sich selbst auf dem Server einrichten: Docker installieren, Firewall konfigurieren, Verzeichnisse anlegen, Watchtower starten.

Das ist der Wendepunkt: Ab hier erledigt Hermes die meiste Arbeit selbstständig — du besprichst, was getan werden soll, und Hermes führt es auf dem Server aus.

Schritt 3.1: Oracle Cloud Free Tier Account#

Oracle bietet dauerhaft kostenlose Server an — das „Always Free" Programm. Das ist kein Trial, sondern gilt unbefristet.

  1. Gehe zu oracle.com/cloud/free
  2. Klicke „Start for free"
  3. Registriere dich (Kreditkarte wird zur Verifizierung verlangt, aber nicht abgebucht)
  4. Wähle als Region Frankfurt (eu-central-1) — wichtig für DSGVO

Was du kostenlos bekommst:

Ressource Menge
ARM-CPUs 4 Kerne
RAM 24 GB
Festplatte (Boot-Volume) 200 GB
Bandbreite 10 TB/Monat

Das ist mehr als genug für ACME. Zum Vergleich: Ein vergleichbarer VPS bei anderen Anbietern kostet 20–40 €/Monat.

Speicher-Hinweis: Die 200 GB Boot-Volume reichen für das Betriebssystem und alle Dienste. Für Nextcloud-Dateien und [optional] Elasticsearch-Logs kann das knapp werden. Die Lösung: Ein Raspberry Pi mit 2 TB microSD als NFS-Storage (siehe Phase 6).

Schritt 3.2: Compute-Instanz erstellen#

  1. Im OCI Dashboard → Compute → Instances → „Create Instance"
  2. Name: acme-server
  3. Image: Canonical Ubuntu 22.04 (oder 24.04)
  4. Shape: VM.Standard.A1.Flex (die kostenlose ARM-Instanz)
  5. Konfiguriere: 4 OCPUs, 24 GB RAM
  6. SSH-Key: Lade einen öffentlichen SSH-Key hoch oder generiere ein neues Schlüsselpaar. Bewahre den privaten Schlüssel sicher auf! Ohne ihn kommst du nicht mehr auf den Server.
  7. Klicke „Create"

Nach ca. 2–3 Minuten ist der Server fertig. Du siehst die öffentliche IP-Adresse im Dashboard.

Schritt 3.3: Hermes SSH-Zugang geben#

Das ist der wichtigste Schritt in diesem Guide. Ab hier kann Hermes selbstständig auf dem Server arbeiten.

Damit Hermes sich per SSH mit dem Server verbinden kann, brauchen wir einen SSH-Key für Hermes und hinterlegen den öffentlichen Teil auf dem Server.

3.3.1: SSH-Key für Hermes generieren#

Auf deinem Laptop (in WSL2):

# SSH-Key für Hermes generieren (ohne Passphrase, damit Hermes ihn automatisch nutzen kann)
ssh-keygen -t ed25519 -C "hermes-it@acme" -f ~/.ssh/hermes_acme_it -N ""

# Public Key anzeigen (den brauchen wir gleich auf dem Server)
cat ~/.ssh/hermes_acme_it.pub

3.3.2: Public Key auf dem Server hinterlegen#

Verbinde dich zuerst selbst per SSH auf den neuen Server:

ssh -i dein-schluessel.pem ubuntu@<server-ip>

Auf dem Server:

# Hermes-Benutzer anlegen
sudo adduser --disabled-password --gecos "" hermes

# Hermes sudo-Rechte geben (ohne Passwort, damit Hermes arbeiten kann)
echo "hermes ALL=(ALL) NOPASSWD:ALL" | sudo tee /etc/sudoers.d/hermes

# SSH-Verzeichnis für Hermes anlegen
sudo mkdir -p /home/hermes/.ssh
sudo touch /home/hermes/.ssh/authorized_keys

# Den Public Key von Hermes eintragen (den du eben generiert hast)
echo "<hermes-public-key-hier-einfügen>" | sudo tee -a /home/hermes/.ssh/authorized_keys

# Berechtigungen setzen
sudo chown -R hermes:hermes /home/hermes/.ssh
sudo chmod 700 /home/hermes/.ssh
sudo chmod 600 /home/hermes/.ssh/authorized_keys

3.3.3: Hermes für SSH-Zugriff konfigurieren#

Zurück auf dem Laptop — Hermes muss wissen, wie er sich verbindet:

nano ~/.hermes/profiles/IT/config.yaml

Ergänze:

# SSH-Konfiguration für Server-Zugriff
ssh:
  acme-server:
    host: <server-ip>
    user: hermes
    key: ~/.ssh/hermes_acme_it
    port: 22

3.3.4: Testen#

Frage Hermes im Workspace:

Du: Verbinde dich mit dem ACME-Server und prüfe, ob du Zugang hast.

Hermes (IT): Ich habe mich per SSH verbunden. Der Server läuft, Ubuntu 22.04, 4 ARM-Cores, 24 GB RAM. Ich habe Zugang als Benutzer „hermes" mit sudo-Rechten. Soll ich mit der Einrichtung beginnen?

Ab diesem Moment kann Hermes selbstständig auf dem Server arbeiten. Das ist der entscheidende Unterschied: Du musst keine Befehle mehr manuell eingeben — du sagst Hermes, was getan werden soll, und Hermes führt es aus.

Schritt 3.4: Hermes richtet den Server ein#

Jetzt kannst du Hermes beauftragen, die Grundkonfiguration durchzuführen. Sage im Workspace:

Du: Bitte richte den Server grundlegend ein: System-Update, Zeitzone Europe/Berlin, Docker installieren, Verzeichnisstruktur für ACME anlegen, Firewall konfigurieren.

Hermes wird dann (mithilfe des acme-server-setup-Skills) folgende Schritte ausführen:

  1. sudo apt update && sudo apt upgrade -y — System aktualisieren
  2. sudo timedatectl set-timezone Europe/Berlin — Zeitzone setzen
  3. curl -fsSL https://get.docker.com | sudo sh — Docker installieren
  4. sudo usermod -aG docker hermes — Hermes in Docker-Gruppe
  5. Verzeichnisstruktur: mkdir -p ~/acme/{caddy,vaultwarden,nextcloud,...}
  6. Firewall (UFW): nur Port 443, 80, 51820 offen
  7. Watchtower einrichten (Auto-Updates für Docker-Container)

Watchtower ist ein Docker-Container, der alle anderen Container automatisch aktualisiert. Wenn es eine neue Version von Nextcloud, Vaultwarden, etc. gibt, lädt Watchtower sie herunter und tauscht den Container aus — ohne dass du eingreifen musst.

# Watchtower (von Hermes ausgeführt)
docker run -d \
  --name watchtower \
  --restart unless-stopped \
  -v /var/run/docker.sock:/var/run/docker.sock \
  containrrr/watchtower \
  --cleanup --interval 86400

(--interval 86400 = prüft alle 24 Stunden auf Updates)

Ergebnis nach Phase 3: Der OCI-Server steht, Docker läuft, die Firewall ist konfiguriert, Watchtower hält alles aktuell. Und das Wichtigste: Hermes hat SSH-Zugriff und kann ab jetzt selbstständig auf dem Server arbeiten.

PHASE 4 — Sicherheit: WireGuard & Firewall#

Was wir hier tun#

Wir bauen die Sicherheitsschicht auf: WireGuard VPN als verschlüsselten Tunnel zwischen Laptop und Server. Nur wer im VPN ist, kann interne Dienste erreichen.

Stell dir das wie ein Bürogebäude vor: Der Parkplatz ist durch eine Schranke gesichert (VPN). Ohne Schlüsselkarte kommst du nicht rein.

Schritt 4.1: WireGuard VPN auf dem Server#

Warum WireGuard? WireGuard ist modern, extrem schnell und einfach zu konfigurieren. Es erstellt einen verschlüsselten Tunnel zwischen dem Laptop und dem Server. Interne Dienste (Hermes Workspace, Kibana, Grafana OSS) sind nur über das VPN erreichbar.

Du kannst Hermes bitten, WireGuard zu installieren:

Du: Bitte installiere WireGuard auf dem Server und lege eine Konfiguration für meinen Laptop an.

Hermes führt dann folgende Schritte aus:

# WireGuard installieren
sudo apt install -y wireguard

# Schlüsselpaar generieren
wg genkey | tee privatekey | wg pubkey > publickey
chmod 600 privatekey

Server-Konfiguration /etc/wireguard/wg0.conf:

[Interface]
PrivateKey = <server-private-key>
Address = 10.10.0.1/24
ListenPort = 51820

# Laptop
[Peer]
PublicKey = <laptop-public-key>
AllowedIPs = 10.10.0.2/32
sudo wg-quick up wg0
sudo systemctl enable wg-quick@wg0

Schritt 4.2: WireGuard auf dem Laptop#

  1. Lade WireGuard von wireguard.com herunter und installiere es
  2. Klicke „Add Tunnel" → „Add empty tunnel"
  3. Generiere automatisch ein Schlüsselpaar
  4. Konfiguration:
[Interface]
PrivateKey = <laptop-private-key>
Address = 10.10.0.2/24
DNS = 10.10.0.1

[Peer]
PublicKey = <server-public-key>
Endpoint = <server-ip>:51820
AllowedIPs = 10.10.0.0/24
PersistentKeepalive = 25
  1. Trage den Laptop-Public-Key in die Server-Konfiguration ein (Hermes kann das erledigen)
  2. Verbinde — du solltest den Server unter 10.10.0.1 pingen können

Ergebnis nach Phase 4: Der Server ist durch WireGuard abgesichert. Nur autorisierte Geräte können interne Dienste erreichen.

PHASE 5 — Basis-Dienste: Caddy, Vaultwarden, Watchtower#

Was wir hier tun#

Wir installieren zwei Grunddienste, die alle weiteren Schritte voraussetzen:

  1. Caddy — der Reverse Proxy, der HTTPS-Zertifikate automatisch besorgt und Anfragen an die richtigen Dienste weiterleitet
  2. Vaultwarden — der Passwort-Manager, in dem alle anderen Passwörter sicher liegen

Watchtower haben wir bereits in Phase 3 installiert.

Schritt 5.1: Caddy als Reverse Proxy#

Was ist ein Reverse Proxy? Stell dir Caddy wie einen Pförtner vor. Jemand kommt herein und sagt „Ich möchte zu Nextcloud". Caddy sagt „Zimmer 8080, bitte entlang" und leitet weiter. Caddy kümmert sich auch um HTTPS — die Verschlüsselung der Verbindung. Das macht Caddy völlig automatisch: Er holt sich Zertifikate von Let's Encrypt (kostenlos) und erneuert sie selbst.

Beauftrage Hermes:

Du: Bitte installiere Caddy als Reverse Proxy auf dem Server. Nutze die Domains aus der DNS-Konfiguration.

Hermes erstellt:

~/acme/caddy/docker-compose.yml:

version: '3.8'
services:
  caddy:
    image: caddy:2
    restart: unless-stopped
    ports:
      - "80:80"
      - "443:443"
    volumes:
      - ./Caddyfile:/etc/caddy/Caddyfile
      - ./data:/data
      - ./config:/config
    network_mode: host

~/acme/caddy/Caddyfile:

# Hauptdomain
acme.firm {
    respond "ACME — Willkommen"
}

# Vaultwarden (Passwort-Manager)
vault.acme.firm {
    reverse_proxy localhost:8001
}

# Nextcloud
cloud.acme.firm {
    reverse_proxy localhost:8080
}

# Hermes Workspace
hermes.acme.firm {
    reverse_proxy localhost:9119
}

# TURN (DNS only, kein Cloudflare Proxy)
turn.acme.firm {
    reverse_proxy localhost:3478
}

# --- Optional ---
# Zitadel (Login)
login.acme.firm {
    reverse_proxy localhost:8081
}

# Kibana (Audit-Logs)
kibana.acme.firm {
    reverse_proxy localhost:5601
}

# Grafana OSS
grafana.acme.firm {
    reverse_proxy localhost:3001
}

# Matrix
matrix.acme.firm {
    reverse_proxy localhost:8008
}

# OpenWebUI
chat.acme.firm {
    reverse_proxy localhost:3000
}

Starten:

cd ~/acme/caddy && docker compose up -d

Caddy holt automatisch HTTPS-Zertifikate für alle Domains. Du kannst nun https://acme.firm im Browser öffnen und solltest die Willkommensnachricht sehen — mit grünem Schloss.

Schritt 5.2: Vaultwarden (Passwort-Manager)#

Was ist Vaultwarden? Vaultwarden ist eine leichtgewichtige, selbstgehostete Version von Bitwarden. Bitwarden ist einer der besten Passwort-Manager — er speichert alle deine Passwörter verschlüsselt und synchronisiert sie zwischen Geräten.

Warum ist das der erste Dienst? Weil du jetzt schon viele Passwörter hast (Server, Cloudflare, Njalla, Oracle, OpenRouter) und sie nicht in einer Textdatei liegen sollten. Vaultwarden wird zum digitalen Tresor von ACME.

Beauftrage Hermes:

Du: Bitte installiere Vaultwarden auf dem Server.

~/acme/vaultwarden/docker-compose.yml:

version: '3.8'
services:
  vaultwarden:
    image: vaultwarden/server:latest
    restart: unless-stopped
    environment:
      DOMAIN: https://vault.acme.firm
      SIGNUPS_ALLOWED: false
      INVITATIONS_ALLOWED: true
      ADMIN_TOKEN: <sicheres-admin-passwort>
    volumes:
      - ./data:/data
    ports:
      - "8001:80"

Schritt 5.3: Vaultwarden einrichten#

  1. Öffne https://vault.acme.firm
  2. Erstelle deinen Account (Master-Account für die Firma)
  3. WICHTIG: SIGNUPS_ALLOWED: false — niemand kann sich selbst registrieren. Nur der Admin kann Einladungen verschicken
  4. Installiere die Bitwarden Browser-Erweiterung auf deinem Laptop
  5. Logge dich mit „Self-hosted" → https://vault.acme.firm ein
  6. Lege Ordner an: „ACME", „ACME/Server", „ACME/Services", „ACME/API-Keys"
  7. Trage alle bisherigen Passwörter ein (Njalla, Cloudflare, Oracle, etc.)

Ergebnis nach Phase 5: ACME hat HTTPS (Caddy) und einen sicheren Passwort-Manager (Vaultwarden). Alle zukünftigen Passwörter landen hier.

PHASE 6 — NFS-Storage: Raspberry Pi einbinden (optional, empfohlen)#

Was wir hier tun#

Der OCI-Server hat 200 GB Boot-Volume. Das reicht für das Betriebssystem und alle Dienste. Aber Nextcloud-Dateien und (optional) Elasticsearch-Logs brauchen mehr Platz. Die Lösung: ein Raspberry Pi mit 2 TB microSD-Karte, der über WireGuard und NFS an den Server angebunden wird.

Warum ein Raspberry Pi? Ein Raspberry Pi 5 kostet ca. 50–80 € (einmalig). Eine 2 TB microSD-Karte ca. 20–30 €. Für insgesamt ~80–110 € hast du 2 TB Speicher, der dauerhaft kostenlos läuft. Vergleich: 2 TB Cloud-Speicher kosten bei Anbietern 10–20 €/Monat — der Raspberry Pi hat sich nach 6–10 Monaten amortisiert.

Alternative: Gemieteter NFS-Service — Wer keine Hardware will, kann bei Hetzner, Scaleway oder OCI selbst einen Block-Volume-Storage mieten (kostet ca. 5–10 €/Monat für 200 GB). Der Guide beschreibt die Raspberry-Pi-Variante, da sie langfristig kostenlos ist.

Schritt 6.1: Raspberry Pi vorbereiten#

  1. Besorge: Raspberry Pi 5 (oder 4), 2 TB microSD-Karte, Netzteil
  2. Flash Ubuntu Server 24.04 LTS (ARM) auf die microSD-Karte (mit dem Raspberry Pi Imager)
  3. MicroSD in den Pi einsetzen, booten
  4. Per HDMI+Tastatur oder per Ethernet im lokalen Netz einloggen
# Auf dem Pi:
sudo apt update && sudo apt upgrade -y
sudo timedatectl set-timezone Europe/Berlin

Schritt 6.2: WireGuard auf dem Raspberry Pi#

Der Pi verbindet sich per WireGuard mit dem OCI-Server — so ist der NFS-Tunnel verschlüsselt.

# Auf dem Pi:
sudo apt install -y wireguard

# Keys generieren
wg genkey | tee privatekey | wg pubkey > publickey

Pi-Konfiguration /etc/wireguard/wg0.conf:

[Interface]
PrivateKey = <pi-private-key>
Address = 10.10.0.3/24

[Peer]
PublicKey = <server-public-key>
Endpoint = <server-ip>:51820
AllowedIPs = 10.10.0.0/24
PersistentKeepalive = 25

Auf dem Server in /etc/wireguard/wg0.conf den Pi als Peer hinzufügen:

# Raspberry Pi (NFS-Storage)
[Peer]
PublicKey = <pi-public-key>
AllowedIPs = 10.10.0.3/32
# Auf dem Pi:
sudo wg-quick up wg0
sudo systemctl enable wg-quick@wg0

Test: ping 10.10.0.1 (Server) sollte funktionieren.

Schritt 6.3: NFS-Server auf dem Pi#

# Auf dem Pi:
sudo apt install -y nfs-kernel-server

# Mountpoint für die 2TB-Karte (falls nicht gemounted, /dev/sdX formatieren)
sudo mkfs.ext4 /dev/sda  # oder entsprechendem Device
sudo mkdir -p /mnt/storage
sudo mount /dev/sda /mnt/storage

# NFS-Export: nur der Server (10.10.0.1) darf zugreifen
echo "/mnt/storage 10.10.0.1/32(rw,sync,no_subtree_check,no_root_squash)" | sudo tee -a /etc/exports
sudo exportfs -ra
sudo systemctl enable nfs-kernel-server

Schritt 6.4: NFS-Mount auf dem OCI-Server#

# Auf dem Server:
sudo apt install -y nfs-common

# Mountpoint
sudo mkdir -p /mnt/nfs-storage

# Mounten
sudo mount 10.10.0.3:/mnt/storage /mnt/nfs-storage

# Persistent machen (fstab)
echo "10.10.0.3:/mnt/storage /mnt/nfs-storage nfs rw,hard,tcp 0 0" | sudo tee -a /etc/fstab

Test:

df -h /mnt/nfs-storage
# sollte ~2 TB zeigen

Schritt 6.5: Nextcloud-Daten auf NFS-Storage#

Nextclouds Daten sollen auf dem NFS-Mount liegen — so hat die Firma 2 TB für Dateien, nicht nur die 200 GB der OCI-Boot-Volume.

Bei der Nextcloud-Installation (Phase 7) wird das Datenverzeichnis auf /mnt/nfs-storage/nextcloud-data gelegt:

# In der Nextcloud docker-compose.yml:
volumes:
  - /mnt/nfs-storage/nextcloud-data:/var/www/html/data

Optional: Elasticsearch-Daten auf NFS — wenn Elasticsearch installiert wird (Phase 10), können auch die Audit-Logs auf dem NFS-Mount liegen:

# In der Elasticsearch docker-compose.yml:
volumes:
  - /mnt/nfs-storage/elasticsearch:/usr/share/elasticsearch/data

Ergebnis nach Phase 6: Der OCI-Server hat jetzt 2 TB zusätzlichen Speicher — sicher über WireGuard getunnelt und als NFS eingebunden. Nextcloud und Elasticsearch haben reichlich Platz.

PHASE 7 — Nextcloud als Teams-Ersatz + TURN-Server#

Was wir hier tun#

Wir installieren Nextcloud — die zentrale Kollaborationsplattform von ACME. Nextcloud ersetzt mehrere kommerzielle Produkte gleichzeitig:

  • Microsoft Teams → Nextcloud Talk (Chat + Videokonferenzen)
  • SharePoint → Nextcloud Files (Dokumentenablage)
  • Microsoft Office → Nextcloud Office (Text, Tabellen, Präsentationen)
  • Outlook → Nextcloud Calendar + Mail
  • OneNote → Nextcloud Collectives (gemeinsame Notizen)

Alles an einem Ort, selbst gehostet, kostenlos.

Schritt 7.1: Nextcloud installieren#

Beauftrage Hermes:

Du: Bitte installiere Nextcloud auf dem Server. Nutze MariaDB als Datenbank. Datenverzeichnis auf dem NFS-Storage (/mnt/nfs-storage).

~/acme/nextcloud/docker-compose.yml:

version: '3.8'
services:
  nextcloud:
    image: nextcloud:latest
    restart: unless-stopped
    ports:
      - "8080:80"
    environment:
      MYSQL_HOST: db
      MYSQL_DATABASE: nextcloud
      MYSQL_USER: nextcloud
      MYSQL_PASSWORD: <sicheres-passwort>
      NEXTCLOUD_TRUSTED_DOMAINS: cloud.acme.firm
      OVERWRITEPROTOCOL: https
      OVERWRITECLIURL: https://cloud.acme.firm
    volumes:
      - ./config:/var/www/html/config
      - /mnt/nfs-storage/nextcloud-data:/var/www/html/data
      - ./html:/var/www/html
    depends_on:
      - db

  db:
    image: mariadb:11
    restart: unless-stopped
    environment:
      MYSQL_ROOT_PASSWORD: <sicheres-passwort>
      MYSQL_DATABASE: nextcloud
      MYSQL_USER: nextcloud
      MYSQL_PASSWORD: <sicheres-passwort>
    volumes:
      - ./db:/var/lib/mysql

Wichtig: Das data-Volume zeigt auf /mnt/nfs-storage/nextcloud-data — also auf den Raspberry Pi. So hat Nextcloud 2 TB Speicher.

Schritt 7.2: Nextcloud-Erstinstallation#

  1. Öffne https://cloud.acme.firm
  2. Erstelle den Admin-Account
  3. Gehe zu „Apps" und installiere:
App Was sie macht
Talk Chat und Videokonferenzen (Teams-Ersatz)
Nextcloud Office Online-Textverarbeitung (Word-Ersatz)
Calendar Kalender (Outlook-Ersatz)
Contacts Kontaktverwaltung
Tasks Aufgabenverwaltung
Deck Kanban-Board (Trello-Ersatz)
Collectives Gemeinsame Notizen (OneNote-Ersatz)
Group folders Geteilte Ordner für Teams

Schritt 7.3: TURN-Server für Nextcloud Talk#

Warum ein TURN-Server? Videokonferenzen über Nextcloud Talk funktionieren nicht immer direkt — oft sitzen Teilnehmer hinter Routern (NAT), die direkte Verbindungen blockieren. Ein TURN-Server ist ein „Vermittler", der den Datenstrom für beide Seiten weiterleitet. Ohne TURN-Server funktioniert Video-Chat nur im lokalen Netzwerk oder bei direkten Verbindungen — mit TURN-Server immer.

Wir nutzen coturn als TURN-Server (Open Source, kostenlos):

~/acme/turn/docker-compose.yml:

version: '3.8'
services:
  coturn:
    image: coturn/coturn:latest
    restart: unless-stopped
    network_mode: host
    volumes:
      - ./turnserver.conf:/etc/turnserver.conf
    command: ["-c", "/etc/turnserver.conf"]

~/acme/turn/turnserver.conf:

# coturn-Konfiguration für ACME
listening-port=3478
tls-listening-port=5349
external-ip=<server-public-ip>
realm=turn.acme.firm
server-name=turn.acme.firm
# Authentifizierung
user=acme:<sicheres-turn-passwort>
lt-cred-mech
fingerprint
# Logging
log-file=/var/log/turnserver.log
simple-log
# Sicherheit
no-multicast-peers
no-cli
no-tlsv1
no-tlsv1_1

In Nextcloud Talk-Einstellungen eintragen: - TURN-Server: turn:turn.acme.firm:3478 - Benutzer: acme - Passwort: <sicheres-turn-passwort>

Schritt 7.4: Projektordner-Struktur#

Lege in Nextcloud Group Folders an:

📁 ACME/
  ├── 📁 01_Verträge/
  ├── 📁 02_Finanzen/
  ├── 📁 03_Projekte/
  │     ├── 📁 Projekt-Alpha/
  │     │     ├── 📁 Dokumente/
  │     │     ├── 📁 Korrespondenz/
  │     │     └── 📁 Berichte/
  │     └── 📁 Projekt-Beta/
  ├── 📁 04_Vorlagen/
  ├── 📁 05_Wissensbasis/    ← Knowledge Base (siehe Phase 11)
  └── 📁 06_Hermes/          ← Hermes-Arbeitsordner
        ├── 📁 Eingang/       ← Neue Aufgaben für Hermes
        ├── 📁 Ausgang/       ← Fertige Ergebnisse
        ├── 📁 Berichte/      ← Hermes-Berichte
        └── 📁 Archiv/

Der Ordner 06_Hermes ist besonders wichtig: Hier lädt Hermes Ergebnisse ab und holt sich neue Aufgaben. Du kannst jederzeit nachschauen, was die KI-Assistentin erledigt hat.

Ergebnis nach Phase 7: ACME hat eine vollständige Kollaborationsplattform — Chat, Video, Dokumente, Office, Kalender, Aufgaben. Kostenlos, mit 2 TB Speicher auf dem Raspberry Pi.

PHASE 8 — Hermes Agent auf OCI installieren + Profile migrieren#

Was wir hier tun#

Bisher lief Hermes nur lokal auf deinem Laptop. Jetzt installieren wir Hermes auch auf dem OCI-Server — als „Produktionsinstanz", die 24/7 verfügbar ist. Gleichzeitig legen wir zusätzliche Profile an und migrieren das IT-Profil vom Laptop auf den Server.

Schritt 8.1: Hermes auf dem OCI-Server#

Beauftrage Hermes (das IT-Profil auf deinem Laptop):

Du: Bitte installiere Hermes Agent auf dem ACME-Server. Nutze dieselbe OpenRouter-Konfiguration.

Hermes führt aus (via SSH auf dem Server):

# Hermes herunterladen und installieren
curl -fsSL https://hermes-agent.nousresearch.com/install.sh | bash

# Konfigurationsverzeichnis
mkdir -p ~/.hermes

Konfiguration auf dem Server:

# ~/.hermes/config.yaml (auf dem Server)
llm:
  provider: openrouter
  model: z-ai/glm-5.2
  api_key: ${OPENROUTER_API_KEY}

gateway:
  enabled: true
  port: 8642

workspace:
  enabled: true
  port: 9119
  password_hash: <hash>
# .env auf dem Server
echo 'OPENROUTER_API_KEY=sk-or-v1-...' > ~/.hermes/.env

Schritt 8.2: Hermes als Dienst einrichten#

sudo tee /etc/systemd/system/hermes.service << 'EOF'
[Unit]
Description=Hermes Agent
After=network.target docker.service

[Service]
Type=simple
User=hermes
WorkingDirectory=/home/hermes
ExecStart=/home/hermes/.hermes/bin/hermes serve
Restart=always
RestartSec=10

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl daemon-reload
sudo systemctl enable hermes
sudo systemctl start hermes

Schritt 8.3: Profile anlegen#

Auf dem Server legen wir jetzt die Produktions-Profile an:

Profil Zweck Beschreibung
IT IT-Administrator Wird vom Laptop migriert — der „Techniker"
Büro Büro-Assistenz Allgemeine Aufgaben, Termine, E-Mails
Projekt-A Projekt-Verwaltung Kanban, Berichte, Projektkommunikation
Buchhaltung Finanzen Rechnungen, Kosten-Tracking, Berichte 
# Auf dem Server:
hermes profile create IT
hermes profile create Büro
hermes profile create Projekt-A
hermes profile create Buchhaltung

Jedes Profil hat: - Eigene config.yaml mit eigenem System-Prompt - Eigene Skills - Eigene Memories - Eigenen Chat-Verlauf

Schritt 8.4: IT-Profil vom Laptop migrieren#

Das IT-Profil auf dem Laptop war für den Aufbau zuständig. Jetzt, wo alles steht, migrieren wir es auf den Server — damit Hermes auch von überall erreichbar ist.

# Auf dem Laptop: IT-Profil exportieren
hermes profile export IT > it-profile-backup.tar.gz

# Auf den Server kopieren
scp it-profile-backup.tar.gz hermes@<server-ip>:~/

# Auf dem Server: importieren
hermes profile import IT < it-profile-backup.tar.gz

Ab jetzt läuft das IT-Profil auf dem Server. Du kannst mit ihm über https://hermes.acme.firm (Workspace) sprechen — oder über Telegram, Matrix, OpenWebUI (siehe Phase 10).

Schritt 8.5: Hermes mit Nextcloud verbinden#

Hermes soll Dateien in Nextcloud lesen und schreiben können.

  1. In Nextcloud: WebDAV-Passwort erstellen (Einstellungen → Sicherheit)
  2. In Hermes config auf dem Server:
tools:
  webdav:
    url: https://cloud.acme.firm/remote.php/dav
    username: hermes-bot
    password: <nextcloud-app-password>

Hermes kann nun: - Dateien im Ordner 06_Hermes/Eingang/ lesen (neue Aufgaben) - Ergebnisse in 06_Hermes/Ausgang/ schreiben - Berichte in 06_Hermes/Berichte/ ablegen

Schritt 8.6: Telegram-Anbindung#

Damit du Hermes auch vom Handy aus erreichst, richten wir Telegram ein:

  1. Bei Telegram: Sprich mit @BotFather → neuen Bot erstellen
  2. Notiere dir den Bot-Token
  3. In Hermes config:
telegram:
  bot_token: <telegram-bot-token>
  allowed_users:
    - <deine-telegram-user-id>
sudo systemctl restart hermes

Ab jetzt kannst du Hermes per Telegram beauftragen — von überall.

Ergebnis nach Phase 8: Hermes läuft 24/7 auf dem Server, ist über Workspace, Telegram erreichbar, und mit Nextcloud verbunden. Vier Profile stehen bereit: IT, Büro, Projekt-A, Buchhaltung.

PHASE 9 — Monitoring: Prometheus, Grafana Cloud, Dashboards#

Was wir hier tun#

Wir bauen das Monitoring-System auf. Das ist die „Zentrale Steuerkonsole" von ACME — auf einen Blick siehst du: Läuft alles? Was kostet die KI? Gibt es Probleme?

Schritt 9.1: Grafana Cloud einrichten#

Warum Grafana Cloud und nicht nur lokal? Grafana Cloud ist die gehostete Version von Grafana. Der Free Tier (10.000 Metriken, 14 Tage Retention) reicht für ACME völlig. Vorteil: Keine Wartung, verfügbar von überall, keine Performance-Belastung auf dem OCI-Server.

  1. Gehe zu grafana.cloud → „Create free account"
  2. Erstelle einen Stack: „ACME"
  3. Notiere dir:
  4. Grafana URL (z. B. https://acme.grafana.net)
  5. Prometheus Remote Write URL
  6. API Key / Token

Schritt 9.2: Prometheus installieren#

Was ist Prometheus? Prometheus ist wie ein Buchhalter für Zahlen. Es fragt regelmäßig alle Dienste ab: „Wie viel CPU benutzt du? Wie viele Anfragen hast du bekommen? Wie viele Token hat Hermes verbraucht?" und speichert diese Zahlen in einer Zeitreihe.

Beauftrage Hermes:

Du: Bitte installiere Prometheus auf dem Server. Konfiguriere Remote Write an Grafana Cloud.

~/acme/monitoring/docker-compose.yml:

version: '3.8'
services:
  prometheus:
    image: prom/prometheus:latest
    restart: unless-stopped
    ports:
      - "9090:9090"
    volumes:
      - ./prometheus/prometheus.yml:/etc/prometheus/prometheus.yml
      - ./prometheus/data:/prometheus

~/acme/monitoring/prometheus/prometheus.yml:

global:
  scrape_interval: 15s

scrape_configs:
  # Hermes Metriken
  - job_name: 'hermes'
    static_configs:
      - targets: ['localhost:9102']

  # Server-Metriken (node_exporter)
  - job_name: 'node'
    static_configs:
      - targets: ['localhost:9100']

  # Docker-Metriken
  - job_name: 'docker'
    static_configs:
      - targets: ['localhost:9323']

# Remote Write an Grafana Cloud
remote_write:
  - url: https://<grafana-cloud-prometheus-url>
    basic_auth:
      username: <grafana-cloud-user>
      password: <grafana-cloud-key>

Schritt 9.3: Prometheus Exporter für Hermes#

Der Exporter liefert Hermes-spezifische Metriken:

Metrik Was sie bedeutet
hermes_messages_total Anzahl der verarbeiteten Nachrichten
hermes_tokens_input_total Verbrauchte Eingabe-Token (Summe)
hermes_tokens_output_total Verbrauchte Ausgabe-Token (Summe)
hermes_tokens_cost_total Kumulierte Kosten in USD
hermes_tool_calls_total Anzahl der Tool-Aufrufe
hermes_active_sessions Aktive Sessions
hermes_response_time_seconds Antwortzeit (Histogramm)
hermes_errors_total Fehler beim Verarbeiten 
cd ~/acme/monitoring/exporter
pip install prometheus-client
python hermes_exporter.py --port 9102

Als Dienst:

sudo tee /etc/systemd/system/hermes-exporter.service << 'EOF'
[Unit]
Description=Hermes Prometheus Exporter
After=network.target

[Service]
Type=simple
User=hermes
WorkingDirectory=/home/hermes/acme/monitoring/exporter
ExecStart=/usr/bin/python3 hermes_exporter.py --port 9102
Restart=always

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable hermes-exporter
sudo systemctl start hermes-exporter

Schritt 9.4: Node Exporter (Server-Metriken)#

Für allgemeine Server-Metriken (CPU, RAM, Disk):

wget https://github.com/prometheus/node_exporter/releases/download/v1.8.1/node_exporter-1.8.1.linux-arm64.tar.gz
tar xzf node_exporter-*.tar.gz
sudo cp node_exporter-*/node_exporter /usr/local/bin/

sudo tee /etc/systemd/system/node-exporter.service << 'EOF'
[Unit]
Description=Node Exporter
After=network.target

[Service]
Type=simple
ExecStart=/usr/local/bin/node_exporter
Restart=always

[Install]
WantedBy=multi-user.target
EOF

sudo systemctl enable node-exporter
sudo systemctl start node-exporter

Schritt 9.5: Dashboards in Grafana Cloud#

Dashboard „Hermes Kostenkontrolle"#

Das wichtigste Dashboard. Es zeigt:

Panel Metrik Bedeutung
Kosten heute sum(hermes_tokens_cost_total) Was hat Hermes heute gekostet?
Kosten diese Woche sum_over_time(hermes_tokens_cost_total[7d]) Wochenübersicht
Token-Verbrauch rate(hermes_tokens_input_total[5m]) Wie viele Token pro Minute?
Nachrichten gesamt sum(hermes_messages_total) Wie viel hat Hermes gearbeitet?
Kosten pro Profil sum by(profile)(hermes_tokens_cost_total) Welches Profil kostet wie viel?
Kosten pro Modell sum by(model)(hermes_tokens_cost_total) Welches Modell ist am teuersten?
Tool-Aufrufe sum by(tool)(hermes_tool_calls_total) Welche Werkzeuge nutzt Hermes?
Antwortzeit histogram_quantile(0.95, hermes_response_time_seconds_bucket) Wie schnell antwortet Hermes?

Alert-Regeln:

Alert Bedingung Aktion
Kosten-Schranke überschritten cost_today > 10 Telegram-Nachricht
Token-Spike rate(tokens[5m]) > 100000 Warnung (möglicher Loop)
Hermes nicht erreichbar up{job="hermes"} == 0 Kritische Warnung
Fehlerrate hoch rate(errors[5m]) / rate(messages[5m]) > 0.1 Warnung

Dashboard „System-Gesundheit"#

Panel Metrik
Server-CPU 100 - avg(rate(node_cpu_seconds_total{mode="idle"}[5m])) * 100
Server-RAM node_memory_MemAvailable_bytes / node_memory_MemTotal_bytes
Disk-Usage node_filesystem_avail_bytes / node_filesystem_size_bytes
Docker-Container count(container_last_seen)
Uptime time() - node_boot_time_seconds

Alert-Regeln:

Alert Bedingung
Disk fast voll disk_usage > 85%
CPU dauerhaft hoch cpu > 80% for 10m
RAM knapp ram_available < 1GB

Ergebnis nach Phase 9: ACME hat ein vollständiges Monitoring. Du siehst auf einen Blick, was Hermes getan hat, was es kostet, und ob alles gesund ist.

PHASE 10 — [Optional] Elasticsearch, Zitadel, OpenWebUI, Matrix#

Was wir hier tun#

Alle Bausteine in dieser Phase sind optional. Sie bringen Mehrwert, sind aber für den Start nicht zwingend. Du kannst ACME ohne diese Phase vollständig betreiben.

Baustein Mehrwert Aufwand
Elasticsearch + Kibana Detaillierte Audit-Logs durchsuchbar 2 Std.
Filebeat Log-Sammler für Elasticsearch 0,5 Std.
Zitadel Zentrales Login (Single Sign-On) 1 Std.
OpenWebUI + MCPO Browser-basierte Hermes-Steuerung 1 Std.
Matrix / Element Sicherer Messenger-Kanal zu Hermes 1 Std.
Grafana OSS Alternative zu Grafana Cloud (lokal) 0,5 Std.

10.1: Elasticsearch + Kibana (Audit-Logs)#

Was ist Elasticsearch? Eine Suchmaschine, die auf das Durchsuchen von Texten optimiert ist. Bei ACME speichert sie alle Audit-Logs: Jedes Ereignis (Login, Hermes-Aktion, Systemereignis) wird als Eintrag gespeichert und ist danach sofort durchsuchbar.

Was ist Kibana? Die Benutzeroberfläche für Elasticsearch. Statt rohe JSON-Einträge zu lesen, sieht man in Kibana eine übersichtliche Darstellung: Filter, Diagramme, Tabellen. Man kann fragen: „Zeige mir alles, was Hermes gestern zwischen 14 und 16 Uhr getan hat" und bekommt sofort die Antwort.

~/acme/audit/docker-compose.yml:

version: '3.8'
services:
  elasticsearch:
    image: docker.elastic.co/elasticsearch/elasticsearch:8.13.0
    environment:
      - discovery.type=single-node
      - xpack.security.enabled=true
      - ELASTIC_PASSWORD=<sicheres-passwort>
      - ES_JAVA_OPTS=-Xms1g -Xmx1g
    volumes:
      - /mnt/nfs-storage/elasticsearch:/usr/share/elasticsearch/data
    ports:
      - "9200:9200"
    restart: unless-stopped

  kibana:
    image: docker.elastic.co/kibana/kibana:8.13.0
    environment:
      - ELASTICSEARCH_HOSTS=http://elasticsearch:9200
      - ELASTICSEARCH_USERNAME=kibana_system
      - ELASTICSEARCH_PASSWORD=<sicheres-passwort>
    ports:
      - "5601:5601"
    depends_on:
      - elasticsearch
    restart: unless-stopped

Wichtig: Das Elasticsearch-Datenverzeichnis zeigt auf /mnt/nfs-storage/elasticsearch — also auf den Raspberry Pi. So haben die Audit-Logs reichlich Platz und belasten nicht die OCI-Boot-Volume.

Filebeat (Log-Sammler)#

Was ist Filebeat? Ein kleines Programm, das auf dem Server läuft, Log-Dateien überwacht und neue Einträge an Elasticsearch weiterleitet.

~/acme/audit/filebeat/filebeat.yml:

filebeat.inputs:
  # Hermes-Aktivitätslogs
  - type: filestream
    id: hermes-activity
    paths:
      - /home/hermes/.hermes/logs/*.log
    fields:
      source: hermes
      type: activity

  # System-Logs
  - type: filestream
    id: system-auth
    paths:
      - /var/log/auth.log
    fields:
      source: system
      type: auth

  # Docker-Logs
  - type: container
    paths:
      - /var/lib/docker/containers/*/*.log
    fields:
      source: docker

output.elasticsearch:
  hosts: ["localhost:9200"]
  username: "elastic"
  password: "<sicheres-passwort>"
  indices:
    - index: "acme-audit-%{[fields.source]}-%{+yyyy.MM.dd}"

Audit-Log-Format#

Hermes schreibt bei jeder Aktion einen Log-Eintrag:

{
  "@timestamp": "2026-07-21T14:32:01Z",
  "source": "hermes",
  "type": "action",
  "profile": "IT",
  "user": "gino",
  "action": "file_write",
  "tool": "write_file",
  "description": "Rechnung R-2026-042 erstellt",
  "file_path": "/ACME/02_Finanzen/Rechnungen/R-2026-042.md",
  "tokens_input": 1240,
  "tokens_output": 890,
  "cost_usd": 0.0041,
  "model": "z-ai/glm-5.2"
}

In Kibana kannst du filtern: - „Zeige mir alle Aktionen, bei denen Hermes Dateien geschrieben hat" - „Zeige mir alle Aktionen des IT-Profils der letzten Woche" - „Zeige mir die teuersten Aktionen des Monats"

10.2: Zitadel (Identity Provider)#

Was ist Zitadel? Zitadel ist eine Open-Source-Plattform für Identitätsverwaltung (IAM — Identity & Access Management). Das ist der „Türsteher" der Firma: Du bekommst dort ein Login, und alle Dienste (Nextcloud, Hermes, Grafana) vertrauen diesem Login.

Das bedeutet: Ein Passwort für alles. Kein separates Login für Nextcloud, Hermes, Grafana — sondern ein zentrales.

Hinweis: Für eine Ein-Personen-Firma ist Zitadel optional. Wenn später weitere Mitarbeiter dazukommen, wird es wertvoll.

~/acme/zitadel/docker-compose.yml:

version: '3.8'
services:
  zitadel:
    image: ghcr.io/zitadel/zitadel:latest
    environment:
      ZITADEL_DATABASE_POSTGRES_HOST: db
      ZITADEL_DATABASE_POSTGRES_PORT: 5432
      ZITADEL_DATABASE_POSTGRES_DATABASE: zitadel
      ZITADEL_DATABASE_POSTGRES_USER: zitadel
      ZITADEL_DATABASE_POSTGRES_PASSWORD: <sicheres-passwort>
      ZITADEL_EXTERNALSECURE: true
      ZITADEL_EXTERNALDOMAIN: login.acme.firm
      ZITADEL_EXTERNALPORT: 443
    depends_on:
      - db
    restart: unless-stopped

  db:
    image: postgres:16
    environment:
      POSTGRES_USER: zitadel
      POSTGRES_PASSWORD: <sicheres-passwort>
      POSTGRES_DB: zitadel
    volumes:
      - ./data:/var/lib/postgresql/data
    restart: unless-stopped

Konfiguration: 1. Öffne https://login.acme.firm 2. Erstelle Organisation: „ACME" 3. Erstelle Benutzer 4. Erstelle OIDC-Clients für Nextcloud, Hermes Workspace, Grafana

10.3: OpenWebUI + MCPO (Browser-Firmensteuerung)#

Was ist OpenWebUI? OpenWebUI ist eine Chat-Oberfläche, die im Browser läuft — ähnlich wie die ChatGPT-Webseite. Aber statt mit einem fremden Dienst zu reden, verbindest du OpenWebUI mit Hermes.

Was ist MCPO? MCPO (Model Context Protocol to OpenAPI) ist ein Gateway, das Hermes' Tools als API-Endpunkte bereitstellt. Das bedeutet: Du kannst in OpenWebUI nicht nur chatten, sondern Hermes dort direkt Tools aufrufen lassen — Dateien bearbeiten, Befehle ausführen, WebDAV durchsuchen. Die Browser-Oberfläche wird so zur vollwertigen Firmensteuerung.

~/acme/openwebui/docker-compose.yml:

version: '3.8'
services:
  openwebui:
    image: ghcr.io/open-webui/open-webui:main
    restart: unless-stopped
    ports:
      - "3000:8080"
    environment:
      - OLLAMA_BASE_URL=http://mcpo:8080
      - OPENAI_API_BASE_URL=http://mcpo:8080/v1
      - OPENAI_API_KEY=mcpo-local-key
    volumes:
      - ./data:/app/backend/data

  mcpo:
    image: ghcr.io/nousresearch/mcpo:latest
    restart: unless-stopped
    environment:
      - HERMES_GATEWAY_URL=http://localhost:8642
      - HERMES_API_KEY=<hermes-api-key>
    ports:
      - "8090:8080"

Öffne https://chat.acme.firm und du hast eine ChatGPT-ähnliche Oberfläche, die direkt mit Hermes verbunden ist — inklusive Tool-Aufrufen.

10.4: Matrix / Element (sicherer Messenger-Kanal)#

Was ist Matrix? Matrix ist ein offener, dezentraler Messenger-Standard. Element ist die bekannteste App für Matrix (es gibt sie für Browser, Desktop, iOS, Android).

Warum Matrix, wenn es Nextcloud Talk gibt? Nextcloud Talk ist praktisch, aber an Nextcloud gebunden. Matrix ist ein eigenständiger Messenger, der von mehreren Geräten aus genutzt werden kann — parallel zu Nextcloud Talk. Jedes Hermes-Profil kann einen eigenen Matrix-Raum haben: Du schreibst im Raum „IT" mit dem IT-Profil, im Raum „Buchhaltung" mit dem Buchhaltungs-Profil.

~/acme/matrix/docker-compose.yml:

version: '3.8'
services:
  synapse:
    image: matrixdotorg/synapse:latest
    restart: unless-stopped
    ports:
      - "8008:8008"
    volumes:
      - ./data:/data
    environment:
      - SYNAPSE_SERVER_NAME=matrix.acme.firm
      - SYNAPSE_REPORT_STATS=no

In Hermes config:

matrix:
  homeserver: https://matrix.acme.firm
  user_id: "@hermes-it:matrix.acme.firm"
  password: <matrix-password>
  allowed_users:
    - "@gino:matrix.acme.firm"

10.5: Grafana OSS (lokale Alternative zu Grafana Cloud)#

Warum lokal? Grafana Cloud ist kostenlos, aber die Daten liegen bei einem Dritten. Grafana OSS läuft auf deinem Server — du hast volle Kontrolle.

# ~/acme/monitoring/docker-compose.yml (erweitern)
  grafana-oss:
    image: grafana/grafana:latest
    restart: unless-stopped
    ports:
      - "3001:3000"
    environment:
      GF_SECURITY_ADMIN_PASSWORD: <sicheres-passwort>
      GF_SERVER_ROOT_URL: https://grafana.acme.firm
    volumes:
      - ./grafana/data:/var/lib/grafana

Ergebnis nach Phase 10: Alle optionalen Bausteine sind installiert. ACME hat jetzt detaillierte Audit-Logs, zentrales Login, Browser- Steuerung, sicheren Messenger — alles optional, alles zuschaltbar.

PHASE 11 — Knowledge Base & Skills aufbauen#

Was wir hier tun#

Wir geben Hermes das „Wissen" der Firma. Das besteht aus zwei Teilen:

  1. Knowledge Base — eine strukturierte Wissensbasis in Nextcloud, die Hermes durchsuchen kann (Firmenhandbuch, Prozesse, Kunden, Verträge, FAQ)
  2. Skills — Fähigkeiten, die Hermes beibringen, wie bestimmte Aufgaben erledigt werden (Rechnungen erstellen, Berichte schreiben, Server überwachen)

Stell dir vor, du stellst einen neuen Mitarbeiter ein. Am ersten Tag braucht er ein Handbuch (Knowledge Base) und eine Einarbeitung in die Werkzeuge (Skills). Genau das machen wir hier mit Hermes.

Schritt 11.1: Knowledge Base in Nextcloud#

Die Knowledge Base ist ein strukturierter Ordnerbaum in Nextcloud unter 05_Wissensbasis/:

📁 05_Wissensbasis/
  ├── 📄 FIRMA.md              ← Wer ist ACME? Mission, Werte
  ├── 📄 ORGANISATION.md       ← Aufbau, Verantwortliche
  ├── 📄 PROZESSE.md           ← Wie arbeiten wir? Standardabläufe
  ├── 📄 WERKZEUGE.md          ← Welche Tools nutzen wir? Anleitungen
  ├── 📄 KUNDEN.md              ← Kundenstamm, Ansprechpartner
  ├── 📄 VERTRAEGE.md          ← Verträge, Konditionen
  ├── 📄 FAQ.md                 ← Häufige Fragen (intern)
  ├── 📁 Projekte/
  │     ├── 📄 Alpha.md         ← Projekt-Alpha: Status, Ziele
  │     └── 📄 Beta.md
  ├── 📁 Vorlagen/
  │     ├── 📄 Rechnung-Vorlage.md
  │     ├── 📄 Angebot-Vorlage.md
  │     └── 📄 Bericht-Vorlage.md
  └── 📁 Anleitungen/
        ├── 📄 Server-Wartung.md
        ├── 📄 Backup-Wiederherstellung.md
        └── 📄 Notfall-Plan.md

Jede Markdown-Datei ist eine „Wikiseite". Hermes kann diese Dateien lesen und durchsuchen — wenn jemand fragt „Wie stellen wir eine Rechnung aus?", sucht Hermes in der Knowledge Base und gibt die Antwort basierend auf PROZESSE.md und Vorlagen/Rechnung-Vorlage.md.

Schritt 11.2: Hermes mit der Knowledge Base verbinden#

Hermes muss die Knowledge Base durchsuchen können. Dafür konfigurieren wir einen WebDAV-Zugriff:

# ~/.hermes/config.yaml erweitern
tools:
  webdav:
    url: https://cloud.acme.firm/remote.php/dav
    username: hermes-bot
    password: <nextcloud-app-password>
  knowledge_base:
    path: /ACME/05_Wissensbasis/
    index_interval: 3600  # stündlich neu indizieren

Schritt 11.3: Skills für jedes Profil#

Jedes Profil bekommt Skills, die zu seinem Aufgabenbereich passen:

IT-Profil#

Skill Was er macht
acme-server-setup Richtet einen neuen Server ein
acme-service-deploy Stellt einen Docker-Dienst bereit
acme-server-health Prüft die Gesundheit aller Dienste
acme-backup-check Prüft, ob Backups aktuell sind
acme-update-check Prüft, ob Watchtower Updates durchführt

Büro-Profil#

Skill Was er macht
acme-invoicing Erstellt eine Rechnung aus Vorlagen
acme-project-report Erstellt wöchentlichen Projektbericht
acme-meeting-notes Fasst Besprechungs-Notizen zusammen
acme-email-draft Erstellt E-Mail-Entwürfe

Projekt-A-Profil#

Skill Was er macht
acme-kanban-update Aktualisiert das Kanban-Board
acme-status-report Erstellt Statusbericht für Projekt Alpha
acme-milestone-check Prüft, ob Meilensteine erreicht wurden

Buchhaltung-Profil#

Skill Was er macht
acme-cost-report Monatlicher Kostenbericht
acme-invoice-track Verfolgt Rechnungsstatus
acme-budget-check Prüft Budget gegen Ist-Kosten

Beispiel-Skill: acme-invoicing#

---
name: acme-invoicing
description: Erstellt eine Rechnung aus den ACME-Vorlagen
---

# Rechnung erstellen

1. Lese die Vorlage aus Nextcloud: `05_Wissensbasis/Vorlagen/Rechnung-Vorlage.md`
2. Frage den Nutzer nach:
   - Kundenname
   - Leistungszeitraum
   - Betrag
   - Beschreibung
3. Fülle die Vorlage aus
4. Speichere unter: `03_Projekte/<Projekt>/Rechnungen/R-<YYYY>-<NN>.md`
5. Sende eine Kopie an `02_Finanzen/Rechnungen/`
6. Benachrichtige den Nutzer über Telegram

Beispiel-Skill: acme-server-health#

---
name: acme-server-health
description: Prüft die Gesundheit aller ACME-Server und Dienste
---

# Server-Health-Check

1. Prüfe Docker-Container: `docker ps --format "table {{.Names}}\t{{.Status}}"`
2. Prüfe Festplatten: `df -h`
3. Prüfe Prometheus-Metriken für anomale Werte
4. [Optional] Prüfe Elasticsearch für Fehler-Logs der letzten Stunde
5. Erstelle Bericht
6. Wenn Probleme gefunden wurden → Telegram-Alert an Inhaber
7. Speichere Bericht unter `06_Hermes/Berichte/health-<date>.md`

Schritt 11.4: Skills installieren#

# Skills in die jeweiligen Profile kopieren
# IT-Profil
cp acme-server-setup.md ~/.hermes/profiles/IT/skills/
cp acme-service-deploy.md ~/.hermes/profiles/IT/skills/
cp acme-server-health.md ~/.hermes/profiles/IT/skills/

# Büro-Profil
cp acme-invoicing.md ~/.hermes/profiles/Büro/skills/
cp acme-project-report.md ~/.hermes/profiles/Büro/skills/
cp acme-meeting-notes.md ~/.hermes/profiles/Büro/skills/

# Projekt-A-Profil
cp acme-kanban-update.md ~/.hermes/profiles/Projekt-A/skills/
cp acme-status-report.md ~/.hermes/profiles/Projekt-A/skills/

# Buchhaltung-Profil
cp acme-cost-report.md ~/.hermes/profiles/Buchhaltung/skills/
cp acme-invoice-track.md ~/.hermes/profiles/Buchhaltung/skills/

Schritt 11.5: Audit-Logs für Hermes-Aktionen#

Damit du sehen kannst, was Hermes auf der OCI getan hat, richten wir ein spezielles Audit-Log ein (sofern Elasticsearch aus Phase 10 installiert ist).

Hermes schreibt bei jeder Aktion einen Log-Eintrag (siehe Format in Phase 10.1). Die Einträge fließen über Filebeat in Elasticsearch. In Kibana siehst du dann:

  • Wer hat Hermes beauftragt? (user)
  • Was hat Hermes getan? (action, tool, description)
  • Wann passierte es? (@timestamp)
  • Welches Profil wurde genutzt? (profile)
  • Was kostete die Aktion? (tokens_input, tokens_output, cost_usd)
  • Welches Modell wurde genutzt? (model)

Ergebnis nach Phase 11: Hermes hat das Firmenwissen (Knowledge Base) und die Fähigkeiten (Skills). Du kannst jederzeit transparent nachvollziehen, was Hermes getan hat.

PHASE 12 — Inbetriebnahme, Tests, Dokumentation#

Was wir hier tun#

Wir nehmen alles in Betrieb, testen es, und dokumentieren das Ergebnis.

Schritt 12.1: End-to-End-Test#

Szenario 1: Kostentransparenz 1. Sende Hermes eine Aufgabe per Telegram („Erstelle eine Zusammenfassung des letzten Projektberichts") 2. Hermes erledigt die Aufgabe, schreibt Ergebnis nach Nextcloud 3. [Optional] Prüfe in Kibana: Audit-Eintrag vorhanden? 4. Prüfe in Grafana: Kosten-Panel aktualisiert? 5. Prüfe in Nextcloud: Datei im Ausgangs-Ordner?

Szenario 2: IT-Administration 1. Frage das IT-Profil: „Mach einen Health-Check" 2. Hermes prüft alle Dienste, erstellt Bericht 3. Prüfe: Bericht in Nextcloud? Telegram-Benachrichtigung?

Szenario 3: Buchhaltung 1. Frage das Buchhaltung-Profil: „Erstelle den monatlichen Kostenbericht" 2. Hermes liest Prometheus-Metriken, erstellt Bericht 3. Prüfe: Bericht in 02_Finanzen/Kostenberichte/?

Schritt 12.2: Backup-Strategie#

Was Wie Wie oft
Nextcloud-Dateien Liegen auf NFS (Raspberry Pi) Pi separat sichern
Vaultwarden-Datenbank OCI-Volume-Snapshot Täglich
[Optional] Elasticsearch Snapshot-API Täglich
Hermes-Konfiguration Git-Repo (private) Bei Änderung
Raspberry Pi (NFS-Storage) rsync auf externe HDD Wöchentlich

Oracle Free Tier bietet kostenlose Volume-Snapshots an.

Schritt 12.3: Cron-Jobs für Hermes#

Hermes soll einige Aufgaben automatisch erledigen:

Cron Aufgabe Profil
Täglich 8:00 Health-Check aller Dienste IT
Täglich 18:00 Tageskostenbericht per Telegram Buchhaltung
Montags 9:00 Wöchentlicher Projektbericht Büro
Monatsende Monatlicher Kostenbericht Buchhaltung

Einrichtung über Hermes CLI:

hermes cron create \
  --schedule "0 8 * * *" \
  --skill acme-server-health \
  --profile IT \
  --deliver telegram

Schritt 12.4: Benutzerhandbuch#

Erstelle ein kurzes Handbuch (für dich selbst und spätere Mitarbeiter):

# ACME — Kurzanleitung

## So nutzt du Hermes
- Per Telegram: Schreibe an den ACME-Bot
- Per Browser: https://hermes.acme.firm
- [Optional] Per OpenWebUI: https://chat.acme.firm
- [Optional] Per Matrix: Im entsprechenden Raum

## So findest du Dateien
1. Gehe zu https://cloud.acme.firm
2. Navigiere zu deinem Projekt-Ordner

## Bei Problemen
- Schreibe an das IT-Profil: "Hilfe, ich kann nicht auf Nextcloud"
- Hermes prüft das Problem und hilft

Schritt 12.5: Notfall-Plan#

Erstelle eine Notfall-Plan.md in der Knowledge Base:

  • Server komplett offline? → OCI-Instanz neu starten (Dashboard)
  • Hermes nicht erreichbar? → sudo systemctl restart hermes
  • [Optional] Audit-Logs verloren? → Elasticsearch-Snapshot wiederherstellen
  • Passwort vergessen? → Vaultwarden Admin-Token zurücksetzen
  • Domain abgelaufen? → Njalla-Verlängerung prüfen
  • Raspberry Pi offline? → NFS-Mount prüfen, Pi neu starten

Ergebnis nach Phase 12: ACME ist vollständig in Betrieb. Alles ist getestet, dokumentiert. Du hast volle Transparenz über Kosten und Hermes-Aktivitäten.

ANHANG#

A. Glossar (für Nicht-ITler)#

Begriff Bedeutung
ARM Ein Prozessortyp, der in Smartphones und mittlerweile auch Cloud-Servern verbaut ist. Sparsam und leistungsstark.
Audit-Log Ein Protokoll, das alle Aktionen aufzeichnet — wie ein Tagebuch des Systems.
Beats Kleine Programme (wie Filebeat), die Logs sammeln und weiterleiten.
Container Eine isolierte Software-Umgebung. Wie eine Schachtel, in der ein Programm zusammen mit allem, was es braucht, verpackt ist.
Dashboard Eine visuelle Übersichtsseite mit Diagrammen und Kennzahlen.
DNS Das Telefonbuch des Internets — übersetzt Domain-Namen (acme.firm) in IP-Adressen.
Docker Eine Software, die Container verwaltet.
Domain Eine Internet-Adresse (z. B. acme.firm).
Elasticsearch Eine Suchmaschine, die für die Suche in Texten optimiert ist.
Firewall Ein Schutzsystem, das unerwünschten Netzwerkverkehr blockt.
HTTPS Verschlüsselte Verbindung zwischen Browser und Server — erkennbar am Schloss-Symbol.
IAM Identity & Access Management — Verwaltung von Benutzern und Berechtigungen.
Kibana Die Benutzeroberfläche für Elasticsearch.
LLM Large Language Model — das „Gehirn" der KI (z. B. Claude, GPT, GLM).
LM Studio Eine App, um LLM-Modelle lokal auf dem Mac laufen zu lassen.
Lokales LLM Ein KI-Modell, das auf dem eigenen Gerät (z. B. Mac) läuft — keine Cloud, keine Kosten, volle Datenhoheit.
MCPO Model Context Protocol to OpenAPI — ein Gateway, das Hermes-Tools für Browser-Oberflächen zugänglich macht.
Metrik Eine messbare Zahl (CPU-Auslastung, Token-Verbrauch, etc.).
Matrix Ein offener Messenger-Standard. Element ist die bekannteste App dafür.
NFS Network File System — ein Protokoll, um Festplatten übers Netzwerk einzubinden.
Nextcloud Eine Open-Source-Plattform für Dateien, Chat, Video und Office.
OIDC OpenID Connect — ein Standard für zentrales Login.
OpenRouter Ein Dienst, der Zugang zu verschiedenen KI-Modellen bietet.
OpenWebUI Eine Chat-Oberfläche im Browser, die mit Hermes verbunden wird.
Profile Eigenständige Hermes-Instanzen mit eigenem Chat-Verlauf, Skills und Erinnerungen — wie verschiedene Mitarbeiter.
Prometheus Ein System, das Metriken sammelt und speichert.
Reverse Proxy Ein Server, der Anfragen entgegennimmt und an andere Server weiterleitet.
Skill Eine Fähigkeit, die Hermes beibringt, wie eine bestimmte Aufgabe erledigt wird.
SSH Secure Shell — ein Protokoll für sichere, verschlüsselte Terminal-Verbindungen zu Servern.
Token Die „Währung" der KI — etwa ein Wort. Token kosten Geld.
TURN-Server Ein Vermittler-Server für Videokonferenzen, der Verbindungen hinter Routern ermöglicht.
Vaultwarden Ein selbstgehosteter Passwort-Manager (Bitwarden-kompatibel).
VPN Virtual Private Network — ein verschlüsselter Tunnel zwischen Geräten.
WAF Web Application Firewall — schützt Web-Anwendungen vor Angriffen.
Watchtower Ein Dienst, der Docker-Container automatisch aktualisiert.
WireGuard Ein modernes, schnelles VPN-Protokoll.
WSL2 Windows Subsystem for Linux — lässt Linux unter Windows laufen.
Zitadel Eine Open-Source-Plattform für Identitätsverwaltung.

B. Kostenübersicht (monatlich)#

Posten Kosten
OCI Server (Free Tier) 0 €
Grafana Cloud (Free Tier) 0 €
Cloudflare (Free Plan) 0 €
Domain (Njalla, jährlich umgelegt) ~1,50 €
OpenRouter (LLM-Zugang, Cloud) 5–30 €
Lokales LLM (Mac, z. B. Qwen 3) 0 € (einmalig Mac)
Gesamt (Minimum, Cloud) ~7–32 €
Gesamt (nur lokal) ~1,50 € (nur Domain)

Optionale Erweiterungen:

Posten Kosten
Raspberry Pi + 2 TB microSD ~80–110 € einmalig, 0 €/Monat
Gemieteter NFS-Storage (Alternative) ~5–10 €/Monat

Im Vergleich: Microsoft 365 Business kostet ca. 12 €/Monat pro Mitarbeiter. Bei einer Person wären das 12 € — nur für Office. ACME hat für diesen Preis die komplette IT-Infrastruktur inkl. KI-Assistentin.

C. Checkliste#

  • Phase 1: Hermes auf Laptop, Profil „IT" angelegt, LLM-Backend gewählt (Cloud und/oder lokal)
  • Sicherheits-Grundregeln gelesen: eigene ACME-Mail, einzigartige Passwörter, 2FA
  • Phase 2: Domain (Njalla) + Cloudflare eingerichtet
  • Phase 3: OCI-Server erstellt, Hermes hat SSH-Zugriff, Docker+Watchtower laufen
  • Phase 4: WireGuard VPN steht
  • Phase 5: Caddy (HTTPS) + Vaultwarden laufen
  • Phase 6: [Optional] Raspberry Pi NFS-Storage eingebunden
  • Phase 7: Nextcloud + Talk + TURN + Office laufen
  • Phase 8: Hermes auf OCI, 4 Profile, Nextcloud+Telegram angebunden
  • Phase 9: Prometheus + Grafana Cloud Dashboards + Alerting
  • Phase 10: [Optional] Elasticsearch, Zitadel, OpenWebUI, Matrix
  • Phase 11: Knowledge Base in Nextcloud, Skills für alle Profile
  • Phase 12: Tests, Backups, Cron-Jobs, Dokumentation

Dieses Dokument ist sowohl als Anleitung für Hermes-Agent-Installationen als auch als technischer Guide für Firmengründer gedacht. Es wird fortlaufend aktualisiert, wenn neue Komponenten hinzukommen.

Version 3.0 — erstellt von Jarvis für ACME

ACME Setup-Guide · Version 3.0 · Erstellt von Jarvis für ACME