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émoire | Emplacement de stockage | Capacité | Méthode de chargement | Objectif |
|---|---|---|---|---|
| Mémoire persistante | Fichiers Markdown sous ~/.hermes/memories/ | ~1,300 tokens au total | Automatiquement injecté dans le prompt système au démarrage de la session | Faits clés, toujours visibles |
| Journal d'histoires | Base de données SQLite + fichiers de transcription JSONL | Illimité (toutes les conversations historiques) | L'agent recherche à la demande, recherche en texte intégral FTS5 | Trouver des discussions historiques spécifiques |
| Modélisation utilisateur Honcho | API côté serveur Honcho | Isolé par agent | Injection d'inférence en arrière-plan par tour / tous les N tours | Dé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.
| Fichier | Objectif | Limite de caractères | approximativement égal à |
|---|---|---|---|
| MEMORY.md | Les notes personnelles de l'Agent—faits sur l'environnement, conventions de projet, choses apprises sur le terrain | 2,200 caractères | ~800 tokens |
| USER.md | Profil utilisateur—vos préférences, style de communication, habitudes de travail, niveau de compétence | 1,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ération | Description | Paramètre |
|---|---|---|
| ajoutez | Ajouter une nouvelle entrée de mémoire | target(memory/user)、content |
| remplacement | Remplacer une entrée existante (localisée par correspondance de sous-chaîne) | target、old_text、content |
| supprimer | Supprimer 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
# 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 :
| Type | Exemple |
|---|---|
| Faits environnementaux | Cette 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 outils | Le port SSH du serveur de staging est 2222, pas 22 ; la clé se trouve dans ~/.ssh/staging_ed25519 |
| Enregistrement des corrections | Ne 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 :
| Type | Exemple |
|---|---|
| Informations d'identité | Nom, intitulé du poste, fuseau horaire |
| Préférences de communication | Pré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 travail | Ne pas vérifier les messages avant 3 PM chaque jour |
| Niveau de compétence | Familier 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 :
| Type | Exemple | Raison |
|---|---|---|
| Trop général | L'utilisateur a un projet | Aucune valeur informative, ne peut pas être réutilisé |
| Peut être revérifié à tout moment | Python 3.12 prend en charge les f-strings imbriquées | Il suffit de rechercher ; cela ne vaut pas la peine d'occuper de l'espace |
| Données brutes | Segments de journal volumineux, blocs de code, tableaux de données | Dépasse la limite de caractères ; une mémoire structurée est plus utile |
| Contenu temporaire | Chemins de fichiers temporaires pour cette session de débogage | Inutilisable la prochaine fois |
| Contenu déjà dans le contexte | Informations déjà présentes dans le projet SOUL.md, AGENTS.md | Une 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.
| Évaluation | Exemple | Révision |
|---|---|---|
| OK | Utilisateur de macOS 14 Sonoma, Homebrew, Docker Desktop, Shell : oui avec oh-my-zsh de zsh, Éditeur : oui VS Code + Vim Keybits | Forte densité d'informations ; les faits liés sont regroupés |
| OK | Projet ~/code/api Utilise Go 1.22, sqlc pour les requêtes DB, routeur chi. Test : make test. CI : GitHub Actions | Règles spécifiques actionnables |
| OK | Serveur de staging(10.0.1.50)port SSH 2222 et non 22, clé privée ~/.ssh/staging_ed25519 | Leçons contextuelles apprises, éviter les pièges |
| Médiocre | Les utilisateurs ont des projets | Trop vague, ne peut guider aucune action |
| Médiocre | Le 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 :
- Lire toutes les entrées actuelles (déjà incluses dans la réponse d'erreur)
- Trouver les entrées qui peuvent être supprimées ou fusionnées
- use
replaceFusionner plusieurs entrées connexes en une version plus affinée - 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é
| Stockage | Limite supérieure | Nombre typique d'entrées |
|---|---|---|
| MEMORY.md | 2,200 caractères | 8–15 éléments |
| USER.md | 1,375 caractères | 5–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
# 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énarios | Comportement |
|---|---|
| Lorsque l’Agent souhaite écrire en mémoire lors d’une interaction en CLI | Invite intégrée dans le terminal demandant votre approbation |
| Plateforme de messagerie / revue automatique en arrière-plan | Les é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
/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
# 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
| Valeur | Effet |
|---|---|
| off | Aucune 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" |
| verbose | Inclut 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
# 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 stockage | Formatage | content |
|---|---|---|
| ~/.hermes/state.db | Base de données SQLite + index en texte intégral FTS5 | Mé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 JSONL | Transcriptions 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 :
- FTS5 récupère les messages correspondants triés par pertinence
- Regroupés par session, en prenant les sessions les plus pertinentes (3 par défaut)
- Charge la conversation de chaque session, en capturant environ 100,000 caractères autour du point de correspondance
- Un modèle de synthèse léger génère des résumés ciblés
- Renvoie le résumé et le contexte de chaque session à l'Agent
Syntaxe de recherche prise en charge (standard FTS5) :
| Syntaxe | Exemple | Description |
|---|---|---|
| Récupération par mots-clés | déploiement docker | Correspond aux messages contenant n'importe quel mot-clé |
| Correspondance de phrase | "phrase exacte" | Correspondance exacte pour la phrase entière |
| OR booléen | docker OR kubernetes | Correspond à n'importe quel mot-clé |
| NOT booléen | python NOT java | Exclure des mots-clés spécifiques |
| Joker de préfixe | deploy* | 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 comparaison | Mémoire persistante (MEMORY.md / USER.md) | Journal d'événements (Session Search) |
|---|---|---|
| Capacité | ~1,300 tokens au total | Illimité (toutes les conversations historiques) |
| Vitesse | Immédiat (déjà dans le prompt système) | ~20ms (requête FTS5) |
| Coût en tokens | Consommation fixe par session | À la demande ; pas de requête, pas de coût |
| Objectif | Faits clés, toujours visibles | Trouver des discussions historiques spécifiques |
| Style de gestion | L’agent organise de manière proactive | Entiè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
/title refactor authentication module
Après le nommage, les sessions peuvent être reprises directement par leur titre :
Exemple
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
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
# 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étences | Mémoire intégrée | Honcho |
|---|---|---|
| Persistance entre sessions | Fichiers locaux | API côté serveur |
| Profil utilisateur | Gé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émantique | Texte intégral FTS5 | D'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 :
| Mode | Conditions | Méthode d'interrogation |
|---|---|---|
| Démarrage à froid | Aucune donnée historique | Requête générique — « Qui est cet utilisateur ? Quelles sont ses préférences, ses objectifs et son style de travail ? » |
| Démarrage à chaud | Données historiques existantes | Requê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ètre | Contenu contrôlé | Valeur par défaut |
|---|---|---|
| contextCadence | Intervalle de rafraîchissement de la couche de base (appelle l'API une fois tous les N tours) | 1 |
| dialecticCadence | Intervalle de rafraîchissement de la couche dialectique (appelle le LLM une fois tous les N tours) | 2 (Recommandé 1–5) |
| dialecticDepth | Profondeur 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 :
| Passe | Tâche | Description |
|---|---|---|
| Passe 0 | Raisonnement de démarrage à froid/à chaud | Établir une évaluation initiale |
| Passe 1 | Auto-audit | Identifie les angles morts dans l'évaluation initiale, en synthétisant les preuves issues des sessions récentes |
| Passe 2 | Réconciliation | Vé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
hermes memory setup
Ou configuration manuelle :
Exemple
# Activer Honcho comme fournisseur de mémoire.
memory:
provider: honcho
Exemple
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 :
| Outils | Objectif |
|---|---|
| honcho_profile | Lire ou mettre à jour la Peer Card de l'utilisateur |
| honcho_search | Recherche sémantique basée sur les conclusions de raisonnement (fragments bruts, sans synthèse LLM) |
| honcho_context | Récupérer le contexte complet de la session (résumé, caractérisation de l'utilisateur, messages récents) |
| honcho_reasoning | Appeler l'inférence LLM de Honcho (reasoning_level peut être spécifié) |
| honcho_conclude | Créer ou supprimer des conclusions de raisonnement |
Commandes CLI Honcho
Exemple
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
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
/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
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 menace | Contenu de détection |
|---|---|
| Injection de prompt | Schémas d'injection tentant de contourner les instructions système de l'Agent |
| Vol d'identifiants | Instructions incitant l'Agent à divulguer des clés API ou des jetons |
| Installation de porte dérobée | Instructions d'installation de portes dérobées SSH ou d'accès à distance |
| Caractères cachés | Caractè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
# 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