Système de mémoire de l'agent Hermes

La capacité différenciante essentielle d'Hermes n'est pas l'appel d'outils, mais plutôt sa capacité àSe souvenir vraiment de vous。

La plupart des outils d'IA repartent de zéro à chaque conversation—vous passez une heure aujourd'hui à lui apprendre la structure de votre projet, vos conventions de nommage et votre processus de déploiement, et demain, quand vous démarrez une nouvelle session, tout est réinitialisé.

Ce chapitre analyse en profondeur comment Hermes résout ce problème grâce à une structure de mémoire à trois niveaux, et comment l'Agent gère la mémoire de manière autonome, permettant la recherche et le rappel entre les sessions.


Architecture de mémoire à trois niveaux

Hermes utilise une architecture de mémoire à trois couches, composée de couches mutuellement indépendantes et fonctionnellement complémentaires, pour stocker et rappeler les informations.

Philosophie de conception fondamentale de l'architecture à trois niveaux :Les informations importantes à haute fréquence restent dans le contexte, les informations historiques à basse fréquence sont rappelées à la demande, et les schémas profonds sont automatiquement inférés par l'IA.—trouvant un équilibre entre la capacité de mémoire et le coût des tokens.

┌─────────────────────────────────────────────────┐
│       第一层:持久记忆(Persistent Memory)        │
│  MEMORY.md(环境事实)+ USER.md(用户画像)          │
│  → 每次会话启动时自动注入系统提示词,始终可见          │
├─────────────────────────────────────────────────┤
│       第二层:情节日志(Session History)            │
│  SQLite + FTS5 全文检索,存储所有历史对话             │
│  → Agent 主动搜索时按需加载,不占用固定 Token         │
├─────────────────────────────────────────────────┤
│       第三层:用户建模(Honcho,可选)               │
│  辩证推理引擎,提取跨会话模式、偏好与目标              │
│  → 比你亲口说出来的更深层地理解你                     │
└─────────────────────────────────────────────────┘
Hiérarchie de mémoireEmplacement de stockageCapacitéMéthode de chargementObjectif
Mémoire persistanteFichiers Markdown sous ~/.hermes/memories/~1,300 tokens au totalAutomatiquement injecté dans le prompt système au démarrage de la sessionFaits clés, toujours visibles
Journal d'histoiresBase de données SQLite + fichiers de transcription JSONLIllimité (toutes les conversations historiques)L'agent recherche à la demande, recherche en texte intégral FTS5Trouver des discussions historiques spécifiques
Modélisation utilisateur HonchoAPI côté serveur HonchoIsolé par agentInjection d'inférence en arrière-plan par tour / tous les N toursDéduit automatiquement les préférences et objectifs profonds

Les trois couches ne sont pas des substituts mais des compléments. La mémoire persistante répond à « J'ai toujours besoin de savoir ceci », l'historique de session répond à « Avons-nous discuté de cela la semaine dernière », et Honcho répond à « Que veux-tu vraiment ».


Fichier de mémoire persistante

La mémoire persistante est la première et la plus fondamentale des couches du système de mémoire Hermes.

Elle est stockée dans deux~/.hermes/memories/Composée de fichiers Markdown sous, automatiquement injectée dans le prompt système au début de chaque session.

Deux fichiers principaux

Les deux fichiers ont chacun leur propre rôle et ne se chevauchent pas.

FichierObjectifLimite de caractèresapproximativement égal à
MEMORY.mdLes notes personnelles de l'Agent—faits sur l'environnement, conventions de projet, choses apprises sur le terrain2,200 caractères~800 tokens
USER.mdProfil utilisateur—vos préférences, style de communication, habitudes de travail, niveau de compétence1,375 caractères~500 tokens

La limite de caractères est intentionnelle—elle garantit que le contenu de la mémoire reste concis et ciblé. Si une nouvelle entrée dépasse la limite, l'outil de mémoire renvoie une erreur invitant l'Agent à libérer de l'espace avant d'écrire, plutôt que de supprimer silencieusement les anciennes entrées.

