Hermes Agent in der Praxis: AI-Assistent für Telegram/Feishu/WeCom über alle Plattformen aufbauen

Schwierigkeit: mittel · Dauer: ca. 20 Minuten · Nutzen: die zentralen Konfigurationen für den Hermes-Zugang über alle Plattformen beherrschen

Hast du dir schon mal gedacht: derselbe KI-Assistent läuft gleichzeitig in Telegram, Feishu und WeCom – und das nur mit einem einzigen Deployment? Hermes Agent kann genau das.

Es ist ein selbstlernender, evolvierender AI Agent aus dem Open-Source-Projekt von Nous Research. Ein besonderes Highlight ist ein eingebauter Nachrichten-Gateway für alle Plattformen. Du startest lediglich einen Prozess auf deinem Server und kannst gleichzeitig 10+ Messaging-Plattformen anbinden – darunter Telegram, Discord, Slack, Feishu, WeCom, Signal und WhatsApp. Die Nachrichten werden automatisch geroutet, das Gedächtnis ist plattformübergreifend gemeinsam nutzbar, die Konfiguration einmalig – und bleibt dauerhaft wirksam.

In diesem Artikel verbinden wir gemeinsam die drei am häufigsten genutzten Plattformen – Telegram, Feishu ( Lark ) und WeCom – komplett miteinander.

---

Zielgruppe

Dieser Artikel richtet sich an folgende Entwickler:

• Du hast grundlegende Linux-/Command-Line-Kenntnisse und möchtest einen KI-Agent auf einem Server selbst hosten
• Du hast Bedarf an Multi-Platform-Nachrichtenanbindung – als unabhängiger Entwickler oder kleines Team
• Du bewertest Hermes Agent als Alternative zu OpenClaw

---

Zentrale Abhängigkeiten & Umgebung

---

Vollständige Projektstruktur

hermes-agent/
├── scripts/
│   └── install.sh              # Ein-Klick-Installationsskript
└── ~/.hermes/                   # Hauptkonfigurationsverzeichnis (wird nach der Installation automatisch erstellt)
    ├── config.yaml              # Zentrale Konfiguration (Modelle, Toolset)
    ├── .env                     # API Keys (nicht in Git einreichen!)
    ├── skills/                  # Skills-Verzeichnis
    ├── memory/                  # Persistentes Gedächtnis
    ├── sessions/                # Sitzungsverlauf (FTS5 Volltextsuche)
    └── gateway/                 # Gateway-Konfiguration (plattform-spezifisches YAML)
        ├── telegram.yaml
        ├── feishu.yaml
        └── wecom.yaml

---

Schritt-für-Schritt-Anleitung

Schritt 1: Hermes Agent per Ein-Klick installieren

Unter Linux / macOS / WSL2 führst du das offizielle Installationsskript aus:

curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

Das Installationsskript kümmert sich automatisch um Python, Node.js und alle Abhängigkeiten – ohne dass du währenddessen manuell eingreifen musst. Nach der Installation lade das Shell neu:

source ~/.bashrc    # für Bash-Benutzer
source ~/.zshrc     # für Zsh-Benutzer

Prüfe, ob die Installation erfolgreich war:

hermes doctor

Schritt 2: LLM Provider konfigurieren – Defapi anbinden

Als Nächstes musst du Hermes sagen, wo es die Sprachmodelle finden soll. Wir tragen den API-Key in die .env-Datei ein:

hermes config set ANTHROPIC_API_KEY <your-defapi-key>

Defapi ist kompatibel mit dem Anthropic-v1/messages-Interface-Protokoll, Hermes kann es direkt verwenden. Alternativ kannst du über den Befehl hermes model interaktiv Modell und Provider auswählen:

hermes model
# interaktive Auswahl:
# 1. Nous Portal
# 2. OpenRouter (200+ Modelle)
# 3. OpenAI
# 4. Defapi / Custom Endpoint
# 5. Weitere...

Wenn du Defapi nutzt, wählst du im Interaktionsmenü den Custom Endpoint (Custom) und gibst Folgendes ein:

API Endpoint: https://api.defapi.org
Model: anthropic/claude-opus-4.6

Schritt 3: Den ersten Plattformzugang anbinden – Telegram Bot

Das ist die einfachste Plattform, um es zu verifizieren: Telegrams Bot API ist öffentlich, eine Unternehmensfreigabe ist nicht nötig.

