Mnemoscope
Demo · Workflow · Tools · Quickstart · Architecture · Science
The dominant 2025–2026 narrative on X —"Markdown trips up the LLM at scale" — is partially wrong. Markdown does not trip up the LLM. Long-context loading trips up the LLM (Chroma, Context Rot, July 2025). Mnemoscope is built on that distinction.
👀 See it in action
Real output, captured from the bundled examples/demo-vault — a 13-note synthetic vault built so every rot factor moves. Reproduce locally with mnemoscope-init examples/demo-vault (full transcript: SAMPLE-OUTPUT.md).
predict_rot — score, factors, top-risk notes
mnemoscope-verify — clean run vs. tamper detection
Related MCP server: auxly-memory-cli
✨ What is Mnemoscope?
Mnemoscope is not another memory store. It is an instrument that sits between your LLM agent and your Markdown vault and gives you three things nobody else gives you in one tool:
🎯 Predict the rot risk of a corpus before injection, with a citation-backed score across 5 factors.
📝 Witness every read and write your agent performs, in an Ed25519-signed, hash-chained journal that detects field-level tampering, deletion, and reordering.
🧱 Tier the corpus into a working / episodic / semantic hierarchy, drawing on the 2025–2026 science instead of the GraphRAG hype.
It ships as an MCP server (Claude Code, Cursor, ChatGPT desktop, anything MCP-compatible), an Obsidian plugin, and a Claude Code PostToolUse hook. Everything runs 100% locally. No cloud. No telemetry without explicit opt-in.
🔄 How it fits your workflow
Imagine you start a brand-new project — a folder of Markdown notes you'll grow with Claude Code over the next year. Mnemoscope plugs into the lifecycle in five places:
[create project]
│
▼
mnemoscope-init ◄─── 1× at the very start
│ creates .mnemoscope/, generates Ed25519 keypair
▼
┌───────────────────────────────────────────────────────────┐
│ [you work with Claude Code on the vault] │
│ │
│ predict_rot ──┐ │
│ ├─► on demand (or before sessions) │
│ get_tiered_read ──┘ "is the vault healthy?" │
│ "what should the agent read?" │
│ │
│ PostToolUse hook ────► passive, on every Write/Edit │
│ "what did the agent just do?" │
└───────────────────────────────────────────────────────────┘
│
▼
mnemoscope-verify ◄─── on demand, or in CI
"has anyone tampered?"Phase | Tool / command | When to use it | What you get |
1. Bootstrap |
| Once, at project creation |
|
2. Predict |
| Before injecting a vault into the LLM | A 0–100 risk score + factor breakdown + top-risk notes |
3. Compact |
| When the vault grows past your model's effective context | Working / episodic / semantic split |
4. Witness |
| Wired once in | Every agent write becomes a signed journal entry |
5. Audit |
| Any time, or as a pre-commit / CI step | Exit 0 if all entries verify, exit 1 if tampered |
🛠️ The four MCP tools
Tool | Input | What it returns |
|
| Score 0–100, dominant factor, full factor breakdown, top 5 risk notes, vault stats |
|
| Note paths grouped into |
|
| The signed entry, including its |
|
| All journal entries, or a single session's entries |
Example — predict_rot on a real vault
{
"rot_risk": 41,
"dominant_factor": "tokenVolume",
"factors": {
"tokenVolume": 100, "semanticRedundancy": 0,
"distractorDensity": 2.65, "structuralCoherence": 100, "freshnessSpread": 0
},
"top_risk_notes": [
{ "relPath": "brainstorms/.../transcript.md", "approxTokens": 13439, "reason": "very large note" },
{ "relPath": "brainstorms/.../sylvie-signaux.md", "approxTokens": 12605, "reason": "very large note" }
],
"vault_stats": { "noteCount": 113, "approxTokens": 506823 },
"baseline_model": "v0-heuristic",
"version": "0.1.0"
}🚀 Quickstart
git clone https://github.com/toonight/Mnemoscope
cd Mnemoscope
npm install
npm run build
npm test # 47 tests across core + mcp-server
npm audit # 0 vulnerabilities
# Make the CLI binaries available on your PATH
npm link --workspace @mnemoscope/cliBootstrap a vault
mnemoscope-init /path/to/your/vault
# → state dir, Ed25519 keypair, fingerprintAdd
.mnemoscope/to your vault's.gitignore— the per-vault private key must never be committed.
Connect the MCP server to Claude Code (or Cursor / any MCP client)
// ~/.claude/settings.json
{
"mcpServers": {
"mnemoscope": {
"command": "node",
"args": ["/absolute/path/to/Mnemoscope/packages/mcp-server/dist/index.js"]
}
}
}The four tools (predict_rot, get_tiered_read, record_journal, read_journal) become available to the agent immediately.
(Optional) wire the auto-journal hook
Asking the agent to call record_journal on every write is a recipe for forgetting. Wire the bundled hook instead:
// ~/.claude/settings.json
{
"hooks": {
"PostToolUse": [
{
"matcher": "Write|Edit|MultiEdit",
"hooks": [{ "type": "command", "command": "mnemoscope-record-hook" }]
}
]
}
}The hook resolves the vault root via MNEMOSCOPE_VAULT_PATH or by walking up to the closest .mnemoscope/ directory. It never blocks the tool call: any internal error is caught, logged to stderr, and the process exits 0. Full setup including safety properties: docs/claude-code-hook.md.
Verify the journal
mnemoscope-verify /path/to/vault
# ok 2026-04-26T19:42:13.001Z write /vault/notes/foo.md
# ok 2026-04-26T19:43:01.220Z write /vault/notes/bar.md
# 2 entries; 2 valid; 0 invalidmnemoscope-verify exits non-zero on any of:
field-level tampering (signature mismatch),
deletion or reordering (
prevHashchain break),entries signed by a key the current vault does not own.
(Optional) back up the per-vault private key
If you lose <vault>/.mnemoscope/keys/ed25519.key, the journal becomes unverifiable. The bundled backup CLIs encrypt the key with a passphrase (scrypt + AES-256-GCM, no extra deps) and let you restore it later:
mnemoscope-backup-key /path/to/vault /path/to/off-vault-backup.enc.json
# … prompts for a passphrase, writes chmod 0600 …
mnemoscope-restore-key /path/to/vault /path/to/off-vault-backup.enc.json
# … prompts for the same passphrase, writes the key back into the vault …Full flow including threat model: docs/key-escrow.md.
(Optional) anchor the journal in time with OpenTimestamps
The signed hash chain proves order. To prove absolute time and stay safe against retroactive rewrites if the per-vault key is ever compromised, anchor each entry's signature to a public Bitcoin-backed OTS calendar:
mnemoscope-timestamp /path/to/vault
# … POSTs SHA-256(sig) per entry to the calendar, writes .ots proofs
# under <vault>/.mnemoscope/timestamps/. Idempotent on re-run.Pending proofs are upgraded to fully self-verifying Bitcoin proofs with the upstream ots upgrade / ots verify CLIs — that part is intentionally not reimplemented. Full threat model and flow: docs/timestamping.md.
✅ What works today (v0.1.0)
What | How verified | |
✅ |
| 12 unit tests; smoke-tested on a real 506 K-token vault — sensible top-risk ordering |
✅ |
| integration test on fixture vault; freshness-based v0, access-frequency planned for v0.2 |
✅ |
| 9 journal tests, including 4 tamper tests + 2 chain-integrity tests (truncation, reordering) |
✅ |
| manual run on multiple fresh + existing vaults |
✅ |
| wired to the same |
✅ |
| docs/claude-code-hook.md, never blocks |
✅ |
| 7 unit tests, full flow in docs/key-escrow.md |
✅ |
| 12 unit tests + smoke-tested 3 entries → 3 |
✅ | MCP server passes 5 end-to-end tests over real JSON-RPC stdio |
|
✅ | Obsidian plugin: sidebar view with SVG rot gauge, factor bars, top-risk list, settings tab, auto-onboarding modal on first launch | 28 KB single-file bundle, no runtime deps |
✅ | Research sub-project: classifier (sklearn → ONNX), MarkdownMemBench v0.1 schema + sample dataset + harness, Chroma replication protocol with position-of-needle sweep | self-contained |
✅ | CI green on Node 22 + Python 3.11, 0 npm vulnerabilities, | GitHub Actions on every push and PR |
🏗️ Architecture
flowchart LR
A["Obsidian vault<br/>Markdown files"] --> B["mnemoscope/core<br/>signatures · rot · tiering · Ed25519 chained journal"]
B --> C["mnemoscope/mcp-server<br/>stdio MCP - 4 tools"]
B --> D["mnemoscope/obsidian-plugin<br/>UI · rot gauge"]
B --> G["mnemoscope/cli<br/>init · record-hook · verify"]
C -->|tools| E(("Claude Code<br/>Cursor<br/>ChatGPT desktop"))
G -->|PostToolUse hook| E
F["research/<br/>classifier · benchmark · replication"] -.->|trained ONNX classifier| B
style A fill:#1a2444,stroke:#a78bfa,color:#cbd5e1
style B fill:#0e1530,stroke:#5fd9d1,color:#cbd5e1
style C fill:#0e1530,stroke:#5fd9d1,color:#cbd5e1
style D fill:#0e1530,stroke:#5fd9d1,color:#cbd5e1
style G fill:#0e1530,stroke:#5fd9d1,color:#cbd5e1
style E fill:#1a2444,stroke:#7cf09d,color:#cbd5e1
style F fill:#1a2444,stroke:#fbbf24,color:#cbd5e1mnemoscope/
├── packages/
│ ├── core/ # rot scoring, tiering, Ed25519 hash-chained journal, signatures
│ ├── mcp-server/ # MCP server (stdio); 4 tools, integration-tested via spawn
│ ├── obsidian-plugin/ # Obsidian plugin: rot gauge, factor bars, top-risk list, settings
│ └── cli/ # mnemoscope-init, mnemoscope-record-hook, mnemoscope-verify
├── examples/
│ └── demo-vault/ # 13-note synthetic vault — every rot factor moves
├── research/ # Python (uv): classifier, MarkdownMemBench v0.1, Chroma replication
└── docs/ # banner, logo, claude-code-hook setup, demo page, screenshots🔐 The signed journal in one diagram
flowchart TD
K["Per-vault Ed25519 keypair<br/>.mnemoscope/keys/ed25519.key (mode 0600)"]
E1["Entry 1<br/>prevHash = GENESIS<br/>sig = σ1"]
E2["Entry 2<br/>prevHash = SHA256 of σ1<br/>sig = σ2"]
E3["Entry 3<br/>prevHash = SHA256 of σ2<br/>sig = σ3"]
K -->|signs| E1
K -->|signs| E2
K -->|signs| E3
E1 -.->|chain| E2
E2 -.->|chain| E3
style K fill:#1a2444,stroke:#a78bfa,color:#cbd5e1
style E1 fill:#0e1530,stroke:#5fd9d1,color:#cbd5e1
style E2 fill:#0e1530,stroke:#5fd9d1,color:#cbd5e1
style E3 fill:#0e1530,stroke:#5fd9d1,color:#cbd5e1Attack | Detected by |
Edit a field of any single entry | per-entry signature mismatch |
Delete an entry | next entry's |
Reorder two entries | both signatures still verify, but the chain breaks |
Forge an entry with a different key |
|
🤝 Voisins (not competitors)
Project | What it does | Where Mnemoscope sits |
Official, file-based, primitive | We add the rot scoring + signed chained journal Anthropic does not provide | |
Runtime-stateful agents | Different layer — we sit under the agent | |
Generic memory stores | Different scope — we are MD-vault-native | |
Viral OSS memory MCP | Not Obsidian-specific; complementary | |
RAG-vector for Obsidian | Co-installable; we are runtime / forensics, they are search | |
Semantic graph over markdown | Closest in spirit — we want to interop, not duplicate | |
MD-compiler approach | Reach out before duplicating |
If you maintain one of these projects and see overlap or complementarity, pleaseopen an issue — collaboration is the explicit design goal.
🔬 Scientific posture
Mnemoscope is meant to be a tool and a contribution to the public empirical record on agent memory.
Research thread | Status | Why it matters |
MarkdownMemBench v0.1 | 🟢 schema + sample dataset + harness shipping | Today's benchmarks (LongMemEval, LoCoMo) are conversational and English-only. There is no public bench for vault-native, MD-native agent memory. |
Predictive Context Rot classifier | 🟡 sklearn → ONNX pipeline working on synthetic baseline | Every existing benchmark measures degradation after injection. We aim to predict it before, calibrated against LongMemEval / LoCoMo / MarkdownMemBench with R² ≥ 0.6. |
Replication of Chroma's "structured > shuffled is worse" | 🟢 runner + offline & online grading shipping; real-corpus runs pending vault contributions | Chroma showed coherent haystacks underperform shuffled ones on NIAH. Nobody has replicated or refuted this on real Obsidian vaults yet. The runner ( |
Each thread lives in research/ and will produce a preprint alongside the code.
🛣️ Roadmap
Dogfood the auto-journal hook on the author's vault for two full weeks; tune heuristics against observed Claude Code session outcomes
Submit the MCP server to Smithery, PulseMCP, Glama — registry metadata files (
smithery.yaml,glama.json) already in this repoSet the repo's
NPM_TOKENsecret so thatgit tag v0.1.0 && git push --tagstriggers the release workflow that publishes@mnemoscope/{core,mcp-server,cli}to npm with provenanceSubmit the Obsidian plugin to community plugins
Replace the v0 heuristic rot score with the calibrated ONNX classifier (load via
onnxruntime-nodefromcoreas an optional dependency)Release MarkdownMemBench v1 with 50–200 contributed real vaults
Preprint #1: replication of Chroma Context Rot on real Obsidian vaults
Periodic remote attestation (timestamping the journal head with an external notary, OTS-style)
Full history: CHANGELOG.md.
🧑🤝🧑 Contributing
PRs are welcome but the most useful first step is opening an issue describing what you want to do. See CONTRIBUTING.md for code style and process.
If you are a researcher at Letta, Chroma, Mem0, Cognee, OSU-NLP, Snap Research or any related lab and you see overlap with the Predictive Context Rot or MarkdownMemBench axes, please reach out — the project is explicitly designed for this.
📜 License
Apache License 2.0. Apache-2.0 was chosen over MIT for its explicit patent grant, which we believe is appropriate for a project introducing novel scoring methods in an active research area.
🙏 Acknowledgements
Mnemoscope's framing borrows directly from public work by:
Without their public artifacts, this project would not be possible.
This server cannot be installed
Maintenance
Resources
Unclaimed servers have limited discoverability.
Looking for Admin?
If you are the server author, to access and configure the admin panel.
Related MCP Servers
- AlicenseAqualityAmaintenanceLocal-first agentic knowledge layer over Obsidian notes, enabling MCP-aware agents to search, retrieve, and compile knowledge with provenance and task contracts.37360MIT
- AlicenseNot gradedqualityAmaintenanceLocal-first, file-based memory layer for AI agents — one shared Markdown vault across Claude, Codex, Gemini, Cursor and any MCP client. Provides read/write memory tools with an audit trail, per-agent trust levels, and Git sync; no cloud and no lock-in.2MIT
- AlicenseNot gradedqualityBmaintenanceLong-term memory for AI agents over MCP — episodic + semantic memory, a temporal knowledge graph, and a dialectic user model, exposed as 32 tools (recall, remember, context, graph, dreaming, peers). Zero dependencies, runs fully offline; leads the LoCoMo benchmark at ~35x fewer LLM calls.2Apache 2.0
- AlicenseAqualityAmaintenanceGit-native long-term memory for AI agents: your markdown files are the source of truth, the search index is a disposable projection rebuilt from git, and every memory the agent writes is a reviewable git commit. Served over one OAuth-secured MCP endpoint with hybrid lexical+semantic recall and a gated, git-first commit_note write tool.78AGPL 3.0
Related MCP Connectors
Token-efficient MCP memory for Markdown vaults. Tiered search, GraphRAG, AI memories.
Persistent memory and knowledge graphs for AI agents. Hybrid search, context checkpoints, and more.
Durable wallet-addressed memory for AI agents: state that survives your process, opened by your key.
Latest Blog Posts
- Who's Calling? MCP Hosts Are an Identity Blind Spot (And the Spec Knows It)By Om-Shree-0709 on .mcpAgent IdentityOAuth 2.1
- Your AI Chatbot Just Exposed Your CEO's Salary to an InternBy Om-Shree-0709 on .Agent IdentityMCP SecurityOAuth Delegation
- Why MCP Servers Need Execution Sandboxing (And Why Your Current Stack Isn't Enough)By Om-Shree-0709 on .Agentic AiPrompt InjectionWebAssembly
MCP directory API
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/toonight/Mnemoscope'
If you have feedback or need assistance with the MCP directory API, please join our Discord server