Memory Dream Engine MCP (memory-dream-engine) — let your agent's memory sleep on it

What it is

Your AI forgets everything the moment the conversation ends. Not because it is stupid — because it never dreams. Humans use sleep to turn the day's fragments into long-term memory: filter noise, reinforce what recurs, connect related things. Most agent memory layers do only the first step, "store", and none of the rest.

You lose at both ends: experience that should settle never settles (the same class of mistake repeats), and noise that should have been dropped piles up until the store crowds out the context window and buries what mattered.

Other servers: Content Router MCP · Memory Dream Engine MCP · Content Pattern Radar MCP · GEO MCP · China AI Compliance MCP · AI Customer Service MCP · All MCP servers

Deployment

Local stdio (open source) · registry: cn.savantcat/memory-dream-engine

Zero third-party dependencies · Pure Python standard library · Read-only

How it works — it sleeps like you do

        +-- Light sleep -- SignalCollector   four signal types (decision / correction / tool / insight)
        |
one  ---+-- Deep sleep  -- SignalScorer      three-dimensional scoring, weights adapt per signal type
cycle   |                 MemoryWriter      dedupe + merge + replace, declarative writes
(180m)  |
        +-- REM ---------- SproutDetector    3 items -> short post / 5 items -> long-form article
                          ^
                    MemoryOptimizer  deep clean every 3 cycles (dedupe / expire / compress)

One cycle per sleep period. Light sleep only collects and never judges; deep sleep decides whether something deserves long-term memory; REM notices that a batch of memories is related.

Tools (6, all read-only)

Tool	What it does
`extract_facts`	Zero-LLM fact extraction (pure regex, Chinese and English)
`score_signal`	Three-dimensional scoring plus the verdict on whether to write to long-term memory
`decay_report`	Ebbinghaus decay: current strength, reinforcement on access, archive verdict, full curve
`simulate_dream`	Runs a complete five-stage cycle over a piece of text and returns the report (temp store, destroyed afterwards)
`list_signal_types`	The four signal types: definitions, weights and scoring keywords
`engine_info`	Capability overview, trade-offs against comparable approaches, service boundaries

Purely computational and read-only: all four annotation hints declared, no API key required, and none of your data is stored.

Four design decisions

Capability	Why it matters
Zero-LLM extraction	Pure regex, Chinese and English. Extracting ten thousand facts costs zero tokens — memory housekeeping should not be billed per token.
Ebbinghaus decay	30-day half-life; frequent access reinforces, low strength auto-archives. Memory slims itself down.
Three-dimensional scoring	Decision signals are judged on durability, correction signals on how much they correct, tool signals on reuse. Not one yardstick for everything.
Content sprouting	When a batch of memories reaches 3 or 5 items, it flags "this batch is ready to become a piece".

How to use it

This is an open-source, locally deployed MCP (pure Python standard library, zero third-party dependencies). Clone it and wire it into your client:

git clone https://github.com/savantcat/memory-dream-engine.git
cd memory-dream-engine
python server.py                                     # stdio (Claude Desktop / Cursor / any MCP client)
python server.py --transport http --port 8770        # self-hosted streamable-http
python server.py --selftest                          # bypass the protocol and hit every tool

Client configuration (stdio):

{
  "mcpServers": {
    "memory-dream-engine": { "command": "python", "args": ["server.py"] }
  }
}

Published to the official MCP Registry as cn.savantcat/memory-dream-engine. To see it before committing, call simulate_dream with any text: it runs the full cycle and hands you the report from a temporary store that leaves nothing behind.

Honest boundaries

It is a memory scheduler, not a knowledge base. It decides what to keep, how long, and when to tidy — it does not do full-text retrieval or question answering. That is the knowledge base's job.

Zero LLM. Extraction and scoring are deterministic rules, no model calls. The upside is zero cost and reproducibility; the cost is no semantic understanding — the same idea in different words will not be merged.
Stores none of your data. simulate_dream runs in a temporary store destroyed on exit; it neither accepts nor hosts your memory store.
Decay parameters need calibrating per scenario. The 30-day half-life was tuned for individual and small-team knowledge accumulation; another setting needs re-calibration.
Watch write permissions when wiring it into an agent. In many frameworks, scheduled-task subprocesses lack memory write permission, so scoring works while writes fail silently — the report keeps showing "stage 3: write — blocked". That is the runtime lacking permission, not a broken engine.
Method published. list_signal_types and engine_info return the signal definitions, weights and boundaries so you can check them yourself.

Your AI ran for a year — how much did it actually retain?

Long-term memory scheduling · knowledge base build · AI customer service

Run the free AI visibility self-check

Or see how an enterprise knowledge base is built →

Citation and licensing

This server is open source (MIT) and read-only; agents and developers are welcome to call it. When citing our measurements, credit 合尘猫 SavantCat (savantcat.cn).