mcp-super-memory 0.10.1 → 0.10.3

package/README.md

@@ -46,9 +46,9 @@ Key Space (concepts)         Value Space (memories)
 [strawberry]────┘
 ```
 
-Search `"Newton"` → matches `[Newton]`, `[apple]` keys (1-hop) → follows shared `[fruit]` key → reaches strawberry memory (2-hop, score decayed by 0.3×).
+`recall("Newton")` returns matching key clusters such as `[Newton]` and `[apple]`, not memory content. The agent then navigates explicitly: `read_key(apple)` → select the Newton memory → `read_memory(...)` → discover its `[fruit]` key → `read_key(fruit)` → select the strawberry memory.
 
-**Results include `hop` field** — you always know if a result is direct or associative.
+The default MCP flow is therefore **Key → Memory → Key**. Full memory content enters the model context only when the agent deliberately calls `read_memory()`.
 
 ---
 
@@ -57,6 +57,7 @@ Search `"Newton"` → matches `[Newton]`, `[apple]` keys (1-hop) → follows sha
 | Feature | Super Memory | A-MEM | Mem0 | MemGPT |
 |---------|-------------|-------|------|--------|
 | Key/Value separation | ✅ N:M | ❌ | ❌ | ❌ |
+| Agent-driven Key → Memory navigation | ✅ built-in | ❌ | ❌ | ❌ |
 | Associative multi-hop | ✅ built-in | ❌ | ❌ | ❌ |
 | Depth system | ✅ | ❌ | ❌ | partial |
 | Memory versioning | ✅ supersede | overwrites | overwrites | ❌ |
@@ -113,26 +114,37 @@ Add key "파이썬"  → finds existing "Python" (similarity 0.87 > threshold 0.
 
 Prevents key space fragmentation. Same concept across languages or phrasing stays unified.
 
-### Hybrid Retrieval (BM25 + dense, RRF-fused)
+### Agent-driven Retrieval (default)
 
-Recall is not a single similarity scan. Three signals run in parallel and are fused with **Reciprocal Rank Fusion** (`RRF_K = 60`):
+The default MCP API keeps Key Space and Value Space separate:
+
+1. `recall(query)` searches canonical keys and aliases. It returns key IDs, concept labels, match scores, linked-memory counts, hub status, and specificity — never memory content.
+2. `read_key(key_id)` returns ranked memory IDs and metadata, never content. Hub keys are paginated with `limit`/`offset` so broad concepts cannot flood context.
+3. `read_memory(memory_id, via_key_id)` returns the full memory plus every connected key cluster. Only this full read increases memory depth/access count; only the traversed `via_key_id` edge receives Hebbian reinforcement.
+4. The agent follows any returned key with another `read_key()` call, producing an explicit **Key → Memory → Key** graph walk.
+
+Semantically merged keys are preserved as aliases on one canonical key cluster (for example `Python` + `파이썬`). A key linked to at least three active memories is surfaced as a hub with `is_hub`, `memory_count`, and `specificity` metadata rather than being hidden by IDF. Override the threshold with `SUPER_MEMORY_KEY_HUB_MIN_LINKS`.
+
+### Direct Hybrid Retrieval (optional compatibility mode)
+
+Set `SUPER_MEMORY_DIRECT_RECALL=true` to expose `recall_memories()`, the previous one-call memory retrieval path. Three signals run in parallel and are fused with **Reciprocal Rank Fusion** (`RRF_K = 60`):
 
 - **BM25 (sparse):** lexical full-text search over memory content (MiniSearch, fuzzy + prefix). Catches exact terms, names, and rare tokens that embeddings blur.
 - **Dense Path A (key matching):** query embedding → match keys → follow links → memories. Score = `keySim × IDF × linkWeight`, summed across all matching keys.
 - **Dense Path B (content matching):** query embedding → directly compare against memory content embeddings. Finds memories even when they weren't tagged with the right keys.
 
-Sparse and dense rank lists are merged by RRF, then modulated by depth and time before 2-hop expansion. Combining lexical and semantic signals is more robust than either alone.
+Sparse and dense rank lists are merged by RRF, then modulated by depth and time before configurable multi-hop expansion (`hops=1–5`, default `2`). This compatibility tool is hidden by default so agents use explicit key navigation instead of collapsing the graph into one search call.
 
 ### Hebbian Link Learning
 
-Recall is a **write**, not just a read. Every recall reshapes the graph:
+Reading a full memory is a **write**, not just a read. In the default flow, `recall()` and `read_key()` are read-only; `read_memory(memory_id, via_key_id)` reshapes the selected path:
 
-- Links whose key **actually matched the query** and led to a **returned** memory are **reinforced** (`+0.1`, capped at `3.0`).
-- Links explored (matched key) but whose memory was **not returned** are **decayed** (`−0.005`, floored at `0.1`).
+- The traversed `via_key_id → memory_id` link is **reinforced** (`+0.1`, capped at `3.0`).
+- Memory depth and access count increase only after the agent reads the full memory.
 
-Reinforcement is scoped to the keys that *fired* for this query — not to every key of a returned memory. This is the literal Hebbian rule ("fire together, wire together") and it matters: reinforcing a returned memory's unrelated keys would let a stray association grow every time that memory surfaced for a *different* key, slowly polluting the graph. Weights are clamped to `[0.1, 3.0]`, so a hot memory's pull is bounded and the graph can recover from a bad reinforcement via subsequent decay.
+Reinforcement is scoped to the key the agent actually traversed — not every key attached to the memory. This is the literal Hebbian rule ("fire together, wire together") and prevents unrelated associations from growing when the memory is reached through a different concept. Weights are clamped to `[0.1, 3.0]`.
 
-Link weights feed directly back into scoring (`keySim × IDF × linkWeight`), so connections that repeatedly co-fire grow stronger and stale ones fade — the graph learns which associations actually matter from access patterns.
+Link weights feed back into `read_key()` ranking, so repeatedly selected paths become easier to reach. Optional `recall_memories()` retains the previous matched-link reinforcement and explored-link decay behavior.
 
 ---
 
@@ -155,7 +167,15 @@ Link weights feed directly back into scoring (`keySim × IDF × linkWeight`), so
 └─────────────────────────────────────────────────────────┘
 ```
 