Comment la mémoire est injectée dans le prompt système

Au début de chaque session, le contenu des deux fichiers est injecté dans le prompt système selon un format fixe, comme suit :

══════════════════════════════════════════════
MEMORY(Agent 个人笔记)[67% — 1,474/2,200 字符]
══════════════════════════════════════════════
用户的项目是位于 ~/code/myapi 的 Rust Web 服务,使用 Axum + SQLx
§
本机运行 Ubuntu 22.04,已安装 Docker 和 Podman
§
用户偏好简洁回复,不喜欢冗长解释

Voici quelques détails de conception clés :

Mode Instantané Gelé: Le contenu de la mémoire dans le prompt système est capturé une fois au début de la session et n'est pas mis à jour en cours de session.

Il s'agit d'une conception délibérée—pour maintenir la validité du cache de préfixe du LLM (Prompt Cache) et réduire le coût en tokens.

Lorsque l'Agent modifie la mémoire pendant une session, les modifications sont écrites immédiatement sur le disque, mais doivent attendreLancement à la prochaine sessionCe n'est qu'alors qu'elles apparaîtront dans le contexte.

Pourcentage d’utilisation visible:[67% — 1,474/2,200]Garde l’Agent conscient de la capacité restante à tout moment, afin qu’il puisse se réorganiser proactivement lorsqu’il approche de la limite.

§ comme séparateur d’éléments: chaque entrée de mémoire est séparée par §, et les entrées elles-mêmes peuvent être du texte multiligne.

Comment l’Agent gère la mémoire

L’Agent utilise desmemoryoutils intégrés pour gérer la mémoire, prenant en charge trois opérations.

OpérationDescriptionParamètre
ajoutezAjouter une nouvelle entrée de mémoiretarget(memory/user)、content
remplacementRemplacer une entrée existante (localisée par correspondance de sous-chaîne)target、old_text、content
supprimerSupprimer une entrée existante (localisée par correspondance de sous-chaîne)target、old_text

Remarque :Aucune opération de lecture—le contenu de la mémoire est déjà injecté dans le prompt système au démarrage de la session, donc l’Agent le voit directement dans le contexte sans avoir besoin de lectures supplémentaires.

replaceetremoveUtilisationCorrespondance par sous-chaînePour localiser une entrée, vous n’avez pas besoin de fournir le texte complet de l’entrée :

Exemple

# Scénario : la mémoire actuelle contient "L’utilisateur préfère le thème sombre pour tous les éditeurs"
# Doit maintenant être mise à jour vers une version plus précise
# Utilisez la correspondance par sous-chaîne pour localiser — fournissez simplement un extrait identifiable de manière unique

memory(
    action="replace",
    target="memory",
    old_text="Dark Theme",  # Une sous-chaîne unique suffit pour localiser l’entrée d’origine.
    content="VS Code de l’utilisateur utilise le thème clair, le terminal utilise le thème sombre"  # Nouveau contenu après remplacement
)

Si la sous-chaîne correspond à plusieurs entrées, l’outil renvoie une erreur demandant une chaîne de correspondance plus précise.


Ce qu’il faut mémoriser, ce qu’il ne faut pas mémoriser

L’Agent détermine et enregistre automatiquement les informations précieuses—vous n’avez généralement pas besoin de le demander explicitement.

Mais comprendre les critères vous aide à comprendre le comportement de l'Agent et à le guider manuellement lorsque c'est nécessaire.

Doit être sauvegardé de manière proactive en mémoire (environnement et travail)

Les types d'informations suivants amènent l'Agent à écrire dans MEMORY.md :

TypeExemple
Faits environnementauxCette machine exécute Debian 12, PostgreSQL 16, avec Docker remplacé par Podman
Spécification du projet~/code/api Utilisation Go 1.22,sqlc query,chi Routing;Tests : utilisez make test
Expérience des outilsLe port SSH du serveur de staging est 2222, pas 22 ; la clé se trouve dans ~/.ssh/staging_ed25519
Enregistrement des correctionsNe pas exécuter les commandes Docker avec sudo ; l'utilisateur est déjà dans le groupe docker
Travail terminé2026-01-15 Migration de la base de données de MySQL vers PostgreSQL terminée

