dsh-mneme

🌏 简体中文 · English

---

🧬 Give Your LLM a Memory That Evolves

dsh-mneme is a cross-session memory plugin for DeepSeek Harness (DSH). It does not just store your memories — it manages them: background deduplication and merging, conflicts frozen for your review, a fully replayable audit trail, offline by default, and export to human-readable Markdown.

Mneme (Μνήμη) comes from Mnemosyne, the Greek goddess of memory and dreams — just as autoDream quietly consolidates your memory store in the background.

What problem does it solve

Does the AI act like it's never met you every new chat?

dsh-mneme gives DeepSeek Harness cross-session memory. Projects you've discussed, preferences you've mentioned, decisions you've made — the AI remembers them even after you close the window and reopen it next time.

Scenario	Without plugin	With plugin
Discuss project requirements on Monday, continue on Wednesday	"Can you describe your project again?"	"You mean the blog refactor we mentioned last week? You said you wanted to use Astro."
Tell the AI your coding habits	Repeat yourself in every session	Set it once, and it holds long-term
Close the window after organizing a large amount of research material	The material is lost	Auto-archived, retrievable anytime

But what makes dsh-mneme trustworthy is exactly the part you can't see — the background. These details are the essential difference from "just a memory-saving plugin."

Why you can trust it

• 🧾 Replayable and accountable — every automated run leaves a "decision receipt": input snapshot + decision details + result hash. The same consolidation is reproducible and replayable. No silent error-swallowing, no untraceable changes.
• ⚖️ Conflicts are frozen first, awaiting your call (can be disabled) — when two memories clash, it won't decide for you. Suspected conflicts are parked for review: side-by-side comparison in the conflict queue on the status page, one-click resolution (keep A / keep B / mark only), effective only after confirmation. For complex judgment calls, a human is always in the loop.
• 🔐 Memories are isolated per agent and workspace (can be disabled) — with scopeEnabled on, each memory is labeled with which agent and which workspace wrote it; retrieval prefers the current session's scope (weighted hits, other scopes down-weighted but still visible); strictScope goes further — memories explicitly declared in other scopes are completely invisible to retrieval/injection (auto carrier labels only down-weight, never hard-block). Multiple agents and projects, no crosstalk.
• 🌙 Works only when idle (can be disabled) — idle time triggers tiered archiving: frequent items stay hot, long-unused ones compress into summaries, stale ones get fully archived. The memory store stays leaner with use, not bigger.
• 🧠 Local semantic retrieval, offline by default — ships with local Embedding and reranking; no API key required, works with the network down.
• 📝 Two-way Markdown sync — memories are local .md files you can open and edit anytime; human edits take priority and are never overwritten by the machine.
• 💾 Deleting a chat ≠ deleting memories — clearing the chat window keeps saved memories (configurable).

5-minute quickstart

# 安装插件
dsh plugin --profile web add @modusensus/dsh-mneme
dsh web

It works out of the box. To see its value within 5 minutes:

1. Chat: start a new session and tell the AI a few things about your preferences or current projects (e.g., "I prefer 4-space indentation in code").
2. Wait: close the window and reopen a new session. If it still remembers what just happened, the memory has been written.
3. Tune: go to "Settings → Memory Settings" and turn on the three switches below as needed (see Quick Config).

Quick Config (optional)

Need	Config key	Default	Change
Run fully offline	embedProvider	openai	Change to local
Keep memories when deleting sessions	sessionLifecycleEnabled	false	Change to true
Auto-extract structured entities	entityExtractionEnabled	false	Change to true
Memory isolation for multiple agents / projects	scopeEnabled (add strictScope for stronger isolation; hard isolation only applies to explicit declarations)	false	Change to true

All of the above can be changed in DSH Settings panel → Memory Settings. For full configuration, see the Configuration section.

The memory loop in one diagram

  写入 ──► 质量过滤（无用信息先拦下）
    │
    ▼
  SQLite + 本地 Markdown 镜像
    │（空闲时）
    ├─ autoDream ：去重 / 合并 / 归档 / 修正 / 冲突冻结
    └─ Sleep Mode ：分层压缩 + 模式发现 + 关系补全（可关）
    │
    ▼
  召回（混合检索 + 精排）──► 注入会话上下文

UI Preview

The panel is bilingual (Chinese/English) and follows your DSH UI language. The screenshots below are in Chinese; for the English version see the English section at the end.

记录、浏览与筛选你的记忆。

自动从记忆里提炼实体，构建带属性的关系图谱。

状态面板一眼看清向量索引、LLM 消耗与自动巩固记录。

检索、实体抽取与记忆巩固开关都在设置里一站式配置。

可选写保护 Token，以及本地化的反馈通道，让记忆库完全本地、可审计。