-**Recall algorithm (hybrid, 2-hop):**
+**Default MCP navigation:**
+
+1. Embed the query and match canonical key concepts plus exact aliases.
+2. Return key clusters with `memory_count`, `is_hub`, and `specificity`; do not return memory content.
+3. Rank a selected key's memory handles by link weight, depth, and time decay in `read_key()`.
+4. Return full content and adjacent key clusters from `read_memory()`; reinforce only the traversed edge.
+5. Repeat `read_key(next_key_id)` to walk the graph deliberately.
+
+**Optional `recall_memories()` algorithm (hybrid, configurable 1–5 hops; default 2):**
 
 Three retrieval signals run in parallel, then get fused and expanded:
 
@@ -166,7 +186,7 @@ Three retrieval signals run in parallel, then get fused and expanded:
 5. **Depth & time modulation:** `score × (0.9 + depth × 0.1) × timeFactor`, where `timeFactor` is a depth-weighted 30-day half-life decay (deep memories decay slower).
 6. **Associative expansion (`hops`, default 2):** breadth-first from the directly-matched set — each round follows shared keys (`× HOP_DECAY(0.3) × IDF × linkWeight`) and explicit `related_to` links (bidirectional, `× HOP_DECAY`) to the next frontier. `hops=N` walks up to N steps, so a memory's `hop` is its shortest chain distance. Score decays by `HOP_DECAY` per hop.
 7. **Hebbian update:** reinforce matched-key links of returned memories (`+0.1`), decay explored-but-unreturned links (`−0.005`).
-8. Return ranked results with `hop` field (`1` = direct, `2` = associative).
+8. Return ranked results with `hop` field (`1` = direct, `2+` = associative distance).
 
 ### Similarity thresholds (calibrated per embedding model)
 
@@ -194,19 +214,19 @@ SUPER_MEMORY_MEMORY_DEDUP=0.99
 
 | Env var | Default (profile) | Description |
 | --- | --- | --- |