Doit être proactivement enregistré pour l'utilisateur (à propos de vous)

Les types d'informations suivants amènent l'Agent à écrire dans USER.md :

TypeExemple
Informations d'identitéNom, intitulé du poste, fuseau horaire
Préférences de communicationPréfère des réponses concises, pas besoin d'expliquer les étapes évidentes
élément non appréciéNe pas ajouter de commentaires excessifs dans le code
Habitudes de travailNe pas vérifier les messages avant 3 PM chaque jour
Niveau de compétenceFamilier avec Rust et Python, Go est nouvellement appris

Contenu qui ne devrait pas être enregistré

Le contenu suivant ne mérite pas de précieux espace mémoire :

TypeExempleRaison
Trop généralL'utilisateur a un projetAucune valeur informative, ne peut pas être réutilisé
Peut être revérifié à tout momentPython 3.12 prend en charge les f-strings imbriquéesIl suffit de rechercher ; cela ne vaut pas la peine d'occuper de l'espace
Données brutesSegments de journal volumineux, blocs de code, tableaux de donnéesDépasse la limite de caractères ; une mémoire structurée est plus utile
Contenu temporaireChemins de fichiers temporaires pour cette session de débogageInutilisable la prochaine fois
Contenu déjà dans le contexteInformations déjà présentes dans le projet SOUL.md, AGENTS.mdUne injection répétée gaspille des tokens

Bonne mémoire vs mauvaise mémoire

La même information, bien écrite, peut valoir dix entrées ; mal écrite, elle ne vaut rien.

ÉvaluationExempleRévision
OKUtilisateur de macOS 14 Sonoma, Homebrew, Docker Desktop, Shell : oui avec oh-my-zsh de zsh, Éditeur : oui VS Code + Vim KeybitsForte densité d'informations ; les faits liés sont regroupés
OKProjet ~/code/api Utilise Go 1.22, sqlc pour les requêtes DB, routeur chi. Test : make test. CI : GitHub ActionsRègles spécifiques actionnables
OKServeur de staging(10.0.1.50)port SSH 2222 et non 22, clé privée ~/.ssh/staging_ed25519Leçons contextuelles apprises, éviter les pièges
MédiocreLes utilisateurs ont des projetsTrop vague, ne peut guider aucune action
MédiocreLe 5 janvier 2026, l'utilisateur m'a demandé de regarder son projet dans ~/code/api, et j'ai découvert qu'il utilise Go 1.22...Trop verbeux ; l'information essentielle est noyée dans le récit

Gestion de la capacité de mémoire

Les fichiers de mémoire ont une limite stricte de caractères ; l'Agent doit organiser de manière proactive lorsqu'il approche de la limite.

Que se passe-t-il lorsqu'on approche de la limite

Lorsqu'une nouvelle entrée entraînerait le dépassement de la limite de caractères, l'outil renvoie une erreur au lieu de tronquer silencieusement :

{
  "success": false,
  "error": "Memory 已用 2,100/2,200 字符。新条目(250 字符)会超出上限。
            请先整理:用 replace 合并重叠条目,或 remove 过时条目,
            再重试——在同一轮对话中完成。",
  "current_entries": [
    "用户的 macOS 14 Sonoma,Homebrew,Docker Desktop",
    "项目 ~/code/api 使用 Go 1.22,sqlc 做 DB 查询"
  ],
  "usage": "2,100/2,200"
}