Privacy Commitment

• Data is stored only on your local computer, never uploaded to any server
• Memories are Markdown files, human-readable and manually editable
• Zero network dependency by default, no API Key required
• No telemetry, no analytics, no remote logging

Use it with other AI tools (MCP)

The plugin ships with a zero-dependency stdio MCP server (standalone npm package mneme-memory, bin name mneme-mcp); any MCP client can mount the six memory tools (memory_save / memory_search / memory_list / memory_get / memory_update / memory_delete).

Prerequisites (one-time):

1. DSH is running and the plugin is installed (the MCP data plane goes through the plugin's standalone API at 127.0.0.1:8790)
2. Generate a token in the DSH panel under "Settings → External Access API"

Mounting on each client (replace <你的token> with the value generated in the previous step):

Client	Mounting method
Claude Code	Project-root .mcp.json: {"mcpServers": {"mneme-memory": {"command": "mneme-mcp", "env": {"MNEME_TOKEN": "<你的token>"}}}}
Cursor	Settings → MCP → Add Server, command is mneme-mcp, add MNEME_TOKEN to env
Codex	~/.codex/config.toml: [mcp_servers.mneme-memory] section, command = "mneme-mcp", env = { MNEME_TOKEN = "<你的token>" }
Hermes	mcp_servers: section of ~/.hermes/config.yaml: mneme-memory: {command: "mneme-mcp", env: {MNEME_TOKEN: "<你的token>"}}, takes effect after restart
OpenCode	opencode.json: {"mcp": {"mneme-memory": {"type": "local", "command": ["mneme-mcp"], "environment": {"MNEME_TOKEN": "<你的token>"}}}}
OpenClaw	openclaw mcp add mneme-memory --command mneme-mcp --env MNEME_TOKEN=<你的token>, or Control UI → Settings → MCP

Legacy mount compatibility: existing dsh-mneme-mcp + DSH_MNEME_TOKEN setups continue to work (both the bin and the env variable are retained, no migration needed). When the npm package is not installed globally, change command to npx and append the arguments -p mneme-memory mneme-mcp (write them into the args array for Claude Code/OpenCode; in Codex use args = ["-p", "mneme-memory", "mneme-mcp"]). For configuration details and security notes, see full docs.

Docs

Doc	Path
Full plugin docs (features / install / configuration / architecture)	dsh-mneme/README.md
stdio MCP server — plug the six memory tools into any MCP client (Claude Code / Cursor, etc.)	dsh-mneme/README.md · MCP Server
Entity structuring design	dsh-mneme/docs/ENTITIES.md
Semantic architecture	dsh-mneme/docs/SEMANTIC.md
Local model deployment guide	dsh-mneme/docs/LOCAL_MODEL.md
Version history	dsh-mneme/CHANGELOG.md
Security policy	SECURITY.md

🗺️ Roadmap

🧬 记忆基因 → 🛡️ 审计加固 → 💤 睡眠维护 → 🕸️ 召回融合与图谱 → ✨ 面板增强 → 🌡️ 自进化记忆 → 🕸️ 图谱增强

Version	Theme	Status
v0.3	Memory genes: entities / attributes (with timeline) / relations	✅
v0.4	Sleep Mode: four-stage deep maintenance during idle time	✅
v0.5	Recall fusion and memory visualization: BM25 + graph + hot memories	✅
v0.6	Session lifecycle: deleting a chat ≠ deleting memories	✅
v0.7	Self-evolving memory: heat decay + dual sleep protection + desktop workbench / feature toggles	✅
v0.8	Scope isolation (agent/workspace dual-dimension isolation + retrieval weighting + opt-in hard filtering) + human adjudication via conflict queue + explicit attribution declaration + ecosystem (stdio MCP server / graph recall axis / cold start / injection truncation & status bar / distillation reliability / injection shaping & agent-driven organize interface)	✅ Released (through v0.8.6)

For the full per-minor-version changelog, see CHANGELOG.

🧪 Local Development

cd dsh-mneme && npm install
npm test        # 1317 个测试
npm run stress  # 三轴线压测
npm run sync    # src → lib 同步

---

---

🙏 Acknowledgements

Provenance of the autoDream concept (ideas credited, implementation original):

• Auto Dream in Claude Code (Anthropic, Memory 2.0): the conceptual source — a background sub-agent consolidates memory files between sessions (deduplication, contradiction resolution, decay pruning).
• Sleep-time Compute: Beyond Inference Scaling at Test-time (UC Berkeley & Letta, arXiv:2504.13171): the academic thread behind the "offline consolidation" idea of Auto Dream.
• cc-haha: one of the references for early implementation ideas.

Building on the work above, dsh-mneme developed its own engineering: K-Means++ cluster pre-grouping, a typed decision list (keep / merge / archive / conflict / update, plus supersede / differentiate on the sleep side), and a replayable sha256 digest audit chain (dream_runs / receipt_chain). If any source of inspiration is missing, please open an issue to point it out.

🧬 Give Your LLM a Memory That Evolves

dsh-mneme is a cross-session memory plugin for DeepSeek Harness (DSH). It does not just store your memories — it manages them: background deduplication and merging, conflicts frozen for your review, a fully replayable audit trail, offline by default, and export to human-readable Markdown.

Mneme (Μνήμη) comes from Mnemosyne, the Greek goddess of memory and dreams — just as autoDream quietly consolidates your memory store in the background.

What problem does it solve

Every time you start a new chat, the AI acts like it's never met you?

dsh-mneme gives DeepSeek Harness cross-session memory. Projects you've discussed, preferences you've mentioned, decisions you've made — the AI remembers them even after you close the window.

Scenario	Without plugin	With plugin
Continue a project discussion from Monday on Wednesday	"Can you describe your project again?"	"You mean the blog refactor from last week? You mentioned wanting to use Astro."
Tell the AI your coding habits	Repeat every session	Set once, remember forever
Close window after organizing research	Notes are lost	Auto-archived, retrievable anytime

But what makes dsh-mneme trustworthy lives in the background you never see. These are the traits that set it apart from "a plugin that just saves things."

Why you can trust it

• 🧾 Replayable, accountable — every consolidation leaves a "decision receipt": input snapshot + decision detail + result hash. The same run reproduces the same outcome. No silent mis-merges, no untraceable changes.
• ⚖️ Conflicts freeze, you decide (opt-in) — when two memories contradict, it does not take sides for you. The suspected conflict is parked for review, compared side-by-side in the status-page conflict queue, and resolved with one click (keep A / keep B / mark reviewed). On hard judgments, a human stays in the loop.
• 🔐 Memories isolated by agent & workspace (opt-in) — with scopeEnabled, every memory is stamped with which agent wrote it and in which workspace; retrieval favors the current scope (weighted hits, out-of-scope demoted but visible); strictScope goes further — memories explicitly scoped to other agents/workspaces become invisible to search and injection (auto carrier labels are demoted only, never hard-blocked). Multiple agents and projects, zero cross-talk.
• 🌙 It works while you sleep (opt-in) — idle time triggers tiered archiving: frequent memories stay hot, stale ones compress to summaries, old ones archive. The store stays lean as it grows.
• 🧠 Local semantic search, offline by default — built-in local Embedding + reranking. No API key required; retrieval still works without a network.
• 📝 Two-way Markdown sync — memories are local .md files you can open and edit; human edits are respected, never clobbered by the machine.
• 💾 Delete the session ≠ delete the memory — clearing a chat window keeps what was saved (configurable).

5-minute quickstart

# Install the plugin
dsh plugin --profile web add @modusensus/dsh-mneme
dsh web

It works out of the box. To feel its value in five minutes:

1. Chat — start a session and tell the AI something about your preferences or a project (e.g. "I prefer 4-space indentation.").
2. Verify — close the window, open a new one. If it recalls what you said, the memory has landed.
3. Tune — open Settings → Memory Settings and flip the three switches below as needed.

Quick config (optional)

Need	Config key	Default	Change
Fully offline	embedProvider	openai	Change to local
Keep memories when deleting sessions	sessionLifecycleEnabled	false	Change to true
Structured entity extraction	entityExtractionEnabled	false	Change to true
Memory isolation per agent / workspace	scopeEnabled (add strictScope for stronger isolation — hard blocking applies to explicit declarations only)	false	Change to true

All of these live in DSH Settings → Memory Settings. Full config docs in the Configuration section (Chinese, bilingual file).

The memory loop in one diagram

  write ──► quality filter (drop noise first)
    │
    ▼
  SQLite + local Markdown mirror
    │ (when idle)
    ├─ autoDream   : dedupe / merge / archive / fix / freeze-conflict
    └─ Sleep Mode  : tiered compression + pattern discovery + relation completion (opt-in)
    │
    ▼
  recall (hybrid search + rerank) ──► inject into the conversation

Screenshots

The panel is bilingual and follows your DSH interface language. English shots below; see the Chinese section for the localized UI.

Record, browse and filter your memories.

Entities are extracted from your memories, building a relation graph with attributes.

The status panel shows your vector index, LLM spend and consolidation activity at a glance.

Retrieval, entity extraction and consolidation toggles are all configured in one place.

Optional write-protect token and feedback channels for a fully local, auditable setup.

Privacy

• Data stays on your machine only, never uploaded
• Memories are Markdown files, human-readable and editable
• Zero network dependency by default, no API key required
• No telemetry, no analytics, no remote logging

Use it in other AI tools (MCP)

The plugin ships a zero-dependency stdio MCP server (standalone npm package mneme-memory, bin mneme-mcp). Any MCP client can mount the six memory tools (memory_save / memory_search / memory_list / memory_get / memory_update / memory_delete).

One-time prerequisites:

1. DSH is running with the plugin installed (the MCP data plane goes through the plugin's standalone API at 127.0.0.1:8790)
2. Generate a token in the DSH panel under Settings → External API

Per-client setup (replace <your-token> with the value from the previous step):

Client	Setup
Claude Code	Project-root .mcp.json: {"mcpServers": {"mneme-memory": {"command": "mneme-mcp", "env": {"MNEME_TOKEN": "<your-token>"}}}}
Cursor	Settings → MCP → Add Server; command mneme-mcp, env MNEME_TOKEN
Codex	~/.codex/config.toml: [mcp_servers.mneme-memory] section, command = "mneme-mcp", env = { MNEME_TOKEN = "<your-token>" }
Hermes	mcp_servers: section of ~/.hermes/config.yaml: mneme-memory: {command: "mneme-mcp", env: {MNEME_TOKEN: "<your-token>"}}, then restart
OpenCode	opencode.json: {"mcp": {"mneme-memory": {"type": "local", "command": ["mneme-mcp"], "environment": {"MNEME_TOKEN": "<your-token>"}}}}
OpenClaw	openclaw mcp add mneme-memory --command mneme-mcp --env MNEME_TOKEN=<your-token>, or Control UI → Settings → MCP

Legacy mounts keep working: dsh-mneme-mcp + DSH_MNEME_TOKEN remain supported (both the bin and env vars are preserved; no migration needed). If the npm package is not installed globally, use npx as the command with args -p mneme-memory mneme-mcp (an args array in Claude Code/OpenCode; args = ["-p", "mneme-memory", "mneme-mcp"] in Codex). Full config details and security notes: full docs (Chinese).

Docs

Doc	Path
Full plugin docs (features / install / config / architecture)	dsh-mneme/README.md (Chinese)
stdio MCP server — plug the six memory tools into any MCP client (Claude Code / Cursor / …)	dsh-mneme/README.md · MCP Server (Chinese)
Entity structure design	dsh-mneme/docs/ENTITIES.md
Semantic architecture	dsh-mneme/docs/SEMANTIC.md
Local model guide	dsh-mneme/docs/LOCAL_MODEL.md
Changelog	dsh-mneme/CHANGELOG.md
Security	SECURITY.md

🗺️ Roadmap

🧬 Gene → 🛡️ Audit hardening → 💤 Sleep maintenance → 🕸️ Recall fusion & graph → ✨ Panel enhancement → 🌡️ Self-evolving memory → 🔐 Scope isolation

Version	Theme	Status
v0.3	Gene: entities / time-boxed attributes / relations	✅
v0.4	Sleep Mode: idle 4-phase deep maintenance	✅
v0.5	Recall fusion & visualization: BM25 + graph + hot memory	✅
v0.6	Session lifecycle: delete session ≠ delete memory	✅
v0.7	Self-evolving memory: heat decay + sleep dual-protection + desktop workbench/feature toggles	✅
v0.8	Scope isolation (agent/workspace stamping + retrieval weighting + opt-in hard filter) + conflict review queue + explicit attribution + ecosystem (stdio MCP server / graph recall axis / cold-start bootstrap / injection truncation & status bar / distill reliability / injection shaping & agent-driven organize)	✅ Released (up to v0.8.6)

Full per-minor-version changelog in CHANGELOG.

🧪 Local development

cd dsh-mneme && npm install
npm test        # 1317 tests
npm run stress  # three-axis stress test
npm run sync    # src → lib sync

---

Acknowledgements

Provenance of the autoDream concept (ideas credited, implementation original):

• Auto Dream in Claude Code (Anthropic, Memory 2.0): the conceptual origin — a background sub-agent consolidates memory files between sessions (dedupe, resolve contradictions, prune decay).
• Sleep-time Compute: Beyond Inference Scaling at Test-time (UC Berkeley & Letta, arXiv:2504.13171): the academic thread behind the offline-consolidation idea.
• cc-haha: an early reference for the implementation approach.

On top of these, dsh-mneme adds its own engineering: K-Means++ cluster pre-grouping, a typed decision list (keep / merge / archive / conflict / update, plus supersede / differentiate on the sleep side), and a replayable sha256-digest audit chain (dream_runs / receipt_chain). If any source of inspiration is missing, please open an issue.

📜 License

MIT