-| `SUPER_MEMORY_MIN_SCORE` | per-model (e.g. `0.55` for bge-m3) | Absolute cosine floor for recall. Effective on well-separated models (bge-m3 / bge / openai) where unrelated queries fall well below related ones. Set to `0` to disable. |
-| `SUPER_MEMORY_GATE_Z` | per-model (e.g. `2.5` for e5, `0` for others) | Distribution gate threshold (robust-z, median/MAD). The top-hit cosine must be at least this many MAD-sigmas above the median of the query's similarity distribution to count as "found". `0` disables the gate. |
-| `SUPER_MEMORY_CONTRADICTION` | per-model (e.g. `0.80` for bge-m3) | Contradiction-band lower bound. Memory pairs whose cosine similarity falls in `[contradiction, memoryDedup)` are flagged as contradictions. `recall()` and `related()` results include a `contradicts` string array listing conflicting memory IDs. |
+| `SUPER_MEMORY_MIN_SCORE` | per-model (e.g. `0.55` for bge-m3) | Absolute cosine floor for optional `recall_memories()`. Set to `0` to disable. |
+| `SUPER_MEMORY_GATE_Z` | `0` by default | Opt-in distribution gate for `recall_memories()` (robust-z, median/MAD). Values around 2–5 are typical; `0` disables it. |
+| `SUPER_MEMORY_CONTRADICTION` | per-model (e.g. `0.80` for bge-m3) | Contradiction-band lower bound. Memory pairs whose cosine similarity falls in `[contradiction, memoryDedup)` are flagged as contradictions. `read_memory()`, `related()`, and optional `recall_memories()` expose conflicting IDs. |
 
-**Why e5 needs the distribution gate:** multilingual-e5's narrow cosine band (~0.86–0.99) makes the absolute `min_score` gate largely inert — both related and unrelated queries land in the same range, so a static floor cannot separate them. The **distribution gate** instead checks whether the top hit is a robust outlier within that query's own distribution. A query with no good match produces a flat similarity band (low robust-z) and is gated out; a query with a real match produces a clear right-tail outlier (high robust-z) and passes.
+**Why e5 gates are opt-in:** multilingual-e5's narrow cosine band (~0.86–0.99) makes a static floor unreliable, while held-out tests showed distribution and key-proximity gates can also overfit. Both are disabled by default to avoid hiding real memories. Use bge-m3 for reliable not-found behavior, or calibrate e5 gates on your own corpus.
 
 Distribution gate parameters:
-- **`gateZ`** (profile default, e.g. `2.5` for e5) — set via `SUPER_MEMORY_GATE_Z` env var or the `min_z` parameter of `recall()`.
+- **`gateZ`** — set via `SUPER_MEMORY_GATE_Z` or the `min_z` parameter of optional `recall_memories()`.
 - **`0` disables** the gate (default for bge-m3, bge, openai, minilm — where `min_score` already works).
 - Both gates **compose (AND)**: a result must clear both `min_score` and `gateZ` to be returned.
 - A **literal name/proper-noun key match** (e.g. querying a stored `name`-typed key exactly) is always a definite anchor and bypasses the distribution gate.
 - **`GATE_MIN_POPULATION = 8`**: the gate is skipped when fewer than 8 memories exist (too few samples for a reliable distribution), so early-session recall is unaffected. The gate's background population is **namespace-filtered** and excludes superseded/expired memories, so recall scoped to a sparse namespace may fall below this threshold and skip the gate entirely.
-- **Known e5 limitation:** the gate keys off `maxContentSim` (content cosine only). A genuinely-relevant hit that anchors solely via a fuzzy (non-literal) key match but produces a flat content distribution may be gated out on e5. This is intentional — the gate overrides weak fuzzy-key anchors; only literal key matches (`memRawSim ≥ 0.999`, i.e. exact name/proper-noun hits) are protected via `definiteAnchor` and bypass the distribution gate regardless of `distOK`.
+- **Known e5 limitation:** the optional gate keys off `maxContentSim` (content cosine only). A relevant fuzzy-key hit with a flat content distribution may be rejected; literal key matches bypass the gate.
 
 An uncalibrated `LOCAL_EMBEDDING_MODEL` falls back to the BGE profile **and logs a warning** so the miscalibration is never silent.
 