À la réception de cette erreur, l'approche correcte de l'Agent est :

  1. Lire toutes les entrées actuelles (déjà incluses dans la réponse d'erreur)
  2. Trouver les entrées qui peuvent être supprimées ou fusionnées
  3. usereplaceFusionner plusieurs entrées connexes en une version plus affinée
  4. Réessayez ensuite d'ajouter la nouvelle entrée

Bonne pratique : lorsque le prompt système affiche une utilisation de la mémoire supérieure à 80 %, organisez de manière proactive—n'attendez pas qu'une erreur survienne. La prévention permet toujours d'économiser plus de tokens que la remédiation.

Référence de capacité

StockageLimite supérieureNombre typique d'entrées
MEMORY.md2,200 caractères8–15 éléments
USER.md1,375 caractères5–10 éléments

Contrôler les autorisations d'écriture dans la mémoire

Par défaut, l'Agent peut écrire librement dans la mémoire—y comprisRevue d'auto-amélioration déclenchée automatiquement en arrière-plan(S'exécute en arrière-plan après la fin d'un tour de conversation, en distillant la mémoire et les compétences.)

Si vous souhaitez examiner le contenu avant que quoi que ce soit ne soit écrit dans la mémoire, vous pouvez activer l'approbation d'écriture.

Activer l'approbation d'écriture

Il suffit de le définir dans le fichier de configuration :

Exemple

# Chemin du fichier : ~/.hermes/config.yaml
# Activer l’approbation des écritures en mémoire — toutes les opérations d’écriture nécessitent une approbation manuelle
memory
:
  write_approval
: true   # Par défaut false (écriture libre)

Changements de comportement après activation :

ScénariosComportement
Lorsque l’Agent souhaite écrire en mémoire lors d’une interaction en CLIInvite intégrée dans le terminal demandant votre approbation
Plateforme de messagerie / revue automatique en arrière-planLes écritures sont préparées, en attente de votre approbation manuelle

Commandes de gestion des approbations

Utilisez les commandes slash suivantes pour gérer les écritures en mémoire en attente :

Exemple

# Afficher les écritures en mémoire en attente (étiquette déclenchée automatiquement [auto])
/memory pending

# Approuver les écritures pour l’ID spécifié, ou tout approuver.
/memory approve <id>
/memory approve all

# Rejeter les écritures pour l’ID spécifié, ou tout rejeter.
/memory reject <id>
/memory reject all

# Activer ou désactiver l’approbation à l’exécution (le paramètre persiste)
/memory approval on
/memory approval off

Cas d’utilisation : si l’Agent a enregistré une hypothèse incorrecte à votre sujet, ou si vous voulez un contrôle total sur le contenu de la mémoire, activer write_approval est l’approche la plus directe.

À propos de la revue d’auto-amélioration en arrière-plan

Après chaque tour de conversation, Hermes exécute en arrière-plan une revue d’auto-amélioration (revue en arrière-plan), analysant la conversation et distillant les souvenirs ou compétences qui valent la peine d’être conservés.

Par défaut, une ligne de notification est affichée dans le chatMemory updated。

Vous pouvez ajuster le niveau de détail des notifications :

Exemple

# Chemin du fichier : ~/.hermes/config.yaml
# Contrôle le niveau de détail des notifications de l'examen en arrière-plan
display
:
  memory_notifications
: on      # off | on (par défaut) | verbose
ValeurEffet
offAucune notification affichée, mais l'examen s'exécute toujours et écrit toujours
on (par défaut)Invites courtes, telles que "Mémoire mise à jour"
verboseInclut un aperçu des modifications, comme Mémoire + L'utilisateur préfère des réponses concises

Si votre modèle principal est coûteux, vous pouvez exécuter les examens en arrière-plan sur un modèle moins cher :

Exemple

# Chemin du fichier : ~/.hermes/config.yaml
# L'examen en arrière-plan utilise un modèle indépendant pour réduire les coûts
auxiliaire
:
  background_review
:
    fournisseur
: openrouter
    modèle
: google/gemini-3-flash-preview   # Auto par défaut = modèle principal

Répertoire des épisodes et recherche inter-sessions

La deuxième couche de mémoire—Historique des sessions—stocke des enregistrements complets de toutes les conversations historiques, prenant en charge la recherche en texte intégral et le rappel à la demande.

Toutes les conversations sont automatiquement enregistrées

Chaque session—qu'elle provienne de la CLI, de Telegram, de Discord ou de toute autre plateforme—est automatiquement enregistrée à deux endroits :

Emplacement de stockageFormatagecontent
~/.hermes/state.dbBase de données SQLite + index en texte intégral FTS5Métadonnées structurées, historique complet des messages (y compris les appels d'outils et les résultats), utilisation des jetons, horodatages
~/.hermes/sessions/Fichiers de transcription JSONLTranscriptions brutes de conversations, y compris les enregistrements d'invocation d'outils

outil session_search

Agent intégrésession_searchUn outil qui peut effectuer une recherche en texte intégral dans toutes les conversations historiques.

L'ensemble du processus ne nécessite aucune implication de LLM dans la phase de recherche ; elle est effectuée directement par le moteur SQLite FTS5 :

Flux de travail :

  1. FTS5 récupère les messages correspondants triés par pertinence
  2. Regroupés par session, en prenant les sessions les plus pertinentes (3 par défaut)
  3. Charge la conversation de chaque session, en capturant environ 100,000 caractères autour du point de correspondance
  4. Un modèle de synthèse léger génère des résumés ciblés
  5. Renvoie le résumé et le contexte de chaque session à l'Agent

Syntaxe de recherche prise en charge (standard FTS5) :

SyntaxeExempleDescription
Récupération par mots-clésdéploiement dockerCorrespond aux messages contenant n'importe quel mot-clé
Correspondance de phrase"phrase exacte"Correspondance exacte pour la phrase entière
OR booléendocker OR kubernetesCorrespond à n'importe quel mot-clé
NOT booléenpython NOT javaExclure des mots-clés spécifiques
Joker de préfixedeploy*Correspond aux mots commençant par « deploy »

Moment de déclenchement : l'Agent appelle automatiquement session_search lorsque vous mentionnez « ce dont nous avons discuté la dernière fois... » ou « cette proposition précédente... », au lieu de vous faire répéter l'explication.

session_search vs mémoire persistante

Les deux sont complémentaires, et non dans une relation de remplacement :

Dimension de comparaisonMémoire persistante (MEMORY.md / USER.md)Journal d'événements (Session Search)
Capacité~1,300 tokens au totalIllimité (toutes les conversations historiques)
VitesseImmédiat (déjà dans le prompt système)~20ms (requête FTS5)
Coût en tokensConsommation fixe par sessionÀ la demande ; pas de requête, pas de coût
ObjectifFaits clés, toujours visiblesTrouver des discussions historiques spécifiques
Style de gestionL’agent organise de manière proactiveEntièrement automatisé, aucune intervention nécessaire

MémoireUtilisée pour « J’ai toujours besoin de savoir ceci » — faits sur l’environnement, préférences utilisateur, conventions de projet.

Journal des discussionsUtilisé pour « Avons-nous parlé de cela la semaine dernière ? » — retrouver des discussions historiques spécifiques.


Gestion des sessions

Chaque session de l’historique des sessions peut être nommée, reprise, exportée et nettoyée.

Nommage et récupération

Hermes génère automatiquement un titre de session court (3–7 mots) après le premier tour de conversation, en s’exécutant de manière asynchrone en arrière-plan sans affecter la vitesse de réponse.

Vous pouvez également le nommer manuellement :

Exemple

# Définir manuellement le titre dans la session
/title refactor authentication module

Après le nommage, les sessions peuvent être reprises directement par leur titre :

Exemple

# Restaurer la session par titre
hermes -c Refactoriser le module d'authentification

# Restaurer la session la plus récente
hermes --continue

# Restaurer par ID de session
hermes -r <session_id>

Auto-Lineage: lorsqu'une session subit une compaction de contexte, Hermes crée et numérote automatiquement les sessions de continuation :

"我的项目" → "我的项目 #2" → "我的项目 #3"

Lors de la reprise par titre, la session de continuation la plus récente est automatiquement sélectionnée.

Commandes courantes de gestion de sessions

Exemple

# Lister les 20 sessions les plus récentes
hermes sessions list

# Filtrer par plateforme source
hermes sessions list --source telegram

# Afficher plus d'entrées
hermes sessions list --limit 50

# Renommer la session spécifiée
hermes sessions rename <id> "Nouveau titre"

# Exporter toutes les sessions vers un fichier
hermes sessions export backup.jsonl

# Supprimer la session spécifiée
hermes sessions delete <id>

# Nettoyer les sessions de plus de 30 jours
hermes sessions prune --older-than 30

# Afficher les statistiques
hermes sessions stats

hermes sessions listExemple de sortie :

标题                 预览                               最近活跃    ID
────────────────────────────────────────────────────────────────────
重构认证模块          帮我重构认证模块的代码                2 小时前   20260305_09...
我的项目 #3          检查一下测试失败的原因                昨天        20260304_14...
—                   Python 装饰器怎么用                  3 天前      20260303_10...

Nettoyage automatique des sessions (facultatif)

Par défaut, l'historique des sessions est conservé de manière permanente (car il fournit des données pour session_search).

Si un nettoyage automatique est nécessaire, activez-le dans la configuration :

Exemple

# Chemin du fichier : ~/.hermes/config.yaml
# Activer le nettoyage automatique des conversations (désactivé par défaut)
sessions
:
  auto_prune
: true        # false par défaut
  retention_days
: 90      # Conserver les 90 derniers jours
  vacuum_after_prune
: true
  min_interval_hours
: 24

Modélisation utilisateur Honcho

Honcho est un backend de mémoire natif pour l'IA développé par Plastic Labs, intégré dans Hermes en tant que plugin.

Il ne remplace pas MEMORY.md et USER.md, mais s'appuie plutôt sur euxAjouter une couche de raisonnement dialectique—en analysant vos schémas de conversation, il déduit automatiquement les préférences, objectifs et habitudes que vous n'avez pas exprimés explicitement.

Contrairement à la gestion manuelle de MEMORY.md, Honcho est entièrement automatique : après chaque tour de conversation (fréquence configurable), il raisonne en arrière-plan, accumulant une compréhension plus profonde de vous.

Honcho vs. mémoire intégrée

CompétencesMémoire intégréeHoncho
Persistance entre sessionsFichiers locauxAPI côté serveur
Profil utilisateurGéré manuellement (USER.md)Raisonnement dialectique automatique
Résumé de session—Injection de contexte au niveau de la session
Isolation multi-agent—Modélisé séparément pour chaque agent
Recherche sémantiqueTexte intégral FTS5D'après les conclusions du raisonnement

Injection de contexte à deux couches

À chaque tour de conversation, Honcho assemble deux couches de contexte injectées dans le prompt système :

Couche de base (Contexte de base): résumé de session + caractérisation de l'utilisateur + Peer Card de l'utilisateur + auto-caractérisation de l'IA. Actualisée selon contextCadence (tous les N tours). C'est la couche « qui est cet utilisateur ».

Couche dialectique (Supplément dialectique): Générée en temps réel par le moteur LLM de Honcho, en se concentrant sur « ce qui est le plus pertinent maintenant ». Actualisée selon dialecticCadence.

Deux modes de démarrage pour le raisonnement dialectique :

ModeConditionsMéthode d'interrogation
Démarrage à froidAucune donnée historiqueRequête générique — « Qui est cet utilisateur ? Quelles sont ses préférences, ses objectifs et son style de travail ? »
Démarrage à chaudDonnées historiques existantesRequête centrée sur la session — « D'après ce qui a été discuté dans cette session, quel est le contexte le plus pertinent à propos de cet utilisateur ? »

Trois boutons de réglage indépendants

ParamètreContenu contrôléValeur par défaut
contextCadenceIntervalle de rafraîchissement de la couche de base (appelle l'API une fois tous les N tours)1
dialecticCadenceIntervalle de rafraîchissement de la couche dialectique (appelle le LLM une fois tous les N tours)2 (Recommandé 1–5)
dialecticDepthProfondeur de raisonnement par dialectique (1–3 passes)1

Les trois boutons de réglage sont totalement indépendants — vous pouvez rafraîchir la couche de base à haute fréquence et exécuter le raisonnement dialectique à basse fréquence, ou inversement :

Exemple

{
  "contextCadence": 1,
  "dialecticCadence": 5,
  "dialecticDepth": 2
}

La configuration ci-dessus signifie : rafraîchir la couche de base à chaque tour, et effectuer un raisonnement dialectique approfondi en 2 passes tous les 5 tours.

Raisonnement dialectique multi-passes

Lorsque dialecticDepth est défini sur une valeur supérieure à 1, chaque exécution de raisonnement dialectique exécute plusieurs tours d'appels LLM :

PasseTâcheDescription
Passe 0Raisonnement de démarrage à froid/à chaudÉtablir une évaluation initiale
Passe 1Auto-auditIdentifie les angles morts dans l'évaluation initiale, en synthétisant les preuves issues des sessions récentes
Passe 2RéconciliationVérifie les contradictions des deux tours précédents, produisant une conclusion finale synthétisée

Profondeur 3 ne signifie pas nécessairement 3 appels LLM—si le tour précédent a déjà produit une sortie de haute qualité, le tour suivant se termine plus tôt pour économiser des tokens.

Démarrage rapide avec Honcho

Exemple

# Configuration interactive, choisir le fournisseur honcho
hermes memory setup

Ou configuration manuelle :

Exemple

# Chemin du fichier : ~/.hermes/config.yaml
# Activer Honcho comme fournisseur de mémoire.
memory
:
  provider
: honcho

Exemple

# Écrire la clé API dans le fichier de variables d'environnement
echo 'HONCHO_API_KEY=your_key' >> ~/.hermes/.env

Obtenez une clé API sur honcho.dev.

Outils fournis par Honcho

Après avoir activé Honcho, l'Agent peut utiliser cinq outils exclusifs :

OutilsObjectif
honcho_profileLire ou mettre à jour la Peer Card de l'utilisateur
honcho_searchRecherche sémantique basée sur les conclusions de raisonnement (fragments bruts, sans synthèse LLM)
honcho_contextRécupérer le contexte complet de la session (résumé, caractérisation de l'utilisateur, messages récents)
honcho_reasoningAppeler l'inférence LLM de Honcho (reasoning_level peut être spécifié)
honcho_concludeCréer ou supprimer des conclusions de raisonnement

Commandes CLI Honcho

Exemple

# Afficher l'état de connexion, la configuration et les paramètres clés de Honcho
hermes honcho status

# Afficher ou définir la politique de session
hermes honcho strategy

# Afficher ou définir le mode de rappel (hybride/contexte/outils)
hermes honcho mode

# Afficher ou définir le budget de jetons
hermes honcho tokens

# Lister les mappages de session Honcho connus
hermes honcho sessions

Référence de configuration du système de mémoire

Voici la référence complète pour toute la configuration liée à la mémoire, qui peut être copiée directement dans votre fichier de configuration pour utilisation.

Exemple

# ============================================
# Chemin du fichier : ~/.hermes/config.yaml
# Référence complète de configuration du système de mémoire Hermes
# ============================================

# --- Configuration de la mémoire persistante ---
memory
:
  memory_enabled
: true          # Activer ou non la mémoire persistante (MEMORY.md)
  user_profile_enabled
: true    # Activer ou non le profil utilisateur (USER.md)
  memory_char_limit
: 2200       # Limite de caractères de MEMORY.md (environ 800 jetons)
  user_char_limit
: 1375         # Limite de caractères de USER.md (environ 500 jetons)
  write_approval
: false         # true = toutes les écritures en mémoire nécessitent une approbation manuelle
  provider
: honcho              # Facultatif : Activer le fournisseur de mémoire Honcho

# --- Nettoyage automatique des sessions (facultatif, désactivé par défaut) ---
sessions
:
  auto_prune
: false             # Nettoyer automatiquement ou non les anciennes sessions
  retention_days
: 90            # Conserver les sessions des N derniers jours
  vacuum_after_prune
: true      # Indique s'il faut récupérer l'espace disque après le nettoyage
  min_interval_hours
: 24        # Intervalle minimum entre deux nettoyages

# --- Notifications de révision en arrière-plan ---
display
:
  memory_notifications
: on      # off | on | verbose

# --- Révision en arrière-plan avec un modèle moins coûteux (facultatif) ---
auxiliaire
:
  background_review
:
    provider
: openrouter        # Fournisseur de modèle
    model
: google/gemini-3-flash-preview  # Nom du modèle

Référence rapide pour les opérations de mémoire courantes

Manipuler directement la mémoire dans la conversation

Vous pouvez demander à Hermes d'opérer sur la mémoire en langage naturel, sans avoir à mémoriser aucune commande :

Exemple

# Ajouter une mémoire
Rappel : ce projet utilise Poetry pour la gestion des dépendances, et non pip

# Supprimer ou écraser la mémoire
Oubliez les enregistrements précédents concernant MySQL, nous avons migré vers PostgreSQL

# Mettre à jour les informations en mémoire
Mettez à jour l'adresse IP du serveur de préproduction à 10.0.2.100

# Interroger la mémoire
Dites-moi ce dont vous vous souvenez actuellement à mon sujet.

Commandes slash

Exemple

# Afficher le contenu actuel de la mémoire
/memory

# Afficher les écritures en attente
/memory pending

# Approuver tout ce qui est en attente
/memory approve all

# Rejeter tout ce qui est en attente
/memory reject all

# Activer l'approbation des écritures
/memory approval on

# Désactiver l'approbation d'écriture
/memory approval off

Modifier directement les fichiers de mémoire

Les fichiers de mémoire sont en Markdown brut, qui peuvent être ouverts et modifiés directement avec un éditeur :

Exemple

# Afficher le contenu actuel de la mémoire
cat ~/.hermes/memories/MEMORY.md
cat ~/.hermes/memories/USER.md

# Ouvrir dans l'éditeur pour modifier
nano ~/.hermes/memories/MEMORY.md

Remarque : après avoir modifié directement les fichiers, les modifications prennent effet au prochain démarrage de session et n'apparaîtront pas immédiatement dans le contexte de la session en cours.


Sécurité et confidentialité de la mémoire

Analyse de sécurité

Le contenu de la mémoire subit une analyse de sécurité avant d'être écrit, détectant les attaques par injection et les schémas de vol de données.

Le système détecte les schémas de menace suivants :

Type de menaceContenu de détection
Injection de promptSchémas d'injection tentant de contourner les instructions système de l'Agent
Vol d'identifiantsInstructions incitant l'Agent à divulguer des clés API ou des jetons
Installation de porte dérobéeInstructions d'installation de portes dérobées SSH ou d'accès à distance
Caractères cachésCaractères Unicode invisibles (espaces de largeur nulle, contrôles directionnels, etc.)

Le contenu correspondant aux schémas de menace seraRefuser l'écriture。

Les informations sensibles dans les journaux sont masquées

Les informations sensibles telles que les clés API et les jetons sont automatiquement masquées dans tous les fichiers journaux—même si elles apparaissent dans les sorties d'outils, elles ne seront jamais enregistrées en clair :

Exemple

# Chemin du fichier : ~/.hermes/config.yaml
# Activé par défaut, désensibilise automatiquement les informations sensibles
sécurité
:
  redact_secrets
: true

Stockage local des données

Toutes les données de mémoire (MEMORY.md, USER.md, state.db) sont stockées localement par défaut~/.hermes/Répertoire, non téléversé dans le cloud

Lorsque vous choisissez d'utiliser Honcho, les données de conversation sont envoyées aux serveurs de Honcho pour traitement—il s'agit d'un compromis délibéré : échanger des téléversements de données contre des capacités de raisonnement plus poussées.

autres extensions