convez.ai
SkillAutomaçãoAvançado
jasonatgit

EchoMind Memory — Sistema de Memória para Agentes IA

jasonatgit/echomind_memory.skill

Memória persistente e auto-evolutiva para agentes IA multplataforma

Ver no GitHub
BomPluginScore · de 0 a 100

Skill de memória de longo prazo que permite agentes IA (Hermes-Agent, OpenClaw, Claude Code, OpenCode) lembrarem preferências, estilos de código, correções e contexto entre sessões. Utiliza SQLite local, auto-otimização com aprendizado por reforço e isolamento de memória por projeto/domínio sem dependências externas.

Instalação

$npx convez-ai jasonatgit/echomind_memory.skill

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
48
Forks
3
Acompanhando
0
Saúde
28%
Último commit
há 1 semana
Versão
v1.2.20
Issues abertas
4
Contribuidores
1

Casos de uso

  • Agentes de código que precisam lembrar estilo e padrões de um projeto
  • Pesquisadores usando múltiplas sessões com mesmo contexto de domínio
  • Desenvolvimento iterativo onde correções anteriores devem ser reutilizadas
  • Sistemas que precisam evoluir comportamento baseado em feedback do usuário

Veredito

Solução robusta para memória persistente em agentes IA, com suporte multi-plataforma e zero dependências externas. Ideal para quem precisa evitar repetição de contexto em workflows complexos, mas requer integração técnica com framework específico.

README

A tradução para o português deste README ainda está na fila.

OpenClaw Compatible Hermes-Agent Ready Claude Code Supported OpenCode Compatible

EchoMind Memory Skill —— Give Your AI Permanent Memory and Self-Evolution Capabilities

🌐 中文版: README.zh-CN.md

A long-term memory Skill supporting the Hermes Agent, OpenClaw, OpenCode, and Claude Code ecosystems.

Stop your AI from "forgetting" — remember your preferences, style, research methods; self-reflect and self-evolve.

EchoMind-Memory Skill helps you: extract knowledge from conversations, crystallize rules through reflection.

📦 Repository: https://github.com/jasonatgit/echomind_memory.skill


EchoMind's 10 Core Capabilities

CapabilityDescription
Self-Evolving Engine Agent 🆕Automatically reflects on raw memories to distill semantic knowledge and procedural rules, with zero-config LLM injection
Seven Types of MemoryUser / Task / Experience / Context / Knowledge / Research / Reflection
RL-Enhanced Auto-OptimizationAutomatically adjusts memory weights based on positive/negative user feedback and persists them — gets smarter with use
Few-Shot AnchoringRapidly builds memory norms from small samples, improving memory quality
Experience Distillation & ReusePreviously fixed bugs / used models → auto-recommended next time
Multi-Trigger RetrievalKeywords + RL weights + LLM semantics, a true "semantic memory system"
Hallucination-Prevention 🆕Long-term memory safety mechanism — low-confidence reflection results are automatically discarded to prevent hallucination pollution
Platform-Aware Memory IsolationCross-platform weight decay; isolation by user, project, session, topic, and research domain — no more memory chaos
Zero-Dependency Local StorageSQLite persistence, no Docker / PostgreSQL / Redis required
Cross-Framework CompatibilityLLM-independent, adapters for Hermes / OpenClaw / OpenCode / Claude Code

Auto-Retrieval Triggers

EchoMind's memory system is optimized specifically for research-oriented memory, storing research papers, theoretical models, and research methodologies.

When a query involves the following domain keywords or related semantics, the system automatically retrieves research memories:

Domain
Management Science
AI
NLP
Biology
Computer Science
Robotics
Speech & Audio
Recommendation Systems
Statistics & Decision Science

Other disciplines and keywords can all be customized


Supported Frameworks

FrameworkIntegration MethodReliability
Hermes-AgentMemoryProvider Plugin (automatic, v0.13.0–v0.16.0)★★★★★ 100%
OpenClawskill.yaml + HTTP API tool invocation★★★★☆ LLM-decision
OpenCodeCLI + HTTP API or MCP stdio★★★★☆ LLM-decision
Claude CodeMCP stdio or HTTP API★★★★☆ LLM-decision

v1.1.0 New Features

