Boucle d'apprentissage et mémoire

源码版本v2026.7.20

Responsabilité

C'est le cœur de ce qui distingue Hermes d'un agent ordinaire : une boucle « qui s'améliore à l'usage ». Elle distille chaque tour de conversation en : (1) évolution des compétences — création / réécriture de compétences depuis l'expérience (agent/learning_mutations.py) ; (2) mémoire — récupération des conversations passées par FTS5 recherche plein texte + résumé LLM (memory_manager), complétée par la modélisation dialectique de l'utilisateur via Honcho ; (3) graphe d'apprentissage — organise les compétences et mémoires en nœuds / arêtes (agent/learning_graph.py) ; (4) examen en arrière-plan — background_review digère l'historique dans un thread et produit des actions de réécriture exécutables. Les réécritures de compétences sont finalement réinjectées dans le système de compétences pour être réutilisées aux tours suivants.

Fichiers clés

Nœuds de compétence et graphe d'apprentissage

• @dataclass SkillNode:28-41 — nœud de compétence
• chargement des compétences:77-125 — _iter_skill_files / build_skill_nodes (scanne skills/ pour construire les nœuds)
• arêtes et stats:156-193 — build_edges / density_stats (corrélations entre compétences)
• arêtes mémoire-compétence:193-227 — _memory_cards / _memory_skill_edges (corrélations mémoire / compétence)
• build_learning_graph:248-328 — agrège pour produire le graphe complet
• _load_usage:84-97 — statistiques d'usage (orientent quelles compétences sont souvent appelées)

Réécriture compétence / mémoire

• node_detail:86-124 — voir le détail d'un nœud
• delete_node:124-157 — supprimer une compétence ou un souvenir
• edit_node:157-200 — éditer une compétence ou un souvenir
• _clear_skill_cache:200 — vider le cache après réécriture (pour prise d'effet au tour suivant)
• localisation mémoire:30-65 — _memories_dir / _parse_memory_id / _locate_memory

Gestion de la mémoire

• class MemoryManager:354 — gestionnaire de mémoire
• injection outils memory provider:83-164 — memory_provider_tools_enabled / inject_memory_provider_tools
• build_memory_context_block:337-354 — assemble la mémoire en un bloc injecté dans le prompt
• sanitize_context:164-172 — masquage du contexte (avant indexation FTS5)
• StreamingContextScrubber:172-337 — masquage du flux en streaming

Examen en arrière-plan

• spawn_background_review_thread:956 — lance le thread d'examen en arrière-plan
• _run_review_in_thread:617 — boucle principale dans le thread
• _digest_history:122-373 — résume les 24 derniers historiques
• summarize_background_review_actions:373-590 — agrège les actions d'examen
• build_memory_write_metadata:590-617 — métadonnées d'écriture mémoire

Flux de données

1. À la fin de chaque tour de conversation, la boucle principale confie un instantané des messages au thread d'examen en arrière-plan (agent/background_review.py:956).
2. _digest_history (agent/background_review.py:122) résume l'historique récent et produit des actions candidates (créer / réécrire une compétence, écrire un souvenir).
3. La réécriture d'une compétence est persistée via edit_node:157 / la suppression via delete_node:124, et le cache est vidé par _clear_skill_cache:200.
4. L'écriture mémoire passe par MemoryManager:354, est masquée (agent/memory_manager.py:164) puis indexée par FTS5, et compressée par un résumé LLM.
5. Au début du tour suivant, build_memory_context_block (agent/memory_manager.py:337) injecte les souvenirs pertinents dans build_turn_context:268 ; les compétences sont injectées via agent/skill_bundles.py.
6. Le graphe d'apprentissage complet est agrégé par build_learning_graph:254, pour que l'UI / le debug affiche les corrélations compétences / souvenirs.

Résumé

La boucle d'apprentissage transforme « la conversation » en « actif » : l'examen en arrière-plan dépose silencieusement l'expérience en compétences et souvenirs, qui sont réinjectés automatiquement au tour suivant. Quatre pièces clés — learning_graph (le graphe), learning_mutations (réécriture), memory_manager (recherche + masquage + résumé), background_review (digestion asynchrone). C'est le socle du mécanisme par lequel Hermes « grandit avec l'utilisateur », et la différence fondamentale avec un « appel de LLM sans état ».