@@ -216,11 +236,13 @@ An uncalibrated `LOCAL_EMBEDDING_MODEL` falls back to the BGE profile **and logs
 
 ## MCP Tools
 
-The memory system exposes 10 tools via MCP:
+The memory system exposes 12 tools by default:
 
 | Tool | Description |
 | --- | --- |
-| `recall(query, top_k, namespace?, expand?, hops?, min_rel_score?, min_score?, min_z?, min_key_gate?, min_depth?)` | Hybrid search (BM25 + dense key/content, RRF-fused) with associative traversal. `hops` sets depth (default 2; 1=direct, up to 5 for chained drill-down — one call replaces manual `related()` chaining). For complex/multi-fact questions, **decompose into focused sub-queries and call recall per sub-query, then merge** (a single broad query blurs concepts). `min_rel_score` (0–0.9, default 0) drops results below that fraction of the top score — set ~0.05 with deep `hops` to trim hub-key noise. `min_score` (0–1, overrides `SUPER_MEMORY_MIN_SCORE`) is an absolute cosine floor; `0` disables. `min_z` (≥0, overrides `SUPER_MEMORY_GATE_Z`) is the distribution gate threshold; `0` disables. **`min_depth` (0–1, default 0)** returns only well-established memories whose depth ≥ floor — surface frequently-confirmed/important facts only. Returns `[]` when nothing clears the active gates. Results include a `contradicts` array. |
+| `recall(query, top_k?, namespace?)` | Search Key Space only. Returns canonical keys, aliases, scores, and hub metadata; never memory content. |
+| `read_key(key_id, namespace?, limit?, offset?)` | List ranked memory IDs and metadata connected to one key. Never returns content; supports pagination for hubs. |
+| `read_memory(memory_id, via_key_id?, namespace?)` | Read full memory content and connected keys. Increases depth/access and reinforces the traversed edge. |
 | `remember(content, keys, key_types?, namespace?, ttl_seconds?, related_to?)` | Save memory with key concepts and optional type annotations |
 | `correct(memory_id, content, keys?, key_types?, related_to?)` | Versioned update — old memory preserved but weakened |
 | `related(memory_id)` | Find memories sharing keys (associative exploration) |
@@ -231,6 +253,8 @@ The memory system exposes 10 tools via MCP:
 | `cleanup_expired()` | Delete memories whose TTL has expired |
 | `memory_stats()` | Get current key/memory/link counts |
 
+Set `SUPER_MEMORY_DIRECT_RECALL=true` to expose a thirteenth compatibility tool, `recall_memories(...)`, with the previous BM25+dense+RRF multi-hop behavior.
+
 A system prompt template is also available via `memory_system_prompt` MCP prompt — include it to instruct the agent to recall silently, use diverse keys, and never mention the memory system to users.
 
 ---
@@ -256,7 +280,7 @@ Add to `claude_desktop_config.json`:
 }
 ```
 
-**Local embeddings (no API key required):**
+**Local embeddings (no API key required) — bge-m3 recommended:**
 ```json
 {
   "mcpServers": {
@@ -264,21 +288,24 @@ Add to `claude_desktop_config.json`:
       "command": "npx",
       "args": ["-y", "mcp-super-memory"],
       "env": {
-        "EMBEDDING_BACKEND": "local"
+        "EMBEDDING_BACKEND": "local",
+        "LOCAL_EMBEDDING_MODEL": "bge-m3"
       }
     }
   }
 }
 ```
 
+> `bge-m3` (multilingual, recommended) **auto-downloads ~570MB on first run**, then caches. Omit `LOCAL_EMBEDDING_MODEL` for the lighter default (`fast-multilingual-e5-large`). Add `"SUPER_MEMORY_RERANK": "true"` to enable cross-encoder reranking (downloads a second model on first use).
+
 ### Claude Code
 
 ```bash
 # OpenAI embeddings
 claude mcp add mcp-super-memory -e OPENAI_API_KEY=your-openai-api-key -- npx -y mcp-super-memory
 