Core Highlights: Introducing a dedicated Reflection Engine Agent that proactively distills semantic memory and procedural memory from raw episodic memory. Analogous to human "bedtime reflection" or the Reflexion/SRMA architecture.

FeatureDescription
Self-Evolving Engine Agent 🧠Automatically extracts long-term knowledge from raw conversations. Auto-triggers self-reflection to distill raw interaction records into persistent knowledge, user preferences, and procedural rules — achieving true memory self-evolution
Upgraded RL CapabilitiesRL weight range mode, random sampling, automatic convergence from user feedback
Configurable Domain PromptsDomain prompts are now configuration-driven — no code changes needed for tuning
Confidence FilteringReflection results below the confidence threshold are automatically discarded, preventing hallucination pollution of memory
Memory Source TrackingComplete storage of reflection records with platform tags and source traceability
Importance ScoringScores memory importance, preserving valuable memories
Multi-Trigger RetrievalKeywords + RL weights + LLM semantics — a true "semantic memory system"
Memory IsolationIsolation by user, project, session, topic, and research domain — no more memory chaos
Architecture UpgradeNew reflection engine architecture supporting highly flexible prompt configuration

v1.1.0 Academic References

The technical design of the Self-Reflective Agent component in this v1.1.0 release is inspired by the following research:

1. SAGE: Self-evolving Agents with Reflective and Memory-Augmented Abilities

Liang, X., He, Y., Xia, Y., Song, X., Wang, J., Tao, M., Sun, L., Yuan, X., Su, J., Li, K., Chen, J., Yang, J., Chen, S., & Shi, T. (2024).

2. SRMA: Self-Reflective Memory Consolidation in Agentic Architectures

Satya, P. R. B. (2026).

  • Paper: IJCA Vol.187 No.73
  • Journal: International Journal of Computer Applications, 187(73)

Acknowledgments

We sincerely thank the authors of the above papers for their pioneering work on self-reflective memory mechanisms. Their research has provided valuable theoretical foundations and inspiration for the design of EchoMind-Memory.skill's Self-Reflective Agent.

The technical design of this project's Self-Reflective Agent benefits from the inspiration of the above groundbreaking research. We extend our sincere academic gratitude to the paper authors.

At the same time, EchoMind-Memory.skill's "self-evolution" primarily differs from the above scientific research in its adoption of dependency inversion (core engine with zero LLM coupling), platform-aware isolation, and zero-configuration deployment — making it directly usable in production Multi-Agent systems without additional infrastructure. This is a production-grade agent application.


Historical Version Notes

v1.0.10 — Full Hermes v0.14.0 Compatibility (2026-05-17)

Added (MemoryProvider ABC compatibility):

MethodDescription
queue_prefetch()Compatible with the new Hermes v0.13.0+ interface, eliminating per-turn AttributeError logs (was previously causing error logs on every turn)
on_session_switch()Fixes session ID corruption after /resume /branch /reset operations (fixes session ID corruption after session switch operations)
on_pre_compress()Auto-saves memories about to be discarded before context compression (auto-saves memories before context compression discards them)
on_delegation()Captures sub-agent task experience into long-term memory (captures sub-agent task experience into long-term memory)

v1.0.9 — OpenClaw / OpenCode / Claude Code Three-Platform Compatibility Fix (2026-05-16)

FixAffected Platforms
main.py added call() dispatch functionOpenClaw
http_api.py retrieve/store endpoints pass through platform parameterAll platforms
code_format/cli.py fixed async→sync crashOpenCode
skill.yaml added platform parameter + openclaw.call declarationOpenClaw

v1.0.8 — Platform-Aware Memory + Hermes Adapter (2026-05-15)

  • Platform-aware memory: same-platform weight ×1.0, cross-platform ×0.5
  • Hermes Agent plugin: implements MemoryProvider interface, auto-save/load each turn
  • WAL concurrency mode + automatic data migration

v1.0.8 Existing Features

FeatureDescription
Hermes Adapter PluginImplements Hermes Agent memory interface for auto-save/load each turn. Code-driven, no LLM decisions needed, 100% reliable
Platform-Aware MemoryAll context memory tagged with platform labels (hermes/openclaw/opencode); same-platform weight ×1.0, cross-platform ×0.5; user preferences isolated by platform
WAL Concurrency ModeSupports multi-process concurrent read/write
Auto-MigrationOld table structures auto-migrated on upgrade
User Preferences Isolated by PlatformDifferent users, different apps, different platforms have independent preferences — keep your memories isolated

