Post-Barman 2026 tiered memory for Claude Code — Qdrant (hot/warm), pgvector + tsvector + pg_trgm cold tier, Memgraph link graph, Ollama embeddings, two-layer plugin hooks, 34 n8n workflows, and an integrated FastAPI + HTMX visualization dashboard. Zero cloud dependency.
Checkout and configuration validated from a clean container; the service was not booted:
git clone https://github.com/bulletproofsoftware-ai/bulletproof-memory.git cd bulletproof-memory ./install.sh # present and executable; not run end-to-end
bulletproof-memory/docs/media/
AI coding agents lose all context between sessions. Every new conversation starts from zero — no memory of past decisions, solved problems, learned patterns, infrastructure knowledge, or operational procedures. This makes agents structurally incapable of improvement.
But memory isn't just storage. Raw session data needs consolidation into knowledge. Knowledge needs to decay when outdated. Contradictions need detection and resolution. Agent identities need provenance tracking. Sensitive content needs classification and access control. Tool usage patterns need to reinforce successful workflows and let failed patterns fade. And all of this needs to happen automatically.
The deeper architectural challenge is that Claude Code reads hooks from settings.json, not from plugin manifests. Hooks defined only in plugin.json don't fire reliably for PostToolUse or Stop events. This means the hook architecture must be two-layer: settings.json for the hooks CC actually executes, and plugin hooks.json for the plugin lifecycle management that CC does read. Both layers reference the same idempotent scripts.
A second challenge surfaced in 2026: a single Qdrant pool degrades as memory volume grows. Recall quality drops because the active vector pool becomes dense with competitors (the n_near problem). The Barman 2026 paper showed that the non-geometric escape is to tier: keep a small active Qdrant pool (hot/warm), demote everything else to a Postgres cold tier with tsvector + pg_trgm hybrid search, and let the link graph live in Memgraph. This PRD describes the tiered system as actually deployed.
The hot path handles real-time session interaction via MCP tools. The cold path handles background maintenance via n8n. They never block each other. The hot path is fail-open — if Qdrant is down, sessions continue with flat-file memory.
Trigger: Claude calls MCP tools (74 registered in src/index.ts)
Flow: MCP Server (Node.js) → Ollama (nomic-embed-text, 768-dim) → Qdrant (hot/warm)
Latency: <500ms p95 recall, <1s p95 store
Also: Tool Facade scripts intercept Grep/Glob and serve memory content directly — Claude doesn't need to "decide" to check memory.
Trigger: 34 scheduled n8n workflows + 1 webhook
Flow: n8n → Qdrant + pgvector APIs → batch operations (only 2 use LLM inference)
Cadence: every 4h (extraction), daily (01:00–06:30), weekly (Sun–Sat 02:00–07:30), monthly (1st 09:00 EST), webhook (gateway).
Full inventory in §9 Workflow Inventory below.
Live in Qdrant. Small active pool keeps competitor density (n_near) low, so every recall stays sharp. Promotions are managed by the daily Hippocampal Consolidation + weekly Hot Rehydration workflows.
Lives in claude-memory-postgres (pgvector/pgvector:pg16, port 5438). Hybrid tsvector + pg_trgm search escapes the geometric collapse that pure-vector cold tiers suffer at scale. Also holds operational audit data and the memory.migration_tracker.
Lives in Memgraph (bolt://localhost:7687). RELATED edges between memory nodes power the graph_* MCP tools, knowledge graph rendering in the dashboard, and contradiction-resolution queries.
Claude Code only reads hooks from settings.json reliably for PostToolUse and Stop events. Plugin hooks.json works for SessionStart and PreToolUse but not reliably for all event types. The solution: wire critical hooks in both places — the scripts are idempotent. Full enumeration in §8 Hook Inventory.
| Service | Container | Image | Host port | Purpose |
|---|---|---|---|---|
| Qdrant | qdrant | qdrant/qdrant:latest | 6334 | Hot + warm + long-term + short-term vector tiers |
| Cold tier | claude-memory-postgres | pgvector/pgvector:pg16 | 127.0.0.1:5438 | tsvector + pg_trgm hybrid search, operational audit |
| n8n state | claude-postgres | postgres:16-alpine | 5436 | Backs n8n workflow state |
| n8n | n8n | n8nio/n8n:latest | 5679 | 34 scheduled workflows + 1 webhook |
| Dashboard | memory-dashboard | local build | 127.0.0.1:8092 | FastAPI + HTMX visualization (see §7) |
| Ollama | host-native | — | 11434 | nomic-embed-text 768-dim embeddings |
| Memgraph | memgraph | memgraph/memgraph-platform | bolt://localhost:7687 | Link graph for RELATED edges |
Measured live from ~/Code/claude-memory-mcp/src/index.ts — the published count is current.
memory_store (temporal classes, sensitivity, decay halflife), memory_recall, memory_forget (two-step), memory_scratch (ephemeral TTL), memory_verify (reset decay), memory_boost (Noguchi), pin_memory (defend against consolidation drain)
memory_promote, memory_consolidate, memory_prune, memory_organize, memory_summarize, memory_impact, hippocampal_consolidation
memory_provenance, memory_trace, contradiction_check, session_recalled
episode, learning, procedure, trajectory
graph_store, graph_query, graph_traverse, graph_path, graph_neighbors, graph_time_travel
governance_report, governance_gap_analysis, compliance_dashboard, constitutional_contract, constitutional_monitor, guardrail_proof, data_sovereignty
agent_identity, nhi_lifecycle, parl_coordinator, a2a_protocol, task_specialization, bft_consensus, federation
agent_marketplace, agent_dev_env, meta_agent, digital_twin
causal_debug, flow_debug, time_travel, semantic_diff, self_assess
benchmark, benchmark_suite, cost_router, stigmergy
rag_search, predictive_preload, context_budget, temporal_planner, workflow_author, workflow_optimizer, micro_swarm, skill_discovery
formal_verify, red_team (6 attack categories: goal hijacking, tool misuse, privilege escalation, memory poisoning, prompt injection, data exfiltration)
world_model (predict outcomes, observe actuals, update service models), multimodal_input (images, audio, diagrams → structured text)
The PRD originally listed 7 named collections. As more capabilities have been added, the count has grown to 67 live in Qdrant today. The principal ones:
| Collection | Purpose | Retention |
|---|---|---|
| memories_hot | Active vector pool (Barman tier) | Small, frequent rebalancing |
| memories_warm | Recently active but cooling | Daily transfer eligible |
| memories_cold | Demoted to Postgres tsvector tier | Long-term, search-only |
| claude_memories | Long-term persistent knowledge | Permanent (protected) |
| short_term_memory / working_memory | Session + task scratch | TTL / 60-min |
| learnings / procedures | Domain knowledge + reusable workflows | Protected (never pruned) |
| trajectories / episodes | Tool sequences + task execution records | Decay / consolidation-eligible |
| heuristics | Task outcome metrics from task_outcome.py | Feeds self-assessment |
| pheromone_trails | Stigmergy — successful tool chains | Daily decay + evaporation |
| causal_analysis | Failure→fix patterns | Long-term |
| constitutional_assessments | Alignment drift observations | Session-scoped, flushed at Stop |
Intercepts Grep and Glob calls. Before the tool executes, the facade embeds the search query, queries Qdrant, and if memory has the answer, serves it directly as the tool result. Claude never needs to "decide" to check memory.
Fires on every tool call. Checks actions against session objectives for scope drift, target drift, and destructive operations. Flags are buffered to JSONL and flushed to constitutional_assessments by flush_insights.py at Stop. No LLM calls — must complete in <2s.
Stop hook. Reads the tool chain buffer, classifies the task type, calculates success metrics, stores in heuristics. Feeds the self-assessment system and dashboard. Must run before flush_insights.py.
Extended SessionStart hook. Beyond auto-recall, runs self-assessment against the heuristics collection and sets constitutional objectives for the session. Those objectives are what the observer checks against on every subsequent tool call.
Build a tiered persistent vector memory system for Claude Code (post-Barman 2026):
1. STORAGE TIERS:
- HOT + WARM in Qdrant (port 6334): small active vector pools to keep
competitor density low so every recall stays sharp
- COLD in claude-memory-postgres (pgvector/pgvector:pg16 on 127.0.0.1:5438)
using tsvector + pg_trgm hybrid search (NOT vectors) to escape geometric
collapse at scale
- LINK GRAPH in Memgraph (bolt://localhost:7687) for RELATED edges between
memory nodes; powers graph_* MCP tools and dashboard graph view
2. MCP SERVER (Node.js, 74 tools across 14 categories):
- Core CRUD: store (temporal classes, sensitivity, decay halflife), recall,
forget (two-step), scratch (ephemeral TTL), verify (reset decay),
boost (Noguchi self-organizing relevance), pin_memory (defend from drain)
- Lifecycle: promote, consolidate, prune, organize, summarize,
impact assess, hippocampal_consolidation (5-phase brain-inspired)
- Graph: graph_store, graph_query, graph_traverse, graph_path,
graph_neighbors, graph_time_travel
- Provenance + episodic + procedural + governance + identity + ecosystem +
debugging + performance + search-planning-swarm + verify-security +
world-model + multimodal (see §3.1 for full enumeration)
3. TWO-LAYER HOOK ARCHITECTURE (both mandatory):
- Layer 1 (settings.json — what CC reads directly):
SessionStart → load-project-memory.sh
PreToolUse → block_manual_memory_writes.sh
PostToolUse → post_tool_failure.py, tool_chain_tracker.py,
world_model_observer.py, auto_linker.py
Stop → notify-on-stop.sh
SessionEnd → capture-session.py, session-daily-note.sh,
session-to-text.sh, session-summarize.py
- Layer 2 (claude-memory-plugin/hooks/hooks.json — auto-discovered):
SessionStart → session_start.py (self-assess + objectives)
UserPromptSubmit → user_prompt_capture.py
PreToolUse → pre_store, subagent_memory_inject,
plan_memory_inject, pre_action_recall,
constitutional_observer
PostToolUse → (mirrors of Layer 1, idempotent)
PreCompact → pre_compact.py
Stop → assistant_response_capture, task_outcome,
auto_trajectory, flush_insights,
auto_skill_generator, user_model_updater
4. N8N WORKFLOWS (34 total, see §9 for full schedule):
- 1 every-4h LLM workflow (session transcript extraction)
- 12 daily cron (01:00–06:30): contradiction check, conflict resolver,
predictive patterns, TTL sweep, hippocampal consolidation, tier transfer,
stigmergy decay, stigmergy reinforce, world model sync, causal patterns,
session recording sync, memory verify sweep
- 13 weekly cron (Sun–Sat 02:00–07:30): hot rehydration, organize
clusters, active pruning, benchmark auto-record, DRM canary, permission
review, identity auto-register, NHI lifecycle, self-assessment,
red team scan, semantic diff, compliance dashboard, formal verify
- 1 monthly (1st 09:00 EST): governance review → Obsidian
- 1 webhook (claude-memory-gateway)
- 6 utility / on-demand (compaction, hierarchical abstraction LLM,
benchmark regression, compliance report, skill discovery,
agent output visual formatter)
- Only 2 use LLM inference (session extraction + hierarchical abstraction)
5. VISUALIZATION DASHBOARD (FastAPI + HTMX + Jinja2 + asyncpg):
- 24 routes including login/logout, /memories, /search, /graph, /contacts,
/decisions, /analytics, mutation endpoints (PUT/DELETE on memories),
and /api/audit
- Reads Qdrant + cold-tier Postgres directly (bypasses MCP)
- Authenticated session cookies (SHA-256 password hash, signed cookies,
7-day session), bound to 127.0.0.1 only
- D3 force-directed graph for memory relationships, Chart.js analytics
6. DOCKER COMPOSE: qdrant, claude-postgres (n8n state), claude-memory-postgres
(cold tier, pgvector image), n8n, memory-dashboard, memgraph.
Ollama runs native on host (not containerized).
Build as MCP server (TypeScript) + Claude Code plugin (Python stdlib only)
+ n8n workflow definitions (JSON imports) + FastAPI dashboard (Python).
Wire hooks in BOTH settings.json and plugin hooks.json.A single growing Qdrant pool degrades recall quality — the n_near problem from Barman 2026. Keeping the active vector pool small and demoting cold entries to Postgres tsvector + pg_trgm escapes geometric collapse without losing searchability.
Claude Code's plugin-manifest hook loading has a gap for PostToolUse and Stop. Wiring critical hooks in settings.json guarantees execution. The plugin layer adds richer behavior. Scripts are idempotent so the duplication is safe.
Requiring Claude to "decide" to check memory is fragile — it often skips under context pressure. The Tool Facade intercepts Grep/Glob and serves memory results directly. Claude gets the answer without needing to make the right decision.
Checking alignment after the session is too late. The constitutional observer runs on every tool call in <2s, buffering drift flags. Stop flushes them to Qdrant for trend analysis. Real-time detection, batch storage.
Each workflow runs independently at the right frequency. A slow LLM synthesis (weekly) never blocks a fast TTL sweep (daily). Each can fail without affecting the others. Sub-minute individual run times once volumes hit five figures.
Pheromone trails encode successful tool chains through observation, not programming. Daily decay prevents stale patterns from dominating. Agents get probabilistic guidance ("87% success rate for this pattern") instead of rigid rules.
The dashboard queries Qdrant + Postgres directly rather than going through the MCP server. This keeps it independent of any Claude Code session, lets it run even if Claude isn't, and lets it inspect both hot and cold tiers in one view.
Qdrant does vector similarity well; it does not do graph traversal. Memgraph handles RELATED edges natively with Bolt protocol, which is what powers the D3 knowledge graph in the dashboard and the graph_* MCP tools.
A vector store with 67 collections and thousands of entries is opaque by default. The dashboard makes the invisible visible — a lightweight FastAPI + HTMX + Jinja2 web application that queries Qdrant and the cold-tier Postgres directly, with no SPA build step and no node_modules.
Previously a separate PRD (Memory Dashboard). Now Section 7 of this combined document. The old memory-dashboard.html URL is preserved as a redirect stub pointing to this section.
Browser ↔ FastAPI (Python 3.11, uvicorn)
└ Jinja2 templates + HTMX partials
└ D3.js (force-directed knowledge graph)
└ Chart.js (analytics dashboards)
└ asyncpg → claude-memory-postgres (cold tier, tsvector + pg_trgm)
└ httpx → Qdrant REST API (hot + warm tiers)
└ itsdangerous-signed session cookies, SHA-256 password hash
Container: memory-dashboard on 127.0.0.1:8092 (healthy)
Collection stats, storage size, last backup, system health indicators. Landing view.
D3 force-directed. Nodes sized by access frequency, colored by collection. Edges at cosine similarity > 0.7. Click to inspect, drag to rearrange, scroll to zoom.
Paginated table per collection. Search, sort, filter by tags. Memory detail view with metadata, history, linked memories. Bulk tag/delete operations.
Chart.js dashboards — growth over time, type distribution, access heatmap, dedup effectiveness, collection size comparison.
Cross-collection query. Results ranked by similarity score with source collection and metadata. Bridges hot Qdrant and cold Postgres tiers.
Relational views over the cold-tier Postgres — contacts/household graph and decision log alongside vector memories.
# Authenticated session required (7-day signed cookie)
GET /login GET /logout GET /health
GET / GET /memories GET /search
GET /graph GET /contacts GET /decisions
GET /analytics GET /api/stats GET /api/recent
GET /api/memories POST /api/search GET /api/graph-data
GET /api/projects GET /api/tags GET /api/contacts
GET /api/household GET /api/decisions GET /api/audit
PUT /api/memories/{id} DELETE /api/memories/{id}
Server-rendered fragments. No build step, no bundler, no hydration. The dashboard is a visualization tool, not an app.
Reads Qdrant and Postgres directly instead of going through the MCP server. Operates independently of any Claude Code session.
Surfaces hot (Qdrant), warm (Qdrant), and cold (Postgres tsvector + pg_trgm) tiers in one view so the Barman 2026 architecture is observable end-to-end.
Login flow with SHA-256 password hash and signed session cookies. Bound to 127.0.0.1 — never exposed to the public network.
The complete set of hooks the running system wires. Layer 1 lives in ~/.claude/settings.json — Claude Code reads it directly, and it is mandatory for PostToolUse and Stop reliability. Layer 2 lives in ~/.claude/plugins/local/claude-memory-plugin/hooks/hooks.json — Claude Code auto-discovers it when the plugin is installed. Several scripts are referenced from both layers on purpose: this is the redundancy that protects against the plugin-loading gap.
| Event | Matcher | Script | Purpose |
|---|---|---|---|
| SessionStart | * | load-project-memory.sh | Qdrant auto-recall + flat MEMORY.md load |
| PreToolUse | Write|Edit|NotebookEdit | block_manual_memory_writes.sh | Reject direct edits to MEMORY.md files |
| PostToolUse | * | post_tool_failure.py | Lookup prior error→fix pattern |
| PostToolUse | * | tool_chain_tracker.py | Buffer chain for task-outcome heuristics |
| PostToolUse | Bash | world_model_observer.py | Update service-model predictions |
| PostToolUse | mcp__claude-memory__memory_store | auto_linker.py | Auto-link new memory to related nodes |
| Notification | * | (cmux notify inline) | Surface CC notifications to cmux |
| Stop | * | (cmux notify inline) | "Task complete" cmux ping |
| Stop | * | notify-on-stop.sh | Telegram bridge for long-running tasks |
| SessionEnd | * | capture-session.py | Archive full transcript |
| SessionEnd | * | session-daily-note.sh | Obsidian breadcrumb |
| SessionEnd | * | session-to-text.sh | Plain-text export for grep |
| SessionEnd | * | session-summarize.py | LLM summary into memory |
| Event | Matcher | Script | Purpose |
|---|---|---|---|
| SessionStart | * | session_start.py | Self-assessment + constitutional objectives |
| UserPromptSubmit | * | user_prompt_capture.py | Embed prompt → Qdrant search → inject context |
| PreToolUse | mcp__claude-memory__memory_store | pre_store.py | Dedup + classification before write |
| PreToolUse | Agent | subagent_memory_inject.py | Pre-load memory into subagent context |
| PreToolUse | EnterPlanMode | plan_memory_inject.py | Inject memories into plan context |
| PreToolUse | Write|Edit|Bash|NotebookEdit | pre_action_recall.py | Pre-action recall on mutating tools |
| PreToolUse | Write|Edit|Bash|Read|Glob | constitutional_observer.py | Drift check <2s/call, buffer flags |
| PostToolUse | * | post_tool_failure.py | (mirrors Layer 1) |
| PostToolUse | * | tool_chain_tracker.py | (mirrors Layer 1) |
| PostToolUse | Bash | world_model_observer.py | (mirrors Layer 1) |
| PostToolUse | mcp__claude-memory__memory_store | auto_linker.py | (mirrors Layer 1) |
| PreCompact | * | pre_compact.py | Emergency state save before compression |
| Stop | * | assistant_response_capture.py | Persist final assistant response |
| Stop | * | task_outcome.py | Classify task → heuristics collection |
| Stop | * | auto_trajectory.py | Record tool sequence as trajectory |
| Stop | * | flush_insights.py | Flush constitutional + stigmergy buffers |
| Stop | * | auto_skill_generator.py | Synthesize emergent skills from trajectories |
| Stop | * | user_model_updater.py | Update user-model from session signals |
Claude Code's PostToolUse and Stop hook loading from plugin manifests is not reliable in every release. Wiring the same scripts in settings.json guarantees execution. The scripts themselves are idempotent — running them twice produces the same result — so the redundancy is safe. If Claude Code closes the plugin-loading gap in the future, the Layer 1 entries can be removed without losing functionality.
The cold path is operated by 34 n8n workflows in ~/Code/claude-memory-mcp/workflows/. The MCP server (hot path) never blocks on these; they run on cron or fire on webhooks. Only 2 workflows use LLM inference (call Claude via the Anthropic API) — everything else is pure HTTP + Qdrant + Postgres operations.
| Workflow | Purpose |
|---|---|
| Session Transcript Extraction LLM | LLM call extracts structured memories from raw session transcripts. First of the two LLM workflows. |
| Time | Workflow | Purpose |
|---|---|---|
| 01:00 | Contradiction Check | Scan memories for semantic contradictions, mark for resolution. |
| 01:30 | Daily Conflict Resolver | Apply resolution rules to the contradictions flagged by 01:00. |
| 02:00 | Predictive Pattern Extraction | Mine trajectories for recurring tool-chain patterns; feed predictive preload. |
| 03:00 UTC | TTL Sweep | Universal GC: expire points whose TTL has passed across all collections. |
| 03:00 | Hippocampal Consolidation | 5-phase consolidation: replay → extraction → integration → pruning → reorganization. Hot → warm with cycle audit. |
| 03:30 | Tier Transfer | Promote warm → long-term; delete expired cold-tier entries. |
| 04:00 | Stigmergy Decay | Pheromone-trail decay + evaporation below threshold. Pairs with Auto-Reinforce. |
| 04:30 | Stigmergy Auto-Reinforce | Strengthen pheromone trails for successful tool chains in the last 24h. |
| 05:00 | World Model Sync | Reconcile predicted-vs-observed outcomes; update service models in world_model. |
| 05:30 | Causal Pattern Extraction | Build failure→fix edges into causal_analysis from recent post-tool failures. |
| 06:00 | Session Recording Sync | Archive previous day's session recordings to cold tier; index for time-travel debug. |
| 06:30 | Memory Verify Sweep | Reset decay clock on memories proven still-relevant by recent recalls. |
| Day/Time | Workflow | Purpose |
|---|---|---|
| Sun 02:00 | Hot Rehydration | Re-warm the hot tier with high-relevance entries from warm/long-term. Counters HOT drain. |
| Sun 02:30 | Memory Organize Clusters | Cluster similar memories, merge near-duplicates above 0.92 cosine, archive originals. |
| Sun 05:00 | Active Pruning | Demote underused memories to cold tier with audit trail. |
| Sun 06:00 | Benchmark Auto-Record | Run 7-dim benchmark suite; record to benchmark_runs for regression detection. |
| Mon 03:00 | DRM Canary | Write a canary, attempt recall, log to audit.memory_health. Detects silent recall regressions. |
| Mon 06:00 | Permission Review | Audit NHI lifecycle for stale permissions; flag for revocation. |
| Mon 07:00 | Identity Auto-Register | Discover new agent identities, register in agent_identities with Ed25519 key. |
| Mon 07:30 | NHI Lifecycle Tracker | Track spawn/escalate/terminate transitions across non-human identities. |
| Tue 06:00 | Self-Assessment Report | Aggregate the week's heuristics into a self-assessment digest for SessionStart. |
| Wed 02:00 | Red Team Scan | Run adversarial campaigns across 6 attack categories; persist to red_team_campaigns. |
| Thu 03:00 | Semantic Diff | Compare behavioral diffs between agent versions; persist to semantic_diffs. |
| Fri 07:00 | Compliance Dashboard | Refresh ISO 42001 + EU AI Act + OWASP Agentic Top 10 scorecards. |
| Sat 04:00 | Formal Verify | Run safety / liveness / invariant checks; emit Ed25519-signed verification certificates. |
Monthly Review — 1st of month 09:00 EST. 4-way governance report → Obsidian: expiring, never-accessed, sensitive, redactions.
Claude Memory Gateway — the single webhook-triggered workflow. Real-time store/recall/rag API surface with auth routing. Everything else runs on cron.
Memory Compaction, Hierarchical Abstraction LLM, Benchmark Regression, Compliance Report, Skill Discovery, Agent Output Visual Formatter. Triggered manually or by other workflows.
Each workflow runs independently at the right frequency. A slow LLM synthesis (weekly) never blocks a fast TTL sweep (daily). Each can fail without affecting the others. The original 2-workflow approach (organize + forget) didn't scale — once memory volume hit five figures the operations needed to be separated to keep individual run times under a minute.
Conductor stores trajectories, learnings, and task outcomes through MCP tools. Agent identity, NHI lifecycle, BFT consensus, and task specialization tools support the conductor's bundled agent workforce. The conductor state schema references governance manifests stored in memory. See the Conductor PRD.
7 governance tools connect memory to the governance framework. Constitutional contracts and monitor tools enforce delegation chain privileges. Data sovereignty and guardrail proofs provide compliance evidence. The governance plugin's policy engine evaluates memory writes via memory_integrity_hook.py. See the Governance PRD.
Context budget management (5 compartments) bridges memory and context window management. PreCompact hooks coordinate — context-guard records the compaction event, the memory plugin saves state. Predictive preloading reduces recall latency. See the Context-Guard PRD.
The memory system is a Claude Code plugin with both settings.json and plugin hooks.json wiring. 6 slash commands (/memory-search, /memory-save, /memory-resume, /forget, /memory-stats, /exit) provide user-facing interfaces. MCP server registered via .mcp.json.
| Component Down | Impact | Fallback |
|---|---|---|
| Ollama | Cannot embed new content | Session continues with flat MEMORY.md |
| Qdrant | Cannot store/recall hot/warm | Empty results; MEMORY.md still loads |
| claude-memory-postgres | Cold tier unreadable | Recalls degrade gracefully to hot/warm Qdrant only |
| n8n | Maintenance stops | Vectors accumulate; run workflows manually after restore |
| Memgraph | Graph queries fail | graph_* tools return empty; vector recall unaffected |
| Dashboard | UI unavailable | Memory operations continue (dashboard is read-only inspection) |
| Metric | Target |
|---|---|
| memory_recall latency | <500ms p95 |
| memory_store latency | <1s p95 |
| Dedup false positive rate | <1% |
| Constitutional observer latency | <2s per tool call |
| Weekly prune coverage | 100% of collections scanned |
| Backup freshness | <7 days |
| DRM canary success rate | 100% (weekly) |
The debug-memory diagnostic checks all hops: Ollama process + API + model, Qdrant container + API + all 67 collections, cold-tier Postgres, MCP server + hooks, n8n container + API, hook pipeline integrity, Memgraph reachability, and the Memory Dashboard container.