-# Local embeddings (no API key required)
-claude mcp add mcp-super-memory -e EMBEDDING_BACKEND=local -- npx -y mcp-super-memory
+# Local embeddings (no API key required) — bge-m3 recommended (auto-downloads ~570MB on first run)
+claude mcp add mcp-super-memory -e EMBEDDING_BACKEND=local -e LOCAL_EMBEDDING_MODEL=bge-m3 -- npx -y mcp-super-memory
 ```
 
 ### Manual / Development
@@ -313,18 +340,29 @@ LOCAL_EMBEDDING_MODEL=bge-m3
 
 > First run downloads ~570MB once, then reuses the cache. If `LOCAL_EMBEDDING_MODEL_PATH` already holds the model it is used **as-is with no download** (a partial dir is self-healed — only missing files are fetched). Online-API backends (OpenAI) and fastembed built-ins are unaffected.
 
-**Cross-encoder reranking (optional):** set `SUPER_MEMORY_RERANK=true` to re-score recall's top candidates with `bge-reranker-v2-m3` — a joint query↔memory relevance model that fixes cases where the right memory is retrieved but ranked too low. The model (~570MB, quantized) **auto-downloads on first use** and caches under `~/.super-memory/models/reranker` (its tokenizer is shared with bge-m3). It is a model, not an LLM, so it runs in-process.
+**Cross-encoder reranking (optional direct mode):** set `SUPER_MEMORY_DIRECT_RECALL=true` and `SUPER_MEMORY_RERANK=true` to re-score `recall_memories()` candidates with `bge-reranker-v2-m3`. The default key-navigation flow does not load the reranker. The model (~570MB, quantized) auto-downloads on first use and caches under `~/.super-memory/models/reranker`.
 
 ```
 SUPER_MEMORY_RERANK=true
+SUPER_MEMORY_DIRECT_RECALL=true
 # optional: SUPER_MEMORY_RERANK_MODEL_PATH=/dir   SUPER_MEMORY_RERANK_POOL=30  (candidates re-scored)
 ```
 
-> Off by default. If the model can't load, recall transparently falls back to its fused ranking (never breaks). Most useful for multi-fact / competing-candidate queries; single-fact recall is already strong without it. (Note: query *decomposition* — splitting a complex question into sub-queries — is the **caller's** job, since that needs LLM reasoning; the reranker is the server-side precision pass.)
+> Off by default. If the model cannot load, `recall_memories()` falls back to fused ranking. Query decomposition remains the caller's responsibility.
+
+**Reranker not-found gate (`SUPER_MEMORY_RERANK_MIN_SCORE`):** in direct compatibility mode, reject the complete `recall_memories()` result when the top cross-encoder logit is below this floor.
+
+```
+SUPER_MEMORY_RERANK=true
+SUPER_MEMORY_DIRECT_RECALL=true
+SUPER_MEMORY_RERANK_MIN_SCORE=0   # reject when top rerank logit < 0 (bge-reranker-v2-m3 scale)
+```
+
+> ⚠️ **Caveats.** (1) Unset by default — no gate. (2) The logit scale is **model-dependent**; `0` (≈ sigmoid 0.5) suits `bge-reranker-v2-m3` (measured: same-language found ≈ +3.9, not-found ≈ −5 to −6) — recalibrate for other rerankers. (3) **Trusted for SAME-LANGUAGE only.** Cross-lingual relevance logits run low even when relevant (KR query ↔ EN memory ≈ −5.4), so the gate auto-**bypasses on a script mismatch** (KR↔Latin) to avoid false-rejecting cross-lingual hits — which means **cross-lingual content must be reachable via bilingual keys** (`["Jiwoo","지우"]`), and cross-lingual *not-found* precision is a known limitation. Leave this off if you can't tag bilingual keys.
 
 > **Prefix behavior:** BGE-M3 does **not** use `passage:`/`query:` prefixes — embeddings are passed through as-is. All other local models (e5, BGE-en, MiniLM) continue to use prefixes unchanged.
 
-> **Recommended for multilingual / cross-lingual use: `bge-m3`.** On a real 19-memory Korean graph, English natural-language queries against Korean content land the correct memory at rank #1 in **7/7** cases under bge-m3 versus **2/7** under e5 (e5 leans on literal BM25 token overlap, so an English query sharing no tokens with Korean content is buried below noise). bge-m3 also separates found from not-found cleanly via the absolute `min_score` gate (≈96% on the gate fixture), whereas e5 needs the gate disabled entirely. Use e5 only if you cannot supply the bge-m3 ONNX model.
+> **Recommended for multilingual / cross-lingual use: `bge-m3`.** It separates unrelated queries more reliably and performs substantially better than e5 on the project's Korean↔English fixtures. In optional direct mode, bge-m3's absolute `min_score` gate reaches ≈96% on the gate fixture; e5 requires corpus-specific tuning.
 
 If `OPENAI_API_KEY` is not set and `EMBEDDING_BACKEND` is unset, the server automatically uses the local `fastembed` backend.
 For English-only use or lower local resource usage, set `LOCAL_EMBEDDING_MODEL=fast-bge-base-en-v1.5` or `fast-bge-small-en-v1.5`.
@@ -353,7 +391,7 @@ All data is local. No external database required.
 
 ```
 ~/.super-memory/