3.1 Bot erstellen

In Telegram öffnest du @BotFather, sendest /newbot, benennst den Bot nach den Hinweisen und erhältst BOT_TOKEN – das Format ist ähnlich wie 123456789:ABCdefGHIjklMNOpqrsTUVwxyz.

3.2 Hermes-Gateway konfigurieren

hermes gateway setup
# Telegram auswählen und in der Interaktion die Konfiguration ausfüllen

Oder du erstellst die Datei ~/.hermes/gateway/telegram.yaml manuell:

platform: telegram
enabled: true
bot_token: "123456789:ABCdefGHIjklMNOpqrsTUVwxyz"

# Zugriffskontrolle: nur bestimmte Nutzer erlauben
allowed_users:
  - your_telegram_username

# Sicherheitseinstellungen
require_approval_for_dangerous_tools: true

3.3 Verifizieren

Nach dem Start des Gateways sendest du dem Bot eine Nachricht:

hermes gateway start
# oder im Hintergrund ausführen:
hermes gateway start --daemon

Sende in Telegram dem Bot /new. Der Bot sollte eine Willkommensnachricht antworten. Sende eine chinesische Nachricht, z. B. „你好“, und prüfe, ob die KI reagiert.

Schritt 4: Feishu (Lark) anbinden – Enterprise-App

Die Feishu-Anbindung ist etwas komplexer: Du musst im Feishu Open Platform eine unternehmensspezifische App erstellen.

4.1 App auf Feishu Open Platform erstellen

1. Öffne Feishu Open Platform und erstelle eine unternehmensgehostete App
2. In „Credentials & Basisinformationen“ erhalte App ID und App Secret
3. „Bot“-Fähigkeit aktivieren

4.2 Event-Subscription konfigurieren

In „Event Subscription“ der App:

• Request-URL URL eintragen: https://deine-domain/gateway/feishu/webhook
• Event auswählen: im.message.receive_v1 (zum Empfangen von Nachrichten)

4.3 App im Unternehmen installieren

Im Bereich „Version Management & Publishing“ musst du eine Version erstellen und veröffentlichen, sonst kann der Bot keine Nachrichten empfangen.

4.4 Hermes-Gateway konfigurieren

hermes gateway setup
# Feishu auswählen und interaktiv App ID sowie App Secret eingeben

Bearbeite alternativ manuell ~/.hermes/gateway/feishu.yaml:

platform: feishu
enabled: true
app_id: "cli_xxxxxxxxxxxxxx"
app_secret: "xxxxxxxxxxxxxxxxxxxx"
verification_token: "your_verification_token"

# Nachrichtenverschlüsselung (optional, aber empfohlen)
encrypt_key: "your_encrypt_key"

# Erlaubte Chats und Nutzer
allowed_chats: []
require_mention: false

4.5 Verifizieren

Sende dem Bot in Feishu /new. Prüfe, ob eine Antwort kommt. Das Nachrichtenformat in Feishu unterscheidet sich von Telegram: Der Bot unterstützt Rich-Text-Nachrichtenkarten, Hermes passt sich automatisch an.

Schritt 5: WeCom (WeChat Work) anbinden

Die Anbindung von WeCom ist ähnlich wie bei Feishu – auch hier läuft alles über den Callback-Webhook-Modus.

5.1 App im WeCom-Verwaltungsportal erstellen

1. Logge dich ins WeCom-Verwaltungsportal ein
2. Gehe zu „App Management“ → „Create App“ → wähle „Enterprise Custom“
3. Erhalte AgentId, Secret und die Unternehmens-CorpId
4. Setze „Trusted IP“ auf deine Server-IP

5.2 Nachrichten empfangen konfigurieren

Aktiviere in den App-Einstellungen den Modus „Empfangen von Nachrichten“:

• URL eintragen: https://deine-domain/gateway/wecom/webhook
• Modus wählen: „Compatibility Mode“ oder „Event Mode“

5.3 Hermes-Gateway konfigurieren

# ~/.hermes/gateway/wecom.yaml
platform: wecom
enabled: true
corp_id: "wwxxxxxxxxxxxxxx"
agent_id: "1000001"
corp_secret: "xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
encrypt_mode: "safe"    # Im Sicherheitsmodus muss encoding_aes_key konfiguriert werden
encoding_aes_key: "your_32_char_aes_key"

