Dernière version du 30 août 2026 à 16:28

Prérequis

(Hermes seul)

Une machine ou VM dédiée (LXC compatible)

Pour un Hermes de base (sans LLM local) :

RAM :
- 1 Go → minimum (test uniquement)
- 2 Go → recommandé
- 4 Go -> confortable
CPU / vCPU :
- 1 vCPU → suffisant
- 2 vCPU → recommandé
Espace disque :
- 5 Go → minimum
- 10 Go → confortable
GPU :
- Inutile

Installation Hermes (service dédié)

Installation (Debian)

# apt update && apt upgrade
# apt install curl git
# curl -fsSL https://raw.githubusercontent.com/NousResearch/hermes-agent/main/scripts/install.sh | bash

How would you like to set up Hermes?
> (○) Quick setup — provider, model & messaging (recommended)

Ollama local :

Select provider:
>(○) Custom endpoint (enter URL manually)

Custom OpenAI-compatible endpoint configuration:
API base URL [e.g. https://api.example.com/v1]: http://IP_OLLAMA:11434/v1
API key [optional]:

Detected model: mon_model
Use this model? [Y/n]: Y

Context length in tokens [leave blank for auto-detect]:

Display name [192.168.2.216:11434]: Ollama

Llama.cpp :

Select provider:
>(○) Custom endpoint (enter URL manually)

Custom OpenAI-compatible endpoint configuration:
API base URL [e.g. https://api.example.com/v1]: https://IP_OLLAMA:11434/v1

Remplir les options désirées puis fin de l'installation :

Launch hermes chat now? [Y/n]: y

Ensuite, inscrire Hermes comme service pour qu'il se lance automatiquement :

Sur une machine physique ou VM :

# hermes gateway install --system

Dans un LXC :

# hermes gateway install --system --run-as-user root

# systemctl enable hermes-gateway.service      
# systemctl start hermes-gateway.service

Configuration

Activer le serveur API

On édite le fichier :

# vi ~/.hermes/.env

Ajouter :

...
API_SERVER_ENABLED=true
API_SERVER_KEY="maclefsecrete"
# pour autoriser toutes les interfaces :
API_SERVER_HOST=0.0.0.0
# pour autoriser une seule interface :
# API_SERVER_HOST=IP_HERMES
API_SERVER_PORT=8642

Si API_SERVER_HOST=0.0.0.0 : l’API est accessible sur le réseau. Définir impérativement une clé API_SERVER_KEY longue et aléatoire, au minimum 16 caractères, idéalement générée avec openssl rand -hex 32. Limiter aussi l’accès via firewall ou réseau privé recommandé.

On relance le service :

# systemctl restart hermes-gateway.service

Pour tester :

# curl http://IP_HERMES:8642/health

Doit renvoyer :

{"status":"ok"}

Pour vérifier le modèle exposé :

# curl http://IP_HERMES:8642/v1/models -H "Authorization: Bearer maclefsecrete"

Retarder le démarrage de Hermes au boot pour laisser le temps aux autres services de se lancer

# systemctl edit hermes-gateway.service

Ajouter dans la zone d’édition (partie supérieure du fichier) :

...
### Anything between here and the comment below will become the contents of the drop-in file

[Service]
ExecStartPre=/bin/sh -c 'uptime=$(cut -d. -f1 /proc/uptime); [ "$uptime" -lt 120 ] && sleep 30 || true'

### Edits below this comment will be discarded
...

Cette commande ajoute une pause de 30 secondes uniquement si la machine a démarré depuis moins de 120 secondes.

Cela permet d’éviter que Hermes tente de se connecter trop tôt à certains services encore en cours de démarrage.

Activer le Dashboard

Le Dashboard expose l’interface d’administration de Hermes ainsi que les API utilisées notamment pour les sessions, skills, configuration, jobs et certaines fonctions MCP.

Avant de modifier la configuration, on génère le hash du mot de passe qui sera utilisé pour l’authentification :

# python3 -c 'import hashlib,secrets,base64; p="MON_MOT_DE_PASSE"; s=secrets.token_bytes(16); d=hashlib.scrypt(p.encode(),salt=s,n=16384,r=8,p=1,dklen=32); print(f"scrypt$16384$8$1${base64.b64encode(s).decode()}${base64.b64encode(d).decode()}")'

La commande retourne une valeur de la forme :

scrypt$16384$8$1$...

On génère ensuite le secret utilisé pour signer les sessions du Dashboard :

# openssl rand -hex 32

On édite alors le fichier :

# vi ~/.hermes/.env

Ajouter :

...
HERMES_DASHBOARD_BASIC_AUTH_USERNAME=admin
HERMES_DASHBOARD_BASIC_AUTH_PASSWORD_HASH="scrypt$16384$8$1$..."
HERMES_DASHBOARD_BASIC_AUTH_SECRET="secret_généré_par_openssl"
...

Le Dashboard donne accès à des fonctions d’administration sensibles de Hermes. Dès qu’il écoute sur une interface réseau autre que 127.0.0.1, Hermes impose une authentification. Utiliser un mot de passe fort et limiter également l’accès au port 9119 via firewall ou réseau privé.

On crée un service systemd pour lancer automatiquement le Dashboard après Hermes Gateway :

# vi /etc/systemd/system/hermes-dashboard.service

Ajouter :

[Unit]
Description=Hermes Dashboard
Requires=hermes-gateway.service
After=hermes-gateway.service

[Service]
Type=simple
User=root
Environment=HOME=/root
WorkingDirectory=/root

ExecStartPre=/bin/sh -c 'until /usr/bin/curl -fsS http://IP_GATEWAY_HERMES:8642/health >/dev/null; do sleep 1; done'

ExecStart=/root/.local/bin/hermes dashboard --host IP_DASHBOARD --port 9119 --no-open

Restart=on-failure
RestartSec=5

[Install]
WantedBy=multi-user.target

Remplacer IP_GATEWAY_HERMES par l’adresse à laquelle le Gateway Hermes est accessible.

Remplacer IP_DASHBOARD par l’adresse locale de l’interface réseau sur laquelle le Dashboard doit écouter. Utiliser une adresse précise plutôt que 0.0.0.0 permet de limiter son exposition au réseau souhaité.

On recharge la configuration systemd :

# systemctl daemon-reload

On active le service au démarrage :

# systemctl enable hermes-dashboard.service

On le démarre :

# systemctl start hermes-dashboard.service

Pour vérifier son état :

# systemctl status hermes-dashboard.service

Pour suivre les logs :

# journalctl -u hermes-dashboard.service -f

Pour vérifier que le Dashboard écoute :

# ss -lntp | grep 9119

Pour tester son API :

# curl http://IP_HERMES:9119/api/status

Utiliser une CA privée avec Hermes

Si Hermes doit se connecter à un service HTTPS signé par une CA privée locale, il peut être nécessaire d’indiquer explicitement à Python et aux bibliothèques HTTP quel bundle de certificats utiliser.

Éditer l’override systemd du service :

# systemctl edit hermes-gateway.service

Ajouter dans la zone d’édition (partie supérieure du fichier) :

...
### Anything between here and the comment below will become the contents of the drop-in file

[Service]
Environment="SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt"
Environment="REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt"
Environment="CURL_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt"

### Edits below this comment will be discarded
...

Explication rapide :

SSL_CERT_FILE : utilisé par Python / OpenSSL
REQUESTS_CA_BUNDLE : utilisé par la bibliothèque Python requests
CURL_CA_BUNDLE : utilisé par curl et parfois comme variable de repli

Puis recharger et redémarrer le service :

# systemctl daemon-reload
# systemctl restart hermes-gateway.service

Cas particulier : bundle certifi du venv Hermes

Dans certains cas, le runtime Python embarqué par Hermes peut continuer à utiliser le bundle interne de certifi au lieu du magasin système.

Si curl valide déjà le certificat avec /etc/ssl/certs/ca-certificates.crt mais que Hermes/OpenAI/httpx échoue avec CERTIFICATE_VERIFY_FAILED, on peut remplacer le bundle certifi du venv Hermes par le bundle système.

Sauvegarder le bundle actuel :

# cp /root/.hermes/hermes-agent/venv/lib/python3.11/site-packages/certifi/cacert.pem /root/.hermes/hermes-agent/venv/lib/python3.11/site-packages/certifi/cacert.pem.bak

Remplacer par le bundle système :

# cp /etc/ssl/certs/ca-certificates.crt /root/.hermes/hermes-agent/venv/lib/python3.11/site-packages/certifi/cacert.pem

Attention : cette modification peut être écrasée lors d’une mise à jour de Hermes, du venv Python ou du paquet certifi.

Automatiser le remplacement du certificat du venv

On édite le service Hermes :

# systemctl edit hermes-gateway.service

Ajouter dans la zone d’édition (partie supérieure du fichier) :

...
### Anything between here and the comment below will become the contents of the drop-in file

[Service]
ExecStartPre=/bin/cp /etc/ssl/certs/ca-certificates.crt /root/.hermes/hermes-agent/venv/lib/python3.11/site-packages/certifi/cacert.pem

### Edits below this comment will be discarded
...

Puis recharger systemd et redémarrer le service :

# systemctl daemon-reload
# systemctl restart hermes-gateway.service

Éditer le prompt système

On édite le fichier suivant :

# vi ~/.hermes/SOUL.md

Puis on modifie le contenu de SOUL.md, qui constitue la partie personnalisée du prompt système de Hermes, par exemple :

You are Hermes Agent, an intelligent AI assistant created by Nous Research. You are helpful, knowledgeable, and direct. You assist users with a wide range of tasks including answering questions, writing and editing code, analyzing information, creative work, and executing actions via your tools. You communicate clearly, admit uncertainty when appropriate, and prioritize being genuinely useful over being verbose unless otherwise directed below. Be targeted and efficient in your exploration and investigations.
TOOLS:
- For current, recent, upcoming, time-sensitive, location-specific, or uncertain factual questions, use searxng_web_search.
- To read a specific URL, use web_url_read.
- For search suggestions, use searxng_search_suggestions.
- For SearXNG instance capabilities, categories, engines, locales, and plugins, use searxng_instance_info.
- For indexed documents, internal documentation, knowledge bases, or when the user asks to check the docs, use the RAGFlow MCP tools: ragflow_retrieval, ragflow_list_datasets, and ragflow_list_chats.
RULES:
- Respond in the same language as the user.
- Do not invent tool results.
- If a tool fails, say so explicitly.
- Do not promise to continue later, follow up later, or say that results are still coming.
- When the user asks multiple questions, use the tools needed, then answer all requested items in one final structured response.
- Never answer current, recent, upcoming, time-sensitive, location-specific, or uncertain factual questions without using the required tool first.
- This includes weather, news, prices, schedules, releases, availability, rankings, versions, and other facts that may have changed.
- If no tool result is available, say you cannot verify and do not guess.
- Use search categories when relevant.
- For image searches, use searxng_web_search with categories=images.
- For video searches, use searxng_web_search with categories=videos.
- For image search results, use the `img_src` field as the direct image URL.
- When displaying an image result, ALWAYS output the direct image URL exactly in this format: ![](URL)
- Do not output the image URL as a normal Markdown link.
- For video results, output links in this format: ~_~N [Titre de la vidéo](URL)
- Do not use tools for simple rewriting, translation, or opinion unless needed.
- Do not use terminal/curl to query RAGFlow unless explicitly asked for a network diagnostic.
- If no RAGFlow dataset exists or no relevant result is found, say so clearly.

Enfin, on redémarre le service :

# systemctl restart hermes-gateway.service

Signal

Signal est une messagerie instantanée axée sur la confidentialité. Tous les messages et appels y sont chiffrés de bout en bout par défaut via le Signal Protocol, de sorte que ni Signal ni un tiers ne peuvent en lire le contenu. Signal se distingue également par une collecte de données très limitée, l’absence de publicité et de traqueurs, ainsi qu’un effort particulier pour réduire les métadonnées accessibles au service.

Signal permet de relier Hermes à la messagerie chiffrée Signal. La connexion ne se fait pas directement avec le téléphone, mais via signal-cli exécuté en mode daemon HTTP, auquel Hermes se connecte ensuite.

Installation :

Via Docker

Installation séparée (Docker sur autre machine) : Les images et fichiers audio générés par Hermes ne peuvent pas être envoyés en pièces jointes natives, signal-cli n'a pas accès au cache local de Hermes (/root/.hermes/image_cache/). Seules les URLs brutes seront transmises.

Pour les pièces jointes natives (images, audio TTS, vidéos), installer signal-cli sur le même serveur qu'Hermes via l'installation native.

# mkdir -p /opt/signal-cli
# vi /opt/signal-cli/docker-compose.yml

services:
  signal-cli:
    image: registry.gitlab.com/packaging/signal-cli/signal-cli-jre:latest
    container_name: signal-cli
    restart: unless-stopped
    command: daemon --http 0.0.0.0:8080
    ports:
      - "IP_SERVEUR:8080:8080" # Remplacer par IP du serveur, ou 127.0.0.1 pour restreindre acces local uniquement
    volumes:
      - signal-cli-data:/var/lib/signal-cli
    tmpfs:
      - /tmp:exec

volumes:
  signal-cli-data:

 # docker compose -f /opt/signal-cli/docker-compose.yml --project-directory /opt/signal-cli up -d

Connexion au téléphone :

Installer qrencode :

# apt install qrencode

Dans le terminal :

# docker exec signal-cli signal-cli link -n "HermesAgent" > /tmp/signal-link.txt 2>&1 & sleep 3 && grep -o 'sgnl://[^ ]*' /tmp/signal-link.txt | qrencode -t ANSIUTF8 && wait

Puis scanner le QR code avec l’application Signal via Paramètres -> Appareils associés.

Connecter Hermes à Signal :

# hermes setup

Connect a messaging platform? (Telegram, Discord, etc.)
-> ●) Set up messaging now (recommended)

Puis redémarrer le service :

# systemctl restart hermes-gateway.service

Communiquer avec le serveur via Signal (depuis le téléphone dans l'application Signal) :
- Appuyer sur l’icône ✏️ (nouveau message)
- Tout en haut de la liste, "Note to Self" ou votre propre nom apparaît
- Taper votre message : Hermes répond dans cette même conversation
- (Optionnel) taper /sethome pour définir le canal par défaut pour les notifications et les tâches planifiées.

Native

Installation :

On installe les dépendances si nécessaire :

# apt update && apt upgrade
# apt install tar qrencode openjdk-25-jre-headless

Si l'installation échoue, vérifier la compatibilité Java : signal-cli --version. En cas d'erreur UnsupportedClassVersionError, installer la version Java requise via apt install openjdk-XX-jre-headless.

On Installe le programme :

# cd /tmp
# VERSION=$(curl -Ls -o /dev/null -w %{url_effective} https://github.com/AsamK/signal-cli/releases/latest | sed 's/^.*\/v//')
# curl -L -O "https://github.com/AsamK/signal-cli/releases/download/v${VERSION}/signal-cli-${VERSION}.tar.gz"
# tar xf "signal-cli-${VERSION}.tar.gz" -C /opt
# ln -sf "/opt/signal-cli-${VERSION}/bin/signal-cli" /usr/local/bin/
# rm /tmp/signal-cli-${VERSION}.tar.gz

Appareillage du téléphone :

# signal-cli link -n "HermesAgent" > /tmp/signal-link.txt 2>&1 & sleep 5 && grep -o 'sgnl://[^ ]*' /tmp/signal-link.txt | qrencode -t ANSIUTF8 && wait

Puis scanner le QR code avec l’application Signal via Paramètres -> Appareils associés.

On créé un service :

# vi /etc/systemd/system/signal-cli.service

[Unit]
Description=signal-cli daemon
After=network.target

[Service]
ExecStart=/usr/local/bin/signal-cli --account +VOTRE_NUMERO daemon --http 127.0.0.1:8080
Restart=always
RestartSec=5

[Install]
WantedBy=multi-user.target

# systemctl daemon-reload
# systemctl enable --now signal-cli
# systemctl status signal-cli

Connecter Hermes à Signal :

# hermes setup

Connect a messaging platform? (Telegram, Discord, etc.)
-> ●) Set up messaging now (recommended)

Puis redémarrer le service :

# systemctl restart hermes-gateway.service

Communiquer avec le serveur via Signal (depuis le téléphone dans l'application Signal) :
- Appuyer sur l’icône ✏️ (nouveau message)
- Tout en haut de la liste, "Note to Self" ou votre propre nom apparaît
- Taper votre message : Hermes répond dans cette même conversation
- (Optionnel) taper /sethome pour définir le canal par défaut pour les notifications et les tâches planifiées.

Mise à jour automatique

Il est recommandé de mettre à jour l'application Signal au moins tous les trois mois.

Version native :

On créé un script :

# vi /usr/local/bin/update-signal-cli.sh

#!/bin/bash
set -e

systemctl stop signal-cli || true
cd /tmp

VERSION=$(curl -Ls -o /dev/null -w '%{url_effective}' https://github.com/AsamK/signal-cli/releases/latest | sed 's/^.*\/v//')

curl -L -O "https://github.com/AsamK/signal-cli/releases/download/v${VERSION}/signal-cli-${VERSION}.tar.gz"

rm -rf "/opt/signal-cli-${VERSION}"
tar xf "signal-cli-${VERSION}.tar.gz" -C /opt

ln -sf "/opt/signal-cli-${VERSION}/bin/signal-cli" /usr/local/bin/signal-cli
rm -f "/tmp/signal-cli-${VERSION}.tar.gz"

# Vérifier la compatibilité Java
if ! signal-cli --version > /dev/null 2>&1; then
    ERROR="$(signal-cli --version 2>&1 || true)"

    echo "$ERROR"

    REQUIRED="$(echo "$ERROR" | grep -oE 'class file (version|major version) [0-9]+' | grep -oE '[0-9]+' | tail -n1 || true)"

    if [ -z "$REQUIRED" ]; then
        echo "Impossible de détecter automatiquement la version Java requise."
        echo "Installation de Java 21 par défaut..."
        JAVA_VERSION=21
    else
        JAVA_VERSION=$((REQUIRED - 44))
        echo "Class file version $REQUIRED détectée => Java $JAVA_VERSION requis."
    fi

    apt update
    apt install -y "openjdk-${JAVA_VERSION}-jre-headless"

    if [ -x "/usr/lib/jvm/java-${JAVA_VERSION}-openjdk-amd64/bin/java" ]; then
        update-alternatives --set java "/usr/lib/jvm/java-${JAVA_VERSION}-openjdk-amd64/bin/java"
    else
        echo "Java $JAVA_VERSION installé, mais chemin update-alternatives non trouvé. Vérifie avec :"
        echo "update-alternatives --config java"
    fi
fi

systemctl start signal-cli

# chmod +x /usr/local/bin/update-signal-cli.sh

On ajoute le script au crontab :

# crontab -e

Ajouter :

...
0 3 1 * * /usr/local/bin/update-signal-cli.sh

0 → minute 0
3 → 3h du matin
1 → le 1er du mois
* → tous les mois
* → peu importe le jour de la semaine

Version docker :

Voir Watchtower pour la mise à jour automatique de tous les containers Docker. (tuto à faire..)

SearXNG

L’intégration native de SearXNG dans Hermes Agent convient aux recherches web classiques et offre une configuration plus simple. Pour un accès plus complet aux fonctions de SearXNG, notamment aux catégories images, vidéos, actualités et à certains paramètres avancés, il est préférable d’utiliser le serveur MCP SearXNG.

Il faut d’abord avoir installé une instance SearXNG.

Sur le serveur Hermes, lancer :

# hermes tools

→ (○) Reconfigure an existing tool's provider or API key

→ (○) 🔍 Web Search & Scraping

→ (●) SearXNG [free · self-hosted] — Free, privacy-respecting metasearch. Point SEARXNG_URL at your instance. [active]

Entrer ensuite l’adresse de l’instance SearXNG :

SearXNG instance URL (e.g. http://localhost:8080) (Enter to keep current):

Scraping via Firecrawl

Il faut d’abord avoir installé une instance Firecrawl.

On renseigne l'adresse de l'instance Firecrawl :

# vi ~/.hermes/.env

...
FIRECRAWL_API_URL=http://IP_DE_FIRECRAWL:3002
...

Si besoin configurer l'API key :

...
FIRECRAWL_API_KEY=c-xxxxxxxxxxxxxxxx
...

Ensuite on édite la configuration de Hermes :

# vi ~/.hermes/config.yaml

On remplace :

web:
  backend: searxng
  search_backend: 
  extract_backend:

Par :

web:
  backend: searxng
  search_backend: searxng
  extract_backend: firecrawl

Enfin on redémarre Hermes :

# systemctl restart hermes-gateway.service

Camofox

Installation native

Méthode recommandé mais déconseillé en cas d'utilisation conjointe avec le MCP SearXNG afin de pouvoir désactiver les outils web natifs de Hermes.

Il faut d’abord avoir installé une instance Camofox.

Sur le serveur Hermes, lancer :

# hermes tools

→ (○) Reconfigure an existing tool's provider or API key

→ (○) 🌐 Browser Automation

→ (●) Camofox [free · local] — Anti-detection browser (Firefox/Camoufox)

Entrer ensuite l’adresse de l’instance Camofox:

Camofox server URL (Enter to keep current):

Règle prompt système facultative :

...
  RULES:
  - If `web_extract` fails or is blocked, use `browser_navigate` through the Camofox browser provider.
...

Via MCP

Voir MCP-CamoFox

Forcer les timeouts d'une IA locale pour une IA derrière une URL

Si l'API de votre IA locale est desservie derrière une URL publique, Hermes peut ne pas la détecter comme un fournisseur local. Il est possible de modifier les timeouts utilisés pour les fournisseurs locaux :

# vi ~/.hermes/.env

...
HERMES_API_TIMEOUT=1800
HERMES_STREAM_READ_TIMEOUT=1800
# HERMES_STREAM_STALE_TIMEOUT=180
HERMES_API_CALL_STALE_TIMEOUT=900
HERMES_AGENT_TIMEOUT=900

# systemctl restart hermes-gateway.service

Fonctions auxiliaires

Configuration des modèles utilisés par Hermes pour les tâches secondaires, indépendamment du modèle principal de conversation.

Editer la section auxiliary dans :

# vi ~/.hermes/config.yaml

vision : analyse d’images (modèle multimodal avec vision)
web_extract : extraction et synthèse de contenu web (LLM texte)
compression : compression et résumé du contexte (LLM texte avec un contexte suffisamment long)
skills_hub : recherche et sélection de compétences (LLM texte léger)
approval : évaluation et validation des actions sensibles (LLM texte léger et fiable)
mcp : sélection et routage des outils MCP (LLM texte efficace en appel d’outils)
title_generation : génération de titres de conversations (petit LLM texte rapide)
tts_audio_tags : génération de balises expressives pour la synthèse vocale (LLM texte léger)
triage_specifier : classification et orientation des demandes (LLM texte léger)
kanban_decomposer : décomposition d’un projet en tâches Kanban (LLM texte avec de bonnes capacités de planification)
profile_describer : génération d’une description de profil (LLM texte)
curator : sélection et organisation du contenu (LLM texte avec de bonnes capacités de synthèse)
monitor : analyse des résultats de surveillance (LLM texte léger)
background_review : révision et analyse en arrière-plan (LLM texte)
moa_reference : production d’une réponse de référence pour le MoA (LLM texte performant)
moa_aggregator : agrégation et synthèse des réponses MoA (LLM texte performant avec un contexte long)
session_search : analyse et sélection des résultats de recherche dans les sessions (LLM texte léger)
flush_memories : sélection et consolidation des souvenirs pertinents (LLM texte léger et fiable)

Note sur vision et les modèles principaux multimodaux

Certains modèles principaux (ex. Qwen3.6-27B) sont nativement multimodaux (encodeur vision intégré au checkpoint) — ce n’est donc pas systématiquement une histoire de « modèle texte qui ne sait pas voir ». Même dans ce cas, garder vision sur un petit modèle auxiliaire séparé reste recommandé pour trois raisons :

Évite de mobiliser le modèle principal (VRAM + temps de calcul) pour une tâche que 4B suffit à traiter.
Le petit modèle peut se décharger automatiquement (--sleep-idle-seconds), pas forcément possible/souhaitable sur le principal.
Latence : un 4B répond bien plus vite qu’un 27B pour une simple description/OCR d’image.

Recommandations

Dans une configuration locale disposant de peu de VRAM disponible, il est recommandé d’attribuer certaines fonctions auxiliaires à des modèles plus petits et plus rapides, afin d’éviter de mobiliser inutilement le modèle principal.

vision : fortement recommandé avec un modèle multimodal séparé (environ 3 à 4 milliards de paramètres ; par exemple Qwen2.5-VL-3B-Instruct, Qwen3-VL-4B-Instruct ou Gemma 3 4B). Un modèle quantifié en Q4 est généralement suffisant pour l’analyse d’images courante. Pour de l’OCR/transcription de texte dense, augmenter --image-min-tokens/--image-max-tokens (ex. 2048/8192) et ajouter un --repeat-penalty 1.1 pour éviter les boucles de génération sur du texte peu lisible à basse résolution.
title_generation : recommandé avec un petit modèle texte très rapide (environ 0,5 à 3 milliards de paramètres ; par exemple Qwen3 0.6B, 1.7B ou un modèle instruct équivalent). Tâche simple, ne nécessite pas un modèle puissant.
web_extract : recommandé avec un modèle texte rapide disposant d’un contexte suffisamment long (environ 3 à 8 milliards de paramètres ; par exemple Qwen3 4B Instruct ou Gemma 3 4B). Privilégier un modèle capable de traiter au moins 32 000 jetons.
compression : recommandé avec un modèle texte intermédiaire doté d’un contexte long et de bonnes capacités de résumé (environ 7 à 14 milliards de paramètres). Un modèle de 3-4B peut fonctionner mais risque de perdre davantage d’informations sur de longues conversations — à éviter si le modèle principal tourne avec un gros contexte (100K+), préférer laisser cette tâche sur le principal dans ce cas plutôt qu’un 4B sous-dimensionné.
mcp : petit modèle texte fiable en sélection/appel d’outils (environ 3 à 8 milliards de paramètres ; ex. Qwen3 4B Instruct). Éviter les modèles extrêmement petits si plusieurs outils ont des descriptions proches.
approval : petit modèle texte fiable (environ 3 à 8 milliards de paramètres). Qualité et respect des consignes plus importants que la vitesse brute — valide des actions sensibles, ne pas sous-dimensionner.
skills_hub, triage_specifier, tts_audio_tags, session_search, monitor : petit modèle texte rapide suffisant (environ 1 à 4 milliards de paramètres).
flush_memories : petit modèle fiable capable de distinguer l’important du temporaire (environ 3 à 8 milliards de paramètres).
profile_describer : petit ou moyen modèle texte (environ 3 à 8 milliards de paramètres).
kanban_decomposer, background_review : modèle texte intermédiaire avec de bonnes capacités de planification/analyse (environ 7 à 14 milliards de paramètres).
curator : modèle texte intermédiaire à performant pour synthèse (7 à 14 milliards de paramètres, plus pour analyses complexes).
moa_reference : modèle texte performant (14 milliards de paramètres ou plus).
moa_aggregator : modèle texte performant avec contexte long (14B+, au moins 64 000 jetons de contexte).

Pour une première optimisation, il est conseillé de configurer en priorité :

vision : modèle multimodal de 3 à 4 milliards de paramètres
title_generation : modèle texte de 0,5 à 3 milliards de paramètres
web_extract : modèle texte de 3 à 8 milliards de paramètres avec contexte long
compression : modèle texte de 7 à 14 milliards de paramètres avec de bonnes capacités de résumé

Les autres fonctions peuvent rester sur provider: auto tant qu’elles ne provoquent pas de lenteurs, de délais d’attente ou une consommation excessive de ressources.

Contexte recommandé par fonction

Le sur-dimensionnement du contexte (-c) est l’un des plus gros gaspillages de VRAM sur les petits modèles auxiliaires — le mettre par défaut à une valeur « confortable » unique pour toutes les routes coûte cher sans bénéfice.

Fonction	Contexte suggéré	Remarque
`title_generation`	2-4K	Ne voit que les 1-2 premiers messages
`tts_audio_tags`	2-4K	Passage de texte court à annoter
`triage_specifier`	4K	Juste la requête à classifier
`skills_hub`	4-8K	Liste de compétences + requête
`session_search`	8K	Résultats de recherche à trier
`monitor`	8K	Selon la taille des logs surveillés
`flush_memories`	8K	Candidats mémoire à évaluer
`profile_describer`	8K	Historique modéré
`approval`	8-16K	Action proposée + contexte suffisant
`mcp`	8-16K	Selon le nombre d’outils déclarés
`kanban_decomposer`	8-16K	Description de projet
`vision`	16K	Ajuster si usage OCR intensif (image seule jusqu’à 8K tokens)
`curator`	16-32K	Peut agréger plusieurs sources
`background_review`	16-32K	Selon ce qui est passé en revue
`web_extract`	32K	Recommandation explicite
`moa_reference`	32K	Réponses de référence potentiellement longues
`compression`	32-64K	Dépend de la longueur laissée s’accumuler avant déclenchement
`moa_aggregator`	64K minimum	Exigence explicite (agrège plusieurs longues réponses)

Quantification (poids du modèle)

Tâches à faible enjeu (title_generation, tts_audio_tags, skills_hub, monitor, session_search, triage_specifier) : Q4_K_M suffit largement.
Tâches à enjeu réel (approval, mcp, web_extract, compression, vision) : privilégier Q5_K_M ou Q6_K — sur des modèles 4-8B, l’écart VRAM entre Q4 et Q6 reste faible (souvent < 1,5 Go), autant prendre la marge.

KV cache (contexte)

En dessous de 16K de contexte : Pas de quantization ou q8_0/q8_0 en KV cache partout par défaut, sur toutes les routes auxiliaires — risque de dégradation négligeable, aucune raison de s'en priver même à faible contexte.
À partir de 32K (web_extract, moa_reference, compression) : q8_0/q8_0 simple devient intéressant, gain notable pour un risque quasi nul.
moa_aggregator à 64K+ : seule route où une approche plus poussée type q8_0/q6_0 + Hadamard (si le fork le supporte) se justifie, vu le volume réel de KV cache à comprimer.

Réglages de la voix

Text-to-Speech (TTS)

# vi ~/.hermes/config.yaml

Configuration par défaut :

...
tts:
  provider: edge
  edge:
    voice: en-US-AriaNeural
...

Parmi les options gratuites et simples proposées par Hermes, Edge constitue probablement le meilleur choix par défaut. Il est toutefois recommandé de sélectionner une voix adaptée à la langue utilisée. Exemple pour le français :

...
tts:
  provider: edge
  edge:
    voice: fr-FR-DeniseNeural
...

TTS via CrispASR

Voir CrispASR

CrispASR expose une API de synthèse vocale compatible avec l’API audio d’OpenAI. Hermes doit donc utiliser le fournisseur openai pour envoyer le texte au serveur TTS.

Dans le fichier ~/.hermes/config.yaml :

...
tts:
  provider: openai
...
  openai:
    model: qwen3-tts-12hz-0.6b-base-q8_0
    voice: default
    base_url: http://IP_CRISPASR:7981/v1
...

Lorsque CrispASR est lancé avec une voix de référence fixe, la valeur default peut être utilisée pour l’option voice. La voix réellement utilisée dépend alors du fichier WAV et de sa transcription chargés par le serveur.

Le nom du modèle exposé peut être vérifié avec la commande suivante :

curl http://IP_CRISPASR:7980/v1/models

Dans le fichier ~/.hermes/.env :

...
VOICE_TOOLS_OPENAI_KEY=local
...

La valeur local sert uniquement de clé fictive lorsque l’authentification n’est pas activée sur CrispASR. Hermes exige néanmoins qu’une clé soit définie pour utiliser le fournisseur OpenAI.

Speech-to-Text (STT)

# vi ~/.hermes/config.yaml

Configuration par défaut :

...
stt:
  enabled: true
  provider: local
  local:
    model: base
    language: 
  openai:
    model: whisper-1
  mistral:
    model: voxtral-mini-latest
  elevenlabs:
    model_id: scribe_v2
    language_code: 
    tag_audio_events: false
    diarize: false
...

Le Speech-to-Text permet de convertir les enregistrements vocaux en texte. Par défaut, Hermes utilise localement faster-whisper avec le modèle base. Cette solution est gratuite, ne nécessite aucune clé API et conserve les enregistrements sur la machine.

Lorsque le champ language reste vide, la langue est détectée automatiquement. Il est toutefois possible de préciser la langue afin de limiter les erreurs de détection, par exemple avec fr pour le français.

Le modèle base offre un bon compromis entre rapidité et consommation de ressources, mais il peut manquer de précision avec les noms propres, les nombres, les adresses IP ou les termes techniques. Il est alors possible d’utiliser un modèle local plus volumineux, par exemple small ou medium. Plus le modèle est grand, plus la transcription est généralement précise, mais plus elle demande de mémoire et de temps de traitement.

Exemple avec un modèle local plus précis configuré pour le français :

...
stt:
enabled: true
provider: local
local:
 model: small
 language: fr
...

Hermes peut également utiliser un service externe de reconnaissance vocale, par exemple OpenAI, Mistral ou ElevenLabs. Dans ce cas, il suffit de sélectionner le fournisseur souhaité avec l’option provider et de renseigner la clé API correspondante dans le fichier ~/.hermes/.env.

STT via CrispASR

Voir CrisASR

CrispASR expose une API compatible avec l’API audio d’OpenAI. Hermes doit donc utiliser le fournisseur openai pour envoyer les fichiers audio au serveur.

Dans le fichier ~/.hermes/config.yaml (exemple avec parakeet-tdt-0.6b-v3) :

...
stt:
  enabled: true
  provider: openai
  local:
    model: small
    language: 'fr'
  openai:
    model: parakeet-tdt-0.6b-v3-q8_0
...

Dans le fichier ~/.hermes/.env :

...
VOICE_TOOLS_OPENAI_KEY=local
STT_OPENAI_BASE_URL=http://IP_CRISPASR:7980/v1

La valeur local sert uniquement de clé fictive lorsque l’authentification n’est pas activée sur CrispASR. Hermes exige néanmoins qu’une clé soit définie pour utiliser le fournisseur OpenAI.

Après modification, on redémarre Hermes afin que la nouvelle configuration soit prise en compte.

Commandes

Lancer l’interface interactive :

# hermes

Choisir le modèle et le provider LLM :

# hermes model

Configurer les outils disponibles :

# hermes tools

Modifier une configuration spécifique :

# hermes config set

Démarrer le gateway (Telegram, Discord, etc.) :

# hermes gateway

Lancer le script de configuration complet :

# hermes setup

Migrer depuis OpenClaw :

# hermes claw migrate

Mettre à jour Hermes :

# hermes update

Diagnostiquer les problèmes :

# hermes doctor

Modules d’extension et d’intégration

Ressource :

Awesome Hermes Agent : liste de différentes extensions classé par catégorie.

Hermes Workspace

Un espace de travail complet : orchestrez vos agents, parcourez la mémoire, gérez les compétences et contrôlez l’ensemble depuis une interface unique.

Docker

Au moment d'écrire ce tutoriel l'accès au Dashboard et à la page MCP ne fonctionne plus avec la version officielle du conteneur, voir cette procédure pour le patcher.

# mkdir -p /opt/hermes-workspace
# vi /opt/hermes-workspace/docker-compose.yml

services:
  hermes-workspace:
    image: ghcr.io/outsourc-e/hermes-workspace:latest
    container_name: hermes-workspace
    restart: unless-stopped

    environment:
      #HERMES_HOME: /home/workspace/.hermes
      #HERMES_WORKSPACE_DIR: /workspace

      HERMES_API_URL: http:/IP_HERMES:8642
      HERMES_DASHBOARD_URL: http://IP_HERMES:9119

      HERMES_API_TOKEN: ""
      HERMES_PASSWORD: "change-moi"

      HERMES_DASHBOARD_BASIC_AUTH_USERNAME: "admin"
      HERMES_DASHBOARD_BASIC_AUTH_PASSWORD: "MOT_DE_PASSE_DASHBOARD"      

      HERMES_UID: 1000
      HERMES_GID: 1000

      COOKIE_SECURE: "0"

    volumes:
      - ./hermes-workspace-data:/home/workspace/.hermes

    ports:
      - "3000:3000"

COOKIE_SECURE=0 autorise l’utilisation du cookie de session de Hermes Workspace sur une connexion HTTP non chiffrée. Cette configuration convient uniquement à un réseau local de confiance ou protégé par VPN/firewall. Si Hermes Workspace est exposé en HTTPS, mettre COOKIE_SECURE=1.

# docker compose -f /opt/hermes-workspace/docker-compose.yml --project-directory /opt/hermes-workspace up -d

Exemple de vhost :

server {
    listen 80;
    listen [::]:80;
     server_name hermes.exemple.net;

    return 301 https://$host$request_uri;
}

server {
    server_name hermes.exemple.net;

    # protection
    add_header X-Content-Type-Options "nosniff" always;
    add_header X-Frame-Options "SAMEORIGIN" always;
    add_header Referrer-Policy "strict-origin-when-cross-origin" always;
    add_header Permissions-Policy "geolocation=(), microphone=(), camera=()" always;
    add_header Strict-Transport-Security "max-age=31536000" always;

    client_max_body_size 256m;

    location / {
        proxy_set_header Upgrade           $http_upgrade;
        proxy_set_header Connection        "upgrade";
        proxy_set_header Host              $host;
        proxy_set_header X-Real-IP         $remote_addr;
        proxy_set_header X-Forwarded-For   $proxy_add_x_forwarded_for;
        proxy_set_header X-Forwarded-Proto $scheme;
        proxy_set_header X-Forwarded-Host  $host;
        proxy_set_header X-Forwarded-Port  $server_port;

        proxy_http_version 1.1;
        proxy_read_timeout 3600;
        proxy_send_timeout 3600;

        proxy_pass http://IP_SERVEUR_HERMES:3000;

        # proxy_buffering off;
    }

    listen [::]:443 ssl; # managed by Certbot
    listen 443 ssl; # managed by Certbot

    ssl_certificate /etc/letsencrypt/live/hermes.exemple.net/fullchain.pem;
    ssl_certificate_key /etc/letsencrypt/live/hermes.exemple.net/privkey.pem;
    include /etc/letsencrypt/options-ssl-nginx.conf;
}

Penser a mettre COOKIE_SECURE=1 dans le fichier docker-compose.yml lorsque Hermes est accessible en HTTPS.

Fix Temporaire

On construit une version patché du conteneur :

# cd /opt/
# git clone https://github.com/outsourc-e/hermes-workspace.git
# cd hermes-workspace
# git fetch origin pull/758/head:pr-758
# git fetch origin pull/735/head:pr-735
# git checkout -b hermes-fixed origin/main
# git cherry-pick f7a50c5dcad8ba0f88e8d29e6f85c60b07681362
# git cherry-pick 36b7192
# docker build -t hermes-workspace:fixed .

Dans le fichier docker-compose.yml remplacer image: ghcr.io/outsourc-e/hermes-workspace:latest par image: hermes-workspace:fixed.

# docker compose -f /opt/hermes-workspace/docker-compose.yml --project-directory /opt/hermes-workspace up -d

Hermes Web Search Plus avec DonSeTch

Les opérations se déroulent directement sur l'hôte Hermes.

Il faut d’abord avoir installé une instance SearXNG.

On installe le plugin :

# cd ~/.hermes/plugins
# git clone https://github.com/robbyczgw-cla/hermes-web-search-plus.git web-search-plus

On choisit le preset self-hosted afin de ne pas dépendre de services extérieurs ou payants :

# python3 ~/.hermes/plugins/web-search-plus/setup.py setup --preset self-hosted

Entrer l'adresse de son instance SearXNG :

SearXNG key (SEARXNG_INSTANCE_URL, Enter to skip):

Il n'est pas obligatoire de renseigner une clé au prompt suivant :

Keenable key (KEENABLE_API_KEY, Enter to skip):

Si le service SearXNG est accessible via une adresse IP privée, il faut l'autoriser explicitement :

# vi ~/.hermes/.env

...
SEARXNG_INSTANCE_URL=http://IP_PRIVEE_SEARXNG:PORT
SEARXNG_ALLOW_PRIVATE=1
...

On teste ensuite le fonctionnement du plugin :

# cd ~/.hermes/plugins/web-search-plus
# python3 search.py --query "Hermes Agent latest release" --provider auto --quality-report

On installe DonSeTch :

# npm install -g --allow-scripts=donsetch,@google/genai,protobufjs donsetch

On installe Chromium :

# apt update && apt upgrade
# apt install chromium

On vérifie son fonctionnement :

# /root/.hermes/node/bin/donsetch --version
# /root/.hermes/node/bin/donsetch doctor

On ajoute le chemin du binaire DonSeTch dans l'environnement de Hermes :

# vi ~/.hermes/.env

...
DONSETCH_BIN=/root/.hermes/node/bin/donsetch
...

Le preset self-hosted limite par défaut le routage automatique à SearXNG et Keenable. On réinitialise donc la configuration afin de repasser sur le profil standard, puis on autorise Web Search Plus à utiliser DonSeTch en priorité :

# python3 ~/.hermes/plugins/web-search-plus/setup.py config reset --yes
# python3 ~/.hermes/plugins/web-search-plus/setup.py config set-routing on
# python3 ~/.hermes/plugins/web-search-plus/setup.py config set-auto-allow donsetch on
# python3 ~/.hermes/plugins/web-search-plus/setup.py config set-priority donsetch,searxng,keenable
# python3 ~/.hermes/plugins/web-search-plus/setup.py config set-extract-priority donsetch,keenable

On désactive les autres fournisseurs :

# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable brave
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable exa
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable firecrawl
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable linkup
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable octen
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable parallel
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable querit
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable serpbase
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable serper
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable tavily
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable tinyfish
# python3 ~/.hermes/plugins/web-search-plus/setup.py config disable you

On réapplique les priorités de recherche et d'extraction :

# python3 ~/.hermes/plugins/web-search-plus/setup.py config set-priority donsetch,searxng,keenable
# python3 ~/.hermes/plugins/web-search-plus/setup.py config set-extract-priority donsetch,keenable

On définit Keenable comme fournisseur de secours :

# python3 ~/.hermes/plugins/web-search-plus/setup.py config set-fallback keenable

Pour vérifier la configuration :

# python3 ~/.hermes/plugins/web-search-plus/setup.py config show --json

Enfin, on redémarre Hermes :

# systemctl restart hermes-gateway.service

(Optionnel) Création d'un provider Web pour remplacer de façon transparente les backends utilisés par les outils natifs web_search et web_extract de Hermes :

# mkdir -p ~/.hermes/plugins/web/wsp

On crée le fichier de métadonnées du plugin :

# vi ~/.hermes/plugins/web/wsp/plugin.yaml

name: web-wsp
version: 1.0.0
description: "Web Search Plus backend for Hermes native web_search/web_extract tools."
author: local
kind: backend
provides_web_providers:
  - wsp

On crée ensuite le provider Web. Celui-ci sert d'adaptateur entre les outils natifs de Hermes et Web Search Plus :

# vi ~/.hermes/plugins/web/wsp/__init__.py

from __future__ import annotations

import json
import subprocess
import sys
from pathlib import Path
from typing import Any, Dict, List

from agent.web_search_provider import WebSearchProvider


WSP_DIR = Path.home() / ".hermes" / "plugins" / "web-search-plus"
WSP_SEARCH = WSP_DIR / "search.py"


class WSPWebSearchProvider(WebSearchProvider):

    @property
    def name(self) -> str:
        return "wsp"

    @property
    def display_name(self) -> str:
        return "Web Search Plus"

    def is_available(self) -> bool:
        return WSP_SEARCH.exists()

    def supports_search(self) -> bool:
        return True

    def supports_extract(self) -> bool:
        return True

    def search(self, query: str, limit: int = 5) -> Dict[str, Any]:
        cmd = [
            sys.executable,
            str(WSP_SEARCH),
            "--query",
            query,
            "--provider",
            "auto",
            "--max-results",
            str(limit),
        ]

        try:
            proc = subprocess.run(
                cmd,
                cwd=str(WSP_DIR),
                capture_output=True,
                text=True,
                timeout=90,
                check=False,
            )
        except Exception as exc:
            return {
                "success": False,
                "error": f"Web Search Plus search failed: {exc}",
            }

        if proc.returncode != 0:
            return {
                "success": False,
                "error": proc.stderr.strip() or "Web Search Plus search failed",
            }

        try:
            data = json.loads(proc.stdout)
        except Exception as exc:
            return {
                "success": False,
                "error": f"Invalid Web Search Plus JSON: {exc}",
            }

        results = []

        for i, item in enumerate(data.get("results", [])[:limit], start=1):
            results.append(
                {
                    "title": str(item.get("title", "")),
                    "url": str(item.get("url", "")),
                    "description": str(
                        item.get("snippet")
                        or item.get("description")
                        or ""
                    ),
                    "position": i,
                }
            )

        return {
            "success": True,
            "data": {
                "web": results,
            },
        }

    def extract(
        self,
        urls: List[str],
        format: str = "markdown",
        **kwargs: Any,
    ) -> List[Dict[str, Any]]:

        cmd = [
            sys.executable,
            str(WSP_SEARCH),
            "--provider",
            "auto",
            "--extract-urls",
            *urls,
            "--format",
            format or "markdown",
        ]

        try:
            proc = subprocess.run(
                cmd,
                cwd=str(WSP_DIR),
                capture_output=True,
                text=True,
                timeout=90,
                check=False,
            )
        except Exception as exc:
            return [
                {
                    "url": url,
                    "title": "",
                    "content": "",
                    "error": f"Web Search Plus extraction failed: {exc}",
                }
                for url in urls
            ]

        if proc.returncode != 0:
            error = (
                proc.stderr.strip()
                or "Web Search Plus extraction failed"
            )

            return [
                {
                    "url": url,
                    "title": "",
                    "content": "",
                    "error": error,
                }
                for url in urls
            ]

        try:
            data = json.loads(proc.stdout)
        except Exception as exc:
            return [
                {
                    "url": url,
                    "title": "",
                    "content": "",
                    "error": f"Invalid Web Search Plus JSON: {exc}",
                }
                for url in urls
            ]

        if data.get("error") and not data.get("results"):
            return [
                {
                    "url": url,
                    "title": "",
                    "content": "",
                    "error": str(data["error"]),
                }
                for url in urls
            ]

        results = []

        for item in data.get("results", []):
            if not isinstance(item, dict):
                continue

            content = str(
                item.get("content")
                or item.get("markdown")
                or ""
            )

            results.append(
                {
                    "url": str(item.get("url", "")),
                    "title": str(item.get("title", "")),
                    "content": content,
                    "raw_content": str(
                        item.get("raw_content")
                        or content
                    ),
                    "metadata": {
                        "provider": data.get("provider"),
                        "fetcher": item.get("fetcher"),
                        "status": item.get("status"),
                        "quality": item.get("quality"),
                        "lang": item.get("lang"),
                        "source_type": item.get("source_type"),
                        "page_type": item.get("page_type"),
                    },
                }
            )

        return results


def register(ctx) -> None:
    ctx.register_web_search_provider(WSPWebSearchProvider())

Le provider lance Web Search Plus dans un sous-processus distinct pour les recherches comme pour les extractions. Cela évite notamment les conflits entre les modules Python de Hermes et ceux de Web Search Plus.

On active ensuite le plugin :

# hermes plugins enable web-wsp

Répondre yes à la demande d'autorisation :

This is a privileged capability: an override can intercept everything the agent routes
through that tool.
Grant it?

Cette autorisation est nécessaire car le plugin fournit un backend susceptible d'intercepter les appels effectués par les outils Web natifs de Hermes.

On édite ensuite la configuration de Hermes pour utiliser le nouveau provider :

# vi ~/.hermes/config.yaml

...
web:
  backend: wsp
  search_backend: wsp
  extract_backend: wsp
...

backend définit le backend Web général, tandis que search_backend et extract_backend permettent de sélectionner explicitement des backends différents pour la recherche et l'extraction.

Avec cette configuration, les outils natifs web_search et web_extract de Hermes restent inchangés pour le modèle, mais leurs appels sont transmis de façon transparente à Web Search Plus.

Si Firecrawl est déjà configuré, on peut également conserver Web Search Plus uniquement pour la recherche et utiliser Firecrawl comme backend d'extraction :

...
web:
  backend: wsp
  search_backend: wsp
  extract_backend: firecrawl
...

Dans ce cas, le routage est le suivant :

Hermes web_search → Web Search Plus → provider sélectionné automatiquement
Hermes web_extract → Firecrawl

Si l'instance Firecrawl utilisée est auto-hébergée, cette configuration permet notamment de conserver l'extraction des pages en local.

Enfin, on redémarre Hermes :

# systemctl restart hermes-gateway.service

Mise à jour

Hermes Web Search Plus

# hermes plugins update web-search-plus

Le scanner de sécurité de Hermes peut désactiver le plugin après la mise à jour si celui-ci obtient un verdict dangerous. Si le plugin est de nouveau désactivé, le réactiver manuellement :

# hermes plugins enable web-search-plus

Répondre yes si demande d'autorisation :

This is a privileged capability: an override can intercept everything the agent routes
through that tool.
Grant it?

Puis redémarrer Hermes :

# systemctl restart hermes-gateway.service

DonSeTch :

# npm install -g --allow-scripts=donsetch,@google/genai,protobufjs donsetch@latest

On vérifie ensuite la version et le bon fonctionnement de DonSeTch :

# /root/.hermes/node/bin/donsetch --version
# /root/.hermes/node/bin/donsetch doctor

Mnemosyne

MCP

MCP pour remplacer les outils web natifs de Hermes

Expérimental et non recommandé. Après de nombreux essais, l'utilisation de serveurs MCP pour remplacer des outils natifs destinés à des tâches basiques, comme la recherche web, complexifie fortement l'architecture de Hermes au quotidien.

Utiliser des serveurs MCP pour remplacer les outils web natifs de Hermes augmente fortement le nombre d'outils disponibles, ce qui peut rendre leur gestion plus complexe pour les LLM.

Désactiver Tool Search

Hermes utilise Tool Search pour éviter d'envoyer au modèle la description complète de tous les outils disponibles à chaque requête.

Lorsque Tool Search est activé, Hermes conserve directement dans le contexte les outils principaux, tandis qu'une partie des outils supplémentaires — notamment ceux provenant des serveurs MCP et de certains plugins — est placée dans une liste d'outils différés.

Le modèle doit alors retrouver l'outil dont il a besoin à l'aide de mécanismes comme :

tool_search
tool_describe
tool_call

Cela permet de réduire la taille du prompt lorsque des dizaines ou des centaines d'outils sont disponibles.

Lorsque les outils web natifs de Hermes sont remplacés par des serveurs MCP, les outils de recherche web et de navigation peuvent eux-mêmes devenir des outils différés. Le modèle doit alors commencer par les rechercher ou en demander la description avant de pouvoir les utiliser.

Dans :

# vi ~/.hermes/config.yaml

Ajouter ou modifier :

tools:
  tool_search:
    enabled: off

Puis redémarrer Hermes :

# systemctl restart hermes-gateway.service

MCP-SearXNG

Depuis la version 0.7, SearXNG est pris en charge nativement par Hermes Agent pour les recherches web classiques. Un serveur MCP dédié n’est donc plus indispensable dans ce cas. En revanche, le MCP SearXNG reste utile pour accéder aux catégories spécialisées telles que les images, les vidéos ou d’autres paramètres avancés qui ne sont pas encore pleinement exposés par l’intégration native. Voir configuration native SearXNG

# vi ~/.hermes/config.yaml

On inscrit le serveur MCP SearXNG (créer la section mcp_servers si absente) :

...
mcp_servers:
  searxng:
    url: http://IP_MCP:3000/mcp
...

La section mcp_servers doit être au niveau racine (tout à gauche). Vérifier également que le port correspond bien à celui exposé par le conteneur MCP SearXNG.

On redémarre le service :

# systemctl restart hermes-gateway.service

Ou depuis Hermes :

/reload-mcp

Test :

# hermes mcp list
# hermes mcp test searxng

Le serveur ihor-sokoliuk/mcp-searxng expose notamment les outils suivants :

searxng_web_search
searxng_search_suggestions
searxng_instance_info
web_url_read

Prompt système recommandé (voir Éditer le prompt système) :

...
TOOLS:
- For current, recent, upcoming, time-sensitive, location-specific, or uncertain factual questions, use searxng_web_search.
- To read a specific URL, use web_url_read.
- For search suggestions, use searxng_search_suggestions.
- For SearXNG instance capabilities, categories, engines, locales, and plugins, use searxng_instance_info.
- For system tasks, use terminal.

RULES:
- Respond in the same language as the user.
- Do not invent tool results.
- If a tool fails, say so explicitly.
- Do not promise to continue later, follow up later, or say that results are still coming.
- When the user asks multiple questions, use the tools needed, then answer all requested items in one final structured response.
- Never answer current, recent, upcoming, time-sensitive, location-specific, or uncertain factual questions without using the required tool first.
- This includes weather, news, prices, schedules, releases, availability, rankings, versions, and other facts that may have changed.
- If no tool result is available, say you cannot verify and do not guess.
- Use search categories when relevant.
- For image searches, use searxng_web_search with categories=images.
- For video searches, use searxng_web_search with categories=videos.
- For image search results, use the `img_src` field as the direct image URL.
- When displaying an image result, ALWAYS output the direct image URL exactly in this format: ![](URL)
- Do not output the image URL as a normal Markdown link.
- For video results, output links in this format: 🎬 [Titre de la vidéo](URL)
- Do not use tools for simple rewriting, translation, or opinion unless needed.

Recommandation :

Il est recommandé de désactiver le service natif correspondant :

# hermes tools

Décocher pour les environnements concernés :

🔍 Web Search & Scraping  (web_search, web_extract)  [no API key]

Skill pour aider la recherche et l'affichage d'images

Dans SOUL.md on remplace :

- For image searches, use searxng_web_search with categories=images.
- For image search results, use the `img_src` field as the direct image URL.
- When displaying an image result, ALWAYS output the direct image URL exactly in this format: ![](URL)
- Do not output the image URL as a normal Markdown link.

Par :

- For any image or photo search, ALWAYS load and follow the `searxng-photo` skill before using any search, browser, or web tool.

Puis on crée le skill :

# mkdir -p ~/.hermes/skills/searxng-photo
# vi ~/.hermes/skills/searxng-photo/SKILL.md

---
name: searxng-photo
description: Find and display an image using the SearXNG MCP image search tool.
---

Use this skill when asked to find, show, or search for an image or photo.

Steps:

1. Call `mcp__searxng__searxng_web_search` with:
   - `query`: a concise image search query
   - `categories`: `"images"`
   - `num_results`: `5`
   - `response_format`: `"json"`

2. Select a relevant result containing `img_src`.

3. For each selected image result, output its direct `img_src` URL using this exact Markdown format:

![](DIRECT_IMAGE_URL)

Replace `DIRECT_IMAGE_URL` with the exact value of the result's `img_src` field.

Rules:

- `categories` must be the string `"images"`, not an array.
- Use `num_results`, not `max_results`.
- Use the exact returned `img_src`.
- Once a usable `img_src` is found, do not call another tool.
- If no usable `img_src` is found, retry once with a better query.
- Do not output the image URL as a normal link.

Enfin on redémarre Hermes :

# systemctl restart hermes-gateway.service

MCP-CamoFox

On inscrit le serveur MCP CamoFox (créer la section mcp_servers si absente) :

...
mcp_servers:
  camofox:
    url: http://IP_MCP:3000/mcp
    headers:
     Authorization: Bearer UNE_CLE_ALEATOIRE_DE_32_CARACTERES_MINIMUM
...

La section mcp_servers doit être au niveau racine (tout à gauche).

On redémarre le service :

# systemctl restart hermes-gateway.service

Ou depuis Hermes :

/reload-mcp

Test :

# hermes mcp list
# hermes mcp test camofox

Prompt système recommandé (avec le MCP-SearXNG) (voir Éditer le prompt système) :

...
TOOLS:
- For browser navigation, clicking, typing, page interaction, snapshots, screenshots, or rendered page inspection, use the Camofox MCP tools.
- Do not use Camofox web_search for general web searches; use searxng_web_search instead.
...
RULES:
- Do not use memory for ordinary factual lookups, web searches, image searches, or one-off questions unless the user explicitly asks to remember or recall something.
- Do not search local files for ordinary factual or web questions unless the user explicitly asks about local files or documents.

Recommandation :

Il est recommandé de désactiver le service natif correspondant :

# hermes tools

Décocher pour les environnements concernés :

[ ] 🌐 Browser Automation  (navigate, click, type, scroll)

Désactiver les outils web natifs de Hermes

Afin d'être sûr qu'Hermes n'expose plus ses outils web natifs aux modèles, il faut modifier la section platform_toolsets :

# vi ~/.hermes/config.yaml

On supprime les occurrences de web et browser dans les sections souhaitées.

Il faut également éviter les toolsets composites susceptibles de les réintroduire, comme hermes_cli, et définir explicitement les outils souhaités.

Pour les requêtes effectuées via l'API Hermes, notamment depuis OpenWebUI, on crée également une section api_server.

Exemple :

...
platform_toolsets:
  cli:
    - clarify
    - code_execution
    - computer_use
    - cronjob
    - delegation
    - file
    - image_gen
    - mcp
    - memory
    - messaging
    - session_search
    - skills
    - terminal
    - todo
    - tts
    - vision

  telegram:
    - hermes-telegram

  discord:
    - clarify
    - code_execution
    - computer_use
    - cronjob
    - delegation
    - file
    - image_gen
    - mcp
    - memory
    - session_search
    - skills
    - terminal
    - todo
    - tts
    - vision

  api_server:
    - clarify
    - code_execution
    - computer_use
    - context_engine
    - cronjob
    - delegation
    - discord
    - discord_admin
    - file
    - homeassistant
    - image_gen
    - mcp
    - memory
    - session_search
    - skills
    - spotify
    - stt
    - terminal
    - todo
    - tts
    - video
    - video_gen
    - vision
    - x_search
    - yuanbao
...

La liste ci-dessus est un exemple. Conserver uniquement les outils réellement utilisés. Le point important est de ne pas inclure web, browser ni un toolset composite susceptible de les réintroduire, tout en conservant mcp si les serveurs MCP doivent rester accessibles.

Enfin on redémarre Hermes :

# systemctl restart hermes-gateway.service

RAGFlow

# vi ~/.hermes/config.yaml

On inscrit le serveur MCP RAGFlow (créer la section mcp_servers si absente) :

...
mcp_servers:
  ragflow:
    url: http://IP_MCP:9382/mcp
...

La section mcp_servers doit être au niveau racine (tout à gauche).

On redémarre le service :

# systemctl restart hermes-gateway.service

Ou depuis Hermes :

/reload-mcp

Test :

# hermes mcp list
# hermes mcp test ragflow

Prompt système recommandé :

 TOOLS:
 - For indexed documents, internal documentation, knowledge bases, or when the user asks to check the docs, use the RAGFlow MCP tools: ragflow_retrieval, ragflow_list_datasets, and ragflow_list_chats.

 RULES:
 - Do not use terminal/curl to query RAGFlow unless explicitly asked for a network diagnostic.
 - If no RAGFlow dataset exists or no relevant result is found, say so clearly.

Rerank

Il faut d’abord identifier l’identifiant complet du modèle de reranking.

Dans cet exemple, l’identifiant est :

/opt/models/jina-reranker-v3/Q8_0/jina-reranker-v3-Q8_0.gguf@Serveur Rerank@OpenAI-API-Compatible

Il faut ensuite créer un skill Hermes afin de demander l’utilisation systématique du reranker lors des appels à ragflow_retrieval.

Créer le dossier du skill :

# mkdir -p ~/.hermes/skills/ragflow-search

Créer le fichier principal du skill :

# vi ~/.hermes/skills/ragflow-search/SKILL.md

Y placer le contenu suivant :

---
name: ragflow-search
description: Use this skill whenever querying RAGFlow datasets through the `ragflow_retrieval` MCP tool. Always include the configured reranker.
version: 1.0.0
---

# RAGFlow Search

Use this skill for every call to the `ragflow_retrieval` MCP tool.

## Tool

Call the MCP tool:

`ragflow_retrieval`

Do not use a generic web search when the requested information is expected to be present in RAGFlow.

## Mandatory reranker

For every call to `ragflow_retrieval`, always include this exact argument:

```yaml
rerank_id: "/opt/models/jina-reranker-v3/Q8_0/jina-reranker-v3-Q8_0.gguf@Serveur Rerank@OpenAI-API-Compatible"
```

Do not omit, shorten, rename, translate, or modify this value.

## Dataset selection

- Use `ragflow_list_datasets` when the relevant dataset ID is unknown.
- Prefer selecting only the datasets relevant to the question.
- Do not invent dataset IDs.
- Omit `dataset_ids` only when searching across all datasets is appropriate.

## Recommended retrieval parameters

Use these defaults unless the task requires otherwise:

```yaml
page: 1
page_size: 10
top_k: 30
similarity_threshold: 0.2
vector_similarity_weight: 0.3
keyword: false
```

## Verification

Do not claim that reranking was used unless `rerank_id` was actually included in the tool call.

If `ragflow_retrieval` is called without `rerank_id`, treat the call as invalid and retry it with the exact configured value.

Une fois le fichier enregistré, démarrer une nouvelle session Hermes afin que le skill soit détecté.