-├── graph.json          # keys, memories, links
+├── graph.json          # canonical keys, aliases, memories, weighted links
 └── conversations/
     └── {session_id}.jsonl   # original conversation turns
 ```
@@ -365,7 +403,8 @@ Set `SUPER_MEMORY_DATA_DIR` to use a different storage directory.
 ## Limitations
 
 - **Linear scan** — suitable for personal use (~10k memories). FAISS/ChromaDB integration planned for larger scale.
-- **2-hop max** — deeper associative chains require `related()` tool calls by the agent.
+- **Agentic round trips** — the default `recall → read_key → read_memory` flow is more controllable and context-efficient, but needs more tool calls than one-shot retrieval.
+- **Hub breadth** — broad keys can connect many memories. `read_key()` paginates hubs; the agent must choose whether to continue paging or follow a more specific adjacent key.
 - **Agent quality matters** — key selection on `remember` affects retrieval quality. System prompt tuning is important.
 - **Cross-lingual content bias** — with multilingual e5, raw content similarity favors same-language memories regardless of meaning. Tag memories with multilingual keys so the key graph (not biased content cosine) carries cross-lingual recall.
 - **Threshold calibration** — thresholds are tuned per embedding model. A new/uncalibrated model falls back to the BGE profile (with a warning); recalibrate via the `SUPER_MEMORY_*` env overrides.

package/dist/memoryGraph.d.ts

@@ -12,6 +12,8 @@ export declare class MemoryGraph {
     private _storedDim;
     private _storedFingerprint;
     private _lock;
+    private _saveLock;
+    private _saveSeq;
     private _dirty;
     private _bm25;
     constructor();
@@ -33,6 +35,9 @@ export declare class MemoryGraph {
     private _isExpired;
     private _timeFactor;
     private _keyIdf;
+    private _recordKeyAlias;
+    private _activeMemoryIdsForKey;
+    private _keyView;
     private _findDuplicate;
     private _findContradiction;
     private _autoLinkKeys;
@@ -57,6 +62,13 @@ export declare class MemoryGraph {
         namespace?: string | null;
         relatedTo?: string[] | null;
     }): Promise<string>;
+    searchKeys(query: string, topK?: number, namespace?: string | null): Promise<object[]>;
+    readKey(keyId: string, options?: {
+        namespace?: string | null;
+        limit?: number;
+        offset?: number;
+    }): object;
+    readMemory(memoryId: string, viaKeyId?: string | null, namespace?: string | null): Promise<object>;
     recall(query: string, topK?: number, namespace?: string | null, expand?: boolean, maxHops?: number, minRelScore?: number, minScore?: number, minZ?: number, minKeyGate?: number, minDepth?: number): Promise<object[]>;
     getRelated(memoryId: string): object[];
     delete(memoryId: string): Promise<boolean>;

package/dist/memoryGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memoryGraph.d.ts","sourceRoot":"","sources":["../src/memoryGraph.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"memoryGraph.d.ts","sourceRoot":"","sources":["../src/memoryGraph.ts"],"names":[],"mappings":"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"}