5.4 Verifizieren

Finde in WeCom deine App und sende eine Testnachricht.

Schritt 6: Gateway starten – einmal laufen lassen, drei Plattformen nutzen

Nachdem alle Plattformkonfigurationen fertig sind, starte das Gateway mit einem einzigen Befehl:

hermes gateway start

Hermes lädt automatisch alle aktivierten Plattform-Konfigurationen unter ~/.hermes/gateway/ und startet alle Adapter parallel. Wenn das Starten einer Plattform fehlschlägt (z. B. wegen eines falschen Tokens), beeinträchtigt das den normalen Betrieb der anderen Plattformen nicht.

Mit hermes gateway status siehst du den Laufstatus je Plattform:

Platform  Status   Users   Messages
telegram  ● online   3         142
feishu    ● online   7          89
wecom     ● online   2          15

Stoppe das Gateway mit Ctrl+C oder starte es im Hintergrund mit --daemon:

hermes gateway start --daemon

Schritt 7: Nachrichten über mehrere Plattformen verifizieren

Jetzt kannst du auf allen drei Plattformen jeweils Nachrichten an den Bot senden und testen:

# Telegram
/new
Hallo, stell dich kurz vor

# Feishu
/new
Wer bist du?

# WeCom
/new
Wobei kann ich dir helfen?

Die Antworten auf allen drei Endpunkten sind komplett identisch, das Gedächtnis wird geteilt – wenn du auf Telegram etwas erzählst, wissen Feishu und WeCom das ebenfalls. Das ist der Kernwert von Hermes: einmal konfigurieren, plattformweit einheitliches Erlebnis.

---

Häufige Probleme & Fehlerbehebung

1. Telegram Bot erhält keine Nachrichten

Symptom: Der Bot reagiert überhaupt nicht, auch die Logs zeigen keinerlei Einträge.

Fehlersuche:

# 1. Token bestätigen
hermes config get telegram.bot_token

# 2. Prüfen, ob der Port frei ist
ss -tlnp | grep 8080

# 3. Falls Webhook-Modus genutzt wird: Telegram-Bot-API-Konfiguration prüfen
# Webhook-URL muss von öffentlich erreichbar sein. Für lokale Entwicklung: ngrok für Tunnel
ngrok http 8080

# 4. Webhook zurücksetzen (manchmal hängt der Bot an einem alten Webhook)
curl -X POST "https://api.telegram.org/bot<YOUR_TOKEN>/deleteWebhook"

2. Feishu-Callback-Validierung fehlgeschlagen

Symptom: Feishu Open Platform zeigt „Callback-URL-Validierung fehlgeschlagen“.

Fehlersuche:

# 1. Sicherstellen, dass die öffentliche URL erreichbar ist
curl -X GET "https://your-domain.com/gateway/feishu/webhook"

# 2. Feishu-Signaturprüfung prüfen
# Feishu verschlüsselt Nachrichten per AES, encrypt_key muss mit der Backend-Konfiguration übereinstimmen
# Hermes-Logs ansehen:
hermes logs --platform feishu

3. WeCom-Nachrichten ohne Antwort

Symptom: Die Nachricht wird gesendet, aber es kommt keinerlei Antwort, und in den Logs gibt es keinen Eintrag.

Fehlersuche:

# 1. Bestätigen: CorpId / AgentId / Secret korrekt eingetragen
# 2. Am wichtigsten: IP-Whitelist prüfen
# WeCom fordert, dass die Server-IP, die die API aufruft, in der Trusted-IP-Liste steht

# 3. AccessToken testen
curl "https://qyapi.weixin.qq.com/cgi-bin/gettoken?corpid=wwxxx&corpsecret=secret"

# Wenn als Rückgabe "errmsg": "ip not in whitelist" kommt, wurde die IP nicht whitelisted

4. Modell reagiert nicht

Symptom: Der Bot erhält die Nachricht, aber die KI antwortet nicht. Es bleibt dauerhaft bei „thinking“.

Fehlersuche:

# 1. API Key testen, ob gültig
curl -X POST "https://api.defapi.org/api/v1/messages" \
  -H "Authorization: Bearer <your-key>" \
  -H "Content-Type: application/json" \
  -d '{"model":"anthropic/claude-opus-4.6","messages":[{"role":"user","content":"hi"}],"max_tokens":10}'

# 2. Modell-Konfiguration prüfen
hermes config get model

# 3. fallback_providers prüfen (empfohlene Konfiguration)
# Ergänze in ~/.hermes/config.yaml einen Backup-Provider:
fallback_providers:
  - provider: openrouter
    api_key: "${OPENROUTER_API_KEY}"

5. Fehler bei der Tool-Ausführung

Symptom: Der Bot antwortet, dass er eine Aktion nicht ausführen kann.

Fehlersuche:

# 1. Aktives Toolset prüfen
hermes tools

# 2. Benötigtes Toolset aktivieren
hermes tools enable web_search
hermes tools enable terminal

# 3. Gefährliche Befehle benötigen manuelle Bestätigung
# Konfiguration prüfen:
hermes config get approval_required
# Auf true setzen führt dazu, dass alle gefährlichen Befehle von dir manuell genehmigt werden müssen

6. Mehrplattform-Konflikte bei Parallelbetrieb

Symptom: Nach einer Nachricht eines Plattformendpunktes reagieren die anderen Plattformen nicht mehr.

Fehlersuche:

Die Token-Lock-Mechanik von Hermes v0.6.0 verhindert, dass zwei Plattforminstanzen denselben Bot-Token verwenden und dadurch kollidieren. Aber wenn du auf mehreren Maschinen mehrere Instanzen desselben Bots laufen lässt, kann genau dieses Problem auftreten.

# Sicherstellen, dass nur eine Hermes-Gateway-Instanz läuft
ps aux | grep hermes
pkill -f hermes-agent

# Danach neu starten
hermes gateway start

---

Weiterführende Lektüre / Fortgeschrittene Richtungen

Von OpenClaw migrieren

Wenn du bereits OpenClaw nutzt, bietet Hermes ein offizielles Migrations-Tool, das SOUL.md, MEMORY.md, Skills, API Keys und Messaging-Plattform-Konfigurationen automatisch importiert:

hermes claw migrate              # Interaktive vollständige Migration
hermes claw migrate --dry-run    # Vorabvorschau
hermes claw migrate --preset user-data  # Keine sensiblen Informationen migrieren

MCP-Server-Modus

Hermes v0.6.0 bringt die Fähigkeit zum MCP Server mit. Damit kann Hermes Tools nach außen verfügbar machen – per einem einzigen Befehl:

hermes mcp serve
# unterstützt zwei Transportprotokolle: stdio und Streamable HTTP

Nach der Verbindung können IDEs wie Cursor, VS Code oder Zed über das MCP-Protokoll alle Tools und Dialogfähigkeiten von Hermes aufrufen.

Custom Skills System

Das Skills-System von Hermes unterstützt das automatische Erstellen von Skills aus natürlichsprachlichen Beschreibungen. Du kannst es aber auch manuell schreiben:

# Bestehende Skills anzeigen
hermes skills

# Skills Hub (Community-Skill-Marktplatz) ansehen
/skills

# Community Skills von agentskills.io installieren

Cron-Tasks (zeitgesteuerte Aufgaben)

Du kannst zeitgesteuerte Aufgaben in natürlicher Sprache definieren. Hermes führt sie automatisch aus und schickt die Ergebnisse an jede beliebige Plattform:

# Jeden Tag um 8 Uhr Wetterbericht an Telegram senden
/cron "Every day at 8am, summarize today's weather and send to me" --platform telegram

---

Abschluss

Das Design des Hermes-Agent-Gateways für alle Plattformen ist ausgesprochen elegant: Du musst nur eine einzige Konfiguration pflegen, damit dieselbe Agent-Instanz auf beliebigen Messaging-Plattformen läuft. Das Gedächtnis wird plattformübergreifend geteilt, die Konfiguration ist einmal erledigt, und der Ressourcenverbrauch ist deutlich geringer als bei mehreren unabhängigen Bots.

Wenn du noch OpenClaw nutzt – oder gerade nach einem wirklich konkurrenzfähigen Open-Source-KI-Agent suchst – dann lohnt sich Hermes: probiere ihn ruhig 20 Minuten lang aus. In Kombination mit dem halbpreisigen Claude Opus 4.6 von Defapi kannst du die monatlichen Kosten auf 50% drücken, ohne dass sich das Erlebnis merklich verschlechtert.