Installation

Prerequisites

Make sure you have the following installed:

ToolCheckInstall
Python 3.10+python3 --versionpython.org
pippip --versionComes with Python
gitgit --versionsudo apt install git / git-scm.com

Option 1: Quick Install (Recommended, with Auto-Start)

The install script copies files, generates config, and registers auto-start.

# Step 1: Clone the repository
git clone https://github.com/jasonatgit/echomind_memory.skill.git
cd echomind_memory.skill

# Step 2: Install Python dependencies
pip install -r requirements.txt

# Step 3: Run the install script
./install.sh

Windows (PowerShell):

# Step 1: Clone the repository
git clone https://github.com/jasonatgit/echomind_memory.skill.git
cd echomind_memory.skill

# Step 2: Install Python dependencies
pip install -r requirements.txt

# Step 3: Run the install script
.\install.ps1

What install.sh / install.ps1 does:

  1. Detects your Hermes home directory automatically (priority: $HERMES_HOME → platform default)
    • Linux/macOS/WSL: ~/.hermes
    • Windows: %LOCALAPPDATA%\hermes
  2. Copies to <hermes>/skills/echomind-memory/ (Skill directory)
  3. Copies to <hermes>/plugins/echomind/ (MemoryProvider plugin)
  4. Creates default config ~/.echomind/echomind_config.yaml (skips if exists)
  5. (optional) Registers HTTP service auto-start — only when ECHOMIND_HTTP_SERVICE=1 is set

Rationale: The EchoMind MemoryProvider plugin runs inside Hermes's process — no separate HTTP service is needed for memory to work. The standalone HTTP API (main.py) is only required when integrating with OpenCode, OpenClaw, or other external tools that call memory over HTTP.

Verify after installation:

curl http://localhost:8005/health
# Expected: {"status": "ok", "version": "1.1.6"}

Option 2: Manual Install (No Auto-Start)

If you prefer to start the service manually:

# 1. Clone and install deps (same as Option 1 steps 1-2)
git clone https://github.com/jasonatgit/echomind_memory.skill.git
cd echomind_memory.skill
pip install -r requirements.txt

# 2. Create config
mkdir -p ~/.echomind && cp echomind_config.yaml ~/.echomind/

# 3. Start the service manually
python main.py
# Service runs at http://localhost:8005

Tip: For auto-start, use Option 1 above.


Hermes-Agent Auto Memory (Recommended)

After completing the installation above, activate the MemoryProvider plugin — this enables Hermes to auto-save and auto-retrieve memories on every turn, no LLM decisions required:

# 1. Install plugin files (already done by one-click install; manual install requires this step)
cp -r echomind_memory.skill/* ~/.hermes/plugins/echomind/

# 2. Activate MemoryProvider
hermes config set memory.provider echomind

# 3. Restart Hermes to take effect

Result: Every turn auto-saved, auto-retrieved. Self-reflection auto-triggered after conversations — no additional configuration required.


OpenClaw / OpenCode / Claude Code

Install EchoMind to your framework's skills directory, then start the HTTP service:

# Install dependencies
pip install -r requirements.txt

# Copy to framework skills directory (choose as needed)
cp -r . ~/.openclaw/skills/echomind-memory/    # OpenClaw
cp -r . ~/.opencode/skills/echomind-memory/    # OpenCode

# Start service
python main.py

Service runs at http://localhost:8005. LLM invokes memory tools based on skill trigger rules.

Python Quick Start

from main import call

# Store memory (platform-aware)
call("store_memory",
    user_id="alice",
    platform="hermes",
    task_id="task-001",
    context=[{"role": "user", "content": "What are common supply chain coordination models?"}],
    task_status="completed",
    success=True,
)
# Retrieve memory
result = call("retrieve_memory", user_id="alice", query="supply chain coordination models")
for m in result["working_memory"]:
    print(f"[{m['source']}] {m['content'][:80]}")
# Record feedback (AI self-evolution)
call("record_feedback",
    user_id="alice",
    task_id="task-001",
    feedback="positive",
    retrieved_memories=result["working_memory"],
)

# Trigger self-reflection (v1.1.0) — Hermes adapter calls automatically
# Or trigger manually via HTTP: POST /api/reflect

API Endpoints (HTTP Mode)

MethodEndpointDescription
POST/api/memory/retrieveRetrieve task memory (with platform parameter support)
POST/api/memory/storeStore conversation context (with platform parameter support)
POST/api/memory/feedbackRecord feedback for RL optimization
POST/api/memory/sync-codeSync project code style memory
POST/api/research/paperAdd research paper
POST/api/research/noteAdd research note
GET/api/research/papersList research papers
POST/api/reflect 🆕Self-reflection
GET/healthHealth check

Data Storage

All persistent data is stored in ~/.echomind/memory.db (SQLite file). Can be backed up or deleted at any time. The storage path can be customized via storage.db_path in echomind_config.yaml.


Vision

AI is not a tool, it's a collaborator. Collaborators shouldn't have to "re-meet you" every time.

EchoMind enables your AI to:

  • Remember your coding style, preferences, and habits
  • Remember the bugs you've fixed and approaches you've tried
  • Remember the papers and theoretical models you've researched
  • Possess an RL-driven self-optimizing weight system — gets smarter with every interaction
  • This is not a plugin, this is an AI Multi-Agent Memory Neural Network with self-reflective memory.

Contact

email:jasonyouatgmaildotcom


Q&A Click to expand

Q: How do I use EchoMind across Hermes Profiles?

EchoMind v1.1.6+ supports Hermes Profile-level memory isolation.

Install once:

./install.sh

Automatic behavior:

  • Default profile → memory stored under profile='default'
  • Other profiles (e.g. weixin) → symlinks created automatically, memory stored under profile='weixin'
  • Both profiles' memories live in the same ~/.echomind/memory.db, completely isolated
  • Historical data is automatically assigned to the default profile

Per-project isolation within the same profile:

# hermes config.yaml
memory:
  provider: echomind
  project: echomind  # optional, filters by project within the same profile

Manually linking a new profile (if the profile was created after installation):

ln -s ~/.hermes/plugins/echomind ~/.hermes/profiles/<profile-name>/plugins/echomind

Q: Does EchoMind support Windows?

Yes. v1.1.6+ has fixed cross-platform path resolution. Windows paths (e.g. C:\Users\...\profiles\weixin\...) correctly extract the profile name. If using WSL, paths follow the Linux convention.


Q: Will multiple profiles conflict when using EchoMind simultaneously?

No. v1.1.6+ uses the following mechanisms to guarantee concurrency safety:

  1. WAL mode: SQLite write-ahead logging, supports concurrent reads across multiple processes
  2. busy_timeout=5000: waits up to 5 seconds when encountering a lock
  3. Auto-retry: exponential backoff retry up to 3 times in edge cases

Q: How do I downgrade to an older version?

⚠️ Important: When downgrading, older versions' SELECT queries lack WHERE profile = ? filtering, making all profile data visible to the default profile.

Safe downgrade steps:

  1. Backup ~/.echomind/memory.db
  2. Clear non-default data:
    DELETE FROM task_memory WHERE profile != 'default';
    DELETE FROM user_memory WHERE profile != 'default';
    
  3. Then roll back to the older version

Recommendation: Keep the new version. Do not downgrade.


Q: Where is data stored? How do I back it up?

All data is stored in a single file ~/.echomind/memory.db. To back up, simply copy the file:

cp ~/.echomind/memory.db ~/.echomind/memory.db.backup-$(date +%Y%m%d)

Q: Will data be lost after migration?

No. SQLite ALTER TABLE ADD COLUMN ... DEFAULT 'default' is an O(1) metadata operation — it does not modify rows row-by-row. Existing 37MB of data is fully preserved, automatically assigned to the default profile.


Q: Is EchoMind compatible with Hermes v0.16.0?

Yes. EchoMind v1.1.6+ has been adapted to Hermes v0.16.0's new on_session_switch(rewound=True) parameter. When the user executes /undo N to truncate conversation history, EchoMind automatically clears the context cache to prevent memory contamination. Compatibility range: Hermes v0.13.0 – v0.16.0.

Ver o original no GitHub

Bom para

Relacionados