Memory System
Myrm’s memory system is the most complete implementation of the Agentic Memory Operations (AMO) paradigm — a 42+ module cognitive system that persists across sessions, learns from every interaction, and proactively surfaces insights.Memory Types
The system supports 8 memory types stored in SQLite + Qdrant (compared to Mem0’s 3 types):Dialectic Preference Reasoning (Cognitive Deriver)
When a conversation ends, the Cognitive Deriver runs in the background with zero impact on response latency:- Analyzes the last 10 messages using LLM-powered dialectic reasoning
- Extracts implicit preferences across unlimited dimensions (communication style, cognitive depth, proactivity, coding paradigm, etc.)
- Applies a 0.8 confidence threshold — only high-certainty insights are stored
- Resolves conflicts via change_kind semantics (support/contradict/supersede/constrain)
- Securely writes to vector store (SemanticMemory) through the standard approval queue + security scanning — external content cannot bypass defenses
- Core preferences go through PreferenceStabilityStrategy multi-observation validation (Candidate → Provisional → Active) before safe promotion to ProfileEntry, auto-injected into the system prompt
- Agent self-generated rules (AGENT_SELF) have a hard priority ceiling of HIGH, preventing them from claiming compression-immune slots
Zero-Cost Goal Deduction (Dream Mechanism)
Inspired by Honcho’s Dream mechanism but implemented with zero additional LLM cost, Myrm asynchronously extracts the user’s Long-term Goals and Ongoing Projects during the routine “Taste Summary” generation. This provides the AI with a persistent “long-term memory target” without the high token costs and data corruption risks of traditional free-text Dream mechanisms.Working Memory (Cross-Session Task Continuity)
Long-running tasks (multi-day refactors, iterative research) lose context between sessions. Other tools require manual recaps or expensive full-history search. Myrm’s Working Memory solves this with a dedicated__working_state Profile Memory entry:
- Automatic extraction — After each conversation turn, the
TaskDigestextractor captures task progress into working state (≤500 chars) - Priority injection — Working State injects at
priority=0(highest) in the system prompt, ensuring the next session immediately knows where you left off - 7-day TTL — Entries older than 7 days auto-expire, preventing stale context from polluting new tasks
- Real-time UI — A Badge in the chat header shows the current working state; it refreshes automatically after each conversation turn. A Settings card provides full create/edit/clear control with a character counter
Profile Injection + Unified Memory Search (Prefix Cache Friendly)
Cross-session continuity: L1 stable profile injects automatically; learned preferences are retrieved viamemory_search_tool (not Turn-1 middleware) to maximize prompt cache hit rate.
Turn 1 behavior: One read tool with
corpus — no standalone conversation_search_tool on GeneralAgent. Sub-agents (Custom + Ephemeral JIT) rebind memory_search_tool with scoped policy/backends (child agent_id, parent chat_id, parent opt-in flags).
Voice (Realtime & Gemini Live): The same Settings ACL applies — voice sessions declare a trimmed memory_search_tool corpus enum and pass enable_conversation_search into tool execution, so “Conversation History Search” in Settings controls both chat and voice. Voice transcripts stay text-only (no Evidence button yet).
Memory is on by default for new users. Conversation history search is decoupled and off by default until you opt in.
How we compare (honest, Jul 2026)
Hermes splits semantic memory and session search into separate tools; CoPaw auto-injects history. Myrm: single corpus ACL + GUI opt-in sessions + incognito fully disables memory + Evidence N citation UI. OpenClaw uses a similar corpus model; we add GUI privacy controls and unified citations. Verified (2026-07-20): 38 factory unit tests (99.6% cov), 8 API memory/session e2e, 4 Chrome citation e2e, 7 frontend vitest — model mimo-v2.5-pro via.env.test.
Memory Diagnostic Explainability Loop
Most products can tell you memory exists, but not whether it was actually used in this turn. Myrm closes that gap with a user-visible diagnostic loop:- Stream phase emits per-turn memory status during response generation
- Persist phase writes the same normalized status to stored message metadata
- Control-plane telemetry aggregates stream/persist status and raises alerts on drift or abnormal drop signals
- Frontend explanation UI shows
preflightvsruntime_fallbacksource, including mobile-friendly non-hover copy
- Faster trust recovery: users can see why memory was skipped instead of guessing
- Lower support cost: operations can triage by status/source/reason labels instead of replaying whole chats
- No prompt-cache regression: diagnostics are emitted after model output (
message_end/persist paths), not by mutating prompt prefixes - No silent telemetry corruption (cloud mode): strict shared dedup fail-closed rejects unsafe ingest paths and records reject reasons for fast incident triage
- Server memory telemetry regression: 28 passed
- Control-plane ingest + auth + metrics regression: 55 passed
- Frontend memory explanation and flow regression: 14 passed
AMO Operations — Full Coverage
The AMO paradigm (2025-2026) defines four core operations that a complete memory system must support. Anthropic’s Dreaming covers steps 1-2; Mem0 covers Store and partial Retrieve. Myrm implements all four with production-grade depth:7-Signal Retrieval Fusion
Unlike traditional vector-only search, Myrm combines 7 independent scoring signals via weighted geometric mean:- Semantic similarity — Qdrant vector embedding match
- Keyword match — SQLite FTS5 + BM25 precise recall
- Entity match — Graph-enhanced multi-hop traversal
- Recency — Exponential time decay (configurable half-life per type)
- Frequency — Access count with logarithmic saturation
- Importance — User-assigned or LLM-extracted importance scores
- Preference — Preference-type boost for preference queries
Anti-Chitchat Memory (No-Op Default)
Mem0 and Codex extractors lean toward High Recall, eagerly pulling transient thoughts (“Hello”, “It’s sunny today”) into the database. Over time, this drastically dilutes meaningful constraints and pollutes the RAG context. Myrm invented the No-Op Default (Strict Precision) paradigm:- The underlying LLM extractor is heavily penalized for outputting trivialities.
- It is instructed to default to returning an empty array
[]representing No-Op. - Only critical business constraints (e.g., “I must use Python 3.14”) and high-leverage knowledge cross the
0.6importance threshold. - The result: Absolute context purity, ensuring AI decisions and long-tail constraint memories achieve a near 100% precision hit rate without token waste.
Dynamic Age Warning (Hallucination Guard)
Retrieving outdated information (like a file path from a month ago) causes naive Agents to blindly use broken context and fail repeatedly. Myrm’s memory retriever injects human-readable age labels (e.g., “today”, “3 days ago”, “2 months ago”) and relevance scores into every loaded episodic/semantic memory. The age reflects the most recent modification — if a memory was updated yesterday, it shows “yesterday” regardless of creation date. Furthermore, if the system detects sensitive time-decaying assets (like code paths), it dynamically prepends a[CRITICAL WARNING] instructing the LLM: “This path may be outdated. You MUST use Read/Grep tools to verify its existence before making code assumptions.” This effectively immunizes the Agent against RAG-induced code hallucinations.
Additional enhancements: 6 result boosters (keyword overlap, temporal proximity, person name, quoted phrase, preference, pattern matching), MMR diversity reranking with source-session deduplication, correction-chain suppression (outdated corrected memories auto-demoted 90%), and adaptive dual-channel selection saving ~35% query cost.
Retrieval Configuration Engine
Under the hood, Myrm’s retrieval system exposes 33 tunable parameters throughRetrievalConfig — all with carefully optimized defaults so you never need to touch them. Key capabilities:
- 3 Recall Modes — HYBRID (context injection + memory tools), CONTEXT (injection only, ideal for API/headless), TOOLS (minimal token overhead)
- 5 Independent Boost Systems — keyword overlap, temporal proximity, person name matching, quoted phrase detection, preference strength — each with its own enable toggle and weight parameter
- Adaptive Dual-Channel Selection — Automatically chooses between summary-only and dual-channel (summary + raw) retrieval based on query complexity, saving ~35% query cost without sacrificing recall quality
- Intent Recognition — Automatically detects query intent (factual lookup vs preference recall vs temporal query) and adapts retrieval strategy accordingly
- 5-Level Memory Scope Isolation — Global → Agent → Channel → Conversation → Task, with configurable read/write policies per scope level
- 6 Memory Type Weights — Independent relevance weights for Profile, Semantic, Episodic, Conversation, Procedural, and Claim memories
- Frontend Settings — 4 toggles (enable/confirmation/auto-extraction/pre-compact) + 1 slider (token budget 800–2000) + 6 tab views — the optimal UX balance between power and simplicity
Knowledge Graph
Relationships between memory entries are modeled as a knowledge graph with 4 semantic relation types (SUPPORTED, CONTRADICTED, SUPERSEDED, CONSTRAINED) and multi-hop traversal. Supports both SQLite CTE and Apache AGE backends with 3D visualization in the GUI. The knowledge graph is featured prominently in the unified Learning Journey page (/journey), where users can explore Claim/Evidence nodes alongside skill efficiency trends and growth KPIs in a single view. The graph API supports namespace filtering, allowing users to explore knowledge scoped to specific agents or shared contexts.
Integration Memory — Cross-Platform Knowledge Fusion
Connect external services and automatically pull their data into your memory system. Any MCP-compatible server becomes a knowledge source with zero custom code:- MCPBridgeProvider auto-bridges any configured MCP Server (Notion, Feishu, DingTalk, GitHub, Slack, etc.) — no per-service adapter needed
- IntegrationSyncDaemon discovers your MCP servers and syncs every 60 minutes automatically
- Auto Knowledge Extraction — the system uses LLM to extract high-value profile traits from synced data and writes them directly to your user profile
- Hierarchical Tree Structure — synced content is organized into navigable trees with LLM-generated summaries at each level
- Concurrent Fetch with Error Isolation — multiple providers sync in parallel with semaphore limiting; one provider’s failure never affects others
- 5 prebuilt OAuth integrations (Feishu, DingTalk, GitHub, Jira, Slack) with credential vault management
- Clean disconnect — when you remove a provider, all its synced memories are automatically cleaned up
Wiki Knowledge Base
With the Wiki builtin tool group enabled on an agent profile, the Agent gets ingest / compile / query / maintain tools automatically. Write paths include file/URL ingest, Save to Wiki from chat, Deep Research vault, post-compaction session-note archive, and large-upload hints. All paths use one unified wiki directory; Settings shows vault health badges (vault ready / legacy migrated). Consumption paths include wiki_query hybrid search, settings overview queries, and the 3D knowledge graph. The Brain page provides a full GUI for browsing concepts, editing content, hybrid search, reviewing pending edits, and exploring the graph. Each user gets an isolated wiki directory.
Need a visual summary? Ask the agent to generate mindmaps, timelines, flowcharts, or any of the 13+ Mermaid chart types directly in chat — rendered live with theme-adaptive styling. Unlike template-locked systems (RAGFlow uses 7 fixed YAML templates), Myrm’s agent generates any visualization on demand with zero pre-computation cost.
Intelligent Forgetting & Incognito Mode
Five-dimension forgetting strategy prevents memory bloat while preserving what matters — covering all memory types including Semantic, Episodic, and Procedural:- Recency — Older memories decay with configurable half-life (90 days default)
- Frequency — Rarely accessed memories are deprioritized (access_count persisted across sessions for all types)
- Importance — Explicitly flagged or high-importance memories are preserved
- Relations — Well-connected memories in the knowledge graph receive higher retention scores
- User Rating — User feedback (thumbs up/down) directly influences retention priority
Memory Staleness Defense
Mem0’s 2026 benchmark identified “memory staleness” as the hardest open problem — high-frequency memories that become outdated lead to confidently wrong answers. Myrm’s 8-layer defense:7-Strategy Anti-Fragmentation System
Long-running agents accumulate thousands of memories that inevitably fragment — duplicates, outdated entries, and noise dilute retrieval quality. Unlike competitors that offer no fragmentation defense (Hermes acknowledges the problem but provides zero mitigation), Myrm deploys 8 autonomous strategies working in concert:
Result: Memory index stays pure, fast, and always relevant — no manual cleanup needed. Verified with 446 automated tests covering all strategies.
Cross-Session Consolidation & Autonomous Maintenance
Myrm’s memory maintenance engine runs 10 specialized modules (4,128 lines of code) that keep memory organized without user intervention. The Memory Guardian scheduler orchestrates all maintenance autonomously with adaptive timing — healthy systems run every 6 hours, degraded systems escalate to every 2 hours with forced recovery. It automatically pauses during active user sessions, respects daily token budgets, performs SQLite hot backups after each cycle, writes audit events to the operation ledger with SSE push to the Command Center, and cleans up expired archives and stale conflicts.Consolidation (5 operations)
- Merge — Combine duplicate or overlapping memories into a single, richer entry
- Correct — Fix outdated or contradictory information with quality Rubric scoring (≥0.7 gate)
- Update — Enrich existing memories with new context from recent conversations
- Archive — Move low-value memories to cold storage (recoverable)
- Split — Break compound memories into atomic facts for better retrieval
Three-Layer Deduplication
Hash matching (0.18ms, saves 98% embedding cost) → Vector similarity → LLM semantic judgment. Four outcomes: SKIP, UPDATE_REPLACE, UPDATE_MERGE, or KEEP_BOTH. Entity matching uses exact= comparison (not substring matching), so distinct entities like “Sam” and “Samsung” or “Apple” and “Pineapple” are never confused — a known issue in competitors that rely on rule-based NER with substring deduplication.
Recurrence Detection
Embedding-based buffer detects when the same topic recurs ≥4 times across sessions, automatically triggering consolidation — inspired by RecMem’s academic approach but with production-grade implementation.Subsumption
When new knowledge fully encompasses an older memory, the system safely soft-deletes the subsumed entry while preserving audit trails.Conflict Arbitration
When consolidation detects a high-importance contradiction (conflicting old/new memories with insufficient confidence for automatic resolution), the conflict is routed to the user:- Real-time notification — SSE push + sidebar badge pulse alert
- Visual comparison — ConflictCard displays old/new content side-by-side with importance percentage and accuracy score
- Four actions — Keep old / Accept new / Free-edit merge (LLM pre-generates suggestion) / Discard both
- 72h safe fallback — Unresolved conflicts auto-retain the old value, preventing information loss
One-Click Rollback
Every consolidation operation is reversible with zero extra storage — the system uses existingprevious_content metadata and soft-deletion flags. The GUI shows a dedicated Consolidation Rollback card with conflict warnings for memories modified by the user after consolidation.
Pattern Discovery
Cross-cycle behavioral pattern analysis (runs weekly) surfaces insights users may not notice:- Recurring work habits and routines
- Knowledge evolution over time
- Unresolved threads and concerns
- Preference drift across sessions
- Blind spots the user never directly addresses
Shared Context — Cross-Agent Knowledge Sharing
Shared Context lets you create curated knowledge spaces that multiple agents, channels, or conversations can access. Unlike file-based project context (PilotDeck’sMEMORY.md approach), Myrm’s Shared Context is a governed, multi-tier system:
6 binding target types — attach context to agents, channels, cron jobs, conversations, tasks, or entire projects.
5-level namespace hierarchy — memories are scoped from global down to task-level, ensuring the right information reaches the right agent at the right time:
Write governance — proposals require explicit approval before entering a shared context. Auto-approve policies can be configured for corrections and goal completions.
Health monitoring — the system actively monitors embedding availability, alerting before you encounter write failures.
Evidence retrieval — browse conversation history, find relevant evidence, and generate approvable proposals directly from past dialogues.
Manage everything from the GUI: create contexts, bind them to targets, review write proposals, and browse history — all from the Memory Center’s Shared Context tab.
Agent Instruction vs Global Memory Boundary Control
When multiple agents share global memories, a global preference might conflict with a specific agent’s instructions. For example: global memory records “user prefers detailed explanations,” but your coding agent is configured to be “concise.” Myrm automatically injects a Scope Boundary declaration at the prompt level, explicitly telling the LLM: when global memories conflict with the agent’s own instructions, agent instructions always take precedence. This ensures each agent’s persona and behavioral rules are never compromised by global memory.- Zero configuration — auto-injected when global memories exist, skipped when none
- Zero performance cost — fixed text participates in Prefix Cache, no latency impact
- Industry-first — comprehensive competitor research confirms no other product implements instruction boundary control in multi-agent shared memory scenarios
Memory GUI Management
A comprehensive 40+ component interactive GUI replaces the traditional plain-text file approach (like MEMORY.md). Every aspect of the memory system is manageable through rich visual interfaces — while competitors like Hermes Agent have zero memory management UI in their dashboard. Verified with 2,120+ dedicated tests (2,060 backend + 62 frontend GUI):- 6-Tab Classification — pending, all, context, shared, recall, and trash views for instant navigation
- Rich Memory Cards — each memory displays its type icon, timestamp, content preview, and action buttons (edit/delete/approve)
- MemoryCommandCenter — full-dashboard management with health scores, operation timelines, governance panels, and diagnostics (DoctorPanel)
- Shared Context Manager — create shared knowledge pools, bind them to specific agents or channels, review write proposals, and audit cross-agent knowledge sharing
- Approval Queue — every AI-extracted memory goes through a review queue. Edit before approving, reject unwanted entries, or batch-approve. Each pending memory links back to the source conversation for full traceability
- Anti-Overwrite Lock — rules you manually edit are automatically protected with
is_user_locked. The 6-module Skill Evolution Pipeline (trace analyzer → frustration detector → screener → extractor → aggregator → variant generator) will never overwrite your locked rules during consolidation - 3D Knowledge Graph — interactive visualization of memory relationships and connections, integrated into the unified
/journeyLearning Journey page alongside growth KPIs and skill trends - 3-Way Rollback — undo migration imports, consolidations, or archive restores with dry-run preview
- Session Replay — replay past conversations to see exactly how memories were used
- Citation Source Tracing — when the agent cites a memory in its response, the citation card shows a “View in original chat” link that navigates directly to the exact source message in the original conversation — closing the loop from “what was recalled” to “where it came from”
- Health Dashboard — real-time monitoring of memory system health with quantified scores
- Preference Analytics — PreferenceStabilityCard and TasteSummaryCard show how well the AI understands your preferences
- Injection Safety — dual-layer protection:
sanitize()strips structural framing tags (tool_call, ChatML, CDATA) and neutralizes Unicode spoofing attacks, then_escape_xml_item()escapes XML entities (&/</>) before injection into the prompt. Content is physically separated into trusted (user-configured) and untrusted (AI-extracted) layers with a Scope Boundary declaring agent instructions take precedence over memories. Automatic content scanning detects prompt injection attacks (CLEAN/WARN/REDACTED/BLOCKED) - Export/Import — full memory export with dry-run preview before import (supports 14 formats including Claude Code, Claude, Cursor, Hermes, Codex, Windsurf, Trae, and mem0)
- New User Guide — built-in MemoryGuide walks first-time users through the system
- Save to Memory Button — one-click save any AI reply to long-term semantic memory directly from the chat action bar. 3-state feedback (idle → saving → saved), duplicate prevention, and 5-language i18n. No competitor offers this in-chat GUI shortcut
Memory Health
The diagnostic system monitors memory quality with quantified health scores and provides actionable repair recommendations. Includes memory import/export for 14 formats, archive management, and recall benchmarking with IR metrics (NDCG, MRR, precision).Dataset Export
Export your conversation traces as industry-standard fine-tuning datasets — directly from the Settings page.- 3 output formats: ShareGPT, Alpaca, OpenAI JSONL — compatible with LLaMA-Factory, Alpaca-LoRA, and OpenAI Fine-tuning API
- 12-category PII redaction: phone, email, ID card, bank card, passport, address, SSN, and more — type-tagged placeholders preserve structure while removing sensitive data
- Quality filtering: only export successful, substantive conversations (configurable success requirement, minimum turns, content length)
- Content deduplication: SHA-256 hashing eliminates duplicate samples automatically
- Incremental export: state tracking skips already-exported sessions on subsequent runs
- Zero runtime cost: pure local file processing, no LLM calls, no performance impact
Privacy-safe Rule Sharing
Share your procedural memory rules with teammates or the community without exposing sensitive information. Myrm automatically sanitizes exported content:- Path anonymization: home directory paths (
/Users/alice/project) become<USER>/project - Credential redaction: API keys and secrets are truncated to safe prefixes (
sk-pro...f456) - Metadata stripping: timestamps, update counts, and internal IDs are removed
- Scoped export: filter by agent ID or select individual rules — share only what’s relevant
- Format options: Markdown (human-readable) or JSON (machine-importable), downloadable as ZIP
- Live preview: inspect sanitized output before sharing — what you see is what gets exported
GET /api/v1/memory/operations/export/rules-safe.
Smart Follow-up Tracking (Commitments)
Myrm automatically detects implicit follow-up obligations from conversations — interviews to schedule, deadlines to meet, health check-ins to make — and tracks them via a structured commitment pipeline:- Async extraction: After each session, an LLM pass identifies commitments without blocking your conversation (4 kinds: event check-in, deadline, care, open loop; 3 sensitivity levels: routine, personal, care)
- Confidence gating: Only high-confidence commitments pass (threshold ≥ 0.65, care items ≥ 0.86) — no spam
- Heartbeat delivery: Due commitments are injected into the agent’s Situation Report at each heartbeat tick
- Two-phase delivery: Injection registers an attempt; the item is marked sent only after a successful heartbeat ack. If the agent replies with
[SILENT](nothing to report), the item is snoozed for 6 hours and retried — not dismissed - GUI management: View, dismiss, or snooze from Settings → Memory Center → Follow-ups tab (card UI, status filters, per-agent filter)
- REST API:
GET/PATCH /api/v1/memory/follow-ups— list, dismiss, snooze; invalid status query returns 400 - 72-hour auto-expiry: Stale commitments are automatically cleaned up (scoped per agent/user)
- 24-hour rolling window: Maximum 3 commitment notifications per day to prevent notification fatigue
Real-Time Memory Notifications
When the agent silently learns from your conversations, Myrm keeps you in the loop with real-time GUI notifications:- Auto-extraction toast: When context compression evicts tool-call content, the harness framework extracts it as long-term memory in the background. Upon completion, a toast notification appears: “Remembered N items from conversation”
- Throttle & merge: Multiple extractions within 2 seconds are merged into a single notification to prevent alert fatigue
- One-click review: Every notification includes a “View Memory” action button that jumps directly to Memory Center
- Recall scope updates: When conversation recall inclusion/exclusion changes, a toast confirms the action with a human-readable description
- Silent failure: If the SSE push fails, memory extraction continues uninterrupted — notifications are best-effort, never blocking
- 5-language i18n: Notifications are fully localized in Chinese, English, Japanese, Korean, and German
Session Notes — Zero-Cost Task Continuity
When conversations grow long enough to require compression, traditional approaches use an LLM to generate summaries — consuming tokens and potentially losing important details. Myrm maintains Session Notes — a structured, 8-section cognitive model that the AI builds incrementally in the background:
When compression is needed, Session Notes replace old messages with zero additional API calls — no LLM summary generation required. Combined with 8 loop detection algorithms and 7 domain-specific suggestion generators, this ensures long tasks stay on track without goal drift.
Evolution Digest — Behavioral Pattern Discovery
Myrm periodically analyzes your accumulated memories to discover behavioral patterns — recurring habits, evolving preferences, and declining trends that you might not notice yourself. How it works:- Every 168 hours (or on-demand via the “Analyze Now” button), the consolidation LLM examines your memory graph
- It identifies patterns across 5 categories: tool preferences, workflow habits, communication styles, topic interests, and scheduling tendencies
- Each pattern is scored by confidence (0–1) and durability (Emerging → Established → Declining)
- High-confidence patterns are automatically promoted to ProceduralRules — making the AI smarter without manual configuration
- Card-based pattern list with expandable evidence summaries
- Durability badges (purple = established, orange = declining, gray = emerging)
- Confidence scores with color-coded indicators
- Actionable suggestions for each discovered pattern
- Manual trigger button for immediate analysis
Auto-Learning from Mistakes
Traditional AI assistants start fresh every session — repeating the same mistakes. Myrm has triple-layer automatic learning built in:
Example flow:
- You say “Never use sudo again” → captured instantly as a critical rule bound to
bash_code_execute_tool - AI uses wrong API → you correct it → system stores
source_error: "Used deprecated v1 API"+ correct approach - Next time → retrieval automatically returns this correction with
(avoid: Used deprecated v1 API)label - The outdated memory is automatically demoted by 90% — it won’t resurface
Right to be Forgotten — Cascade Memory Deletion
When you permanently delete a chat from the Trash, Myrm automatically removes all memories derived from that conversation — semantic facts, episodic events, procedural rules, and pending review items. How it works:- Open Trash in the sidebar and select a chat for permanent deletion
- The confirmation dialog shows exactly how many memories will be affected
- On confirmation, all memories tagged with
source_chat_idmatching that chat are purged across all stores (Vector + Relational)
- True privacy: Deleting a chat means the AI genuinely forgets what it learned there — no “ghost memories” influencing future responses
- Clean testing: Delete experimental chats without polluting your knowledge base with incorrect memories
- GDPR-aligned: Implements the spirit of the Right to be Forgotten — deletion is thorough and verifiable
Bulk operations: “Empty Trash” cascades through every chat being removed, ensuring complete cleanup.
Embedding Configuration
Myrm supports 7+ embedding providers out of the box. Configure in Settings → Retrieval → Embedding:
Local embedding with Ollama — Your data never leaves your device. After installing Ollama, run
ollama pull nomic-embed-text (or bge-m3 for multilingual), then configure as shown above.
Embedding Model Migration
When you change the embedding model in Settings, previously stored memories are encoded with the old model’s vectors and cannot be retrieved by the new model. Myrm handles this transparently:- Automatic Detection — After saving a new embedding model, the system scans for “orphan collections” (memories stored under the previous model)
- Inline Warning — If orphan memories are found, an amber banner appears in Settings showing the count
- One-Click Migration — Click “Migrate” to re-embed all orphan memories using your new model. The process reuses the existing export/import pipeline
- Safe & Reversible — Original collections are preserved (not deleted), so no data is lost even if migration is interrupted
- Memory Doctor Integration — The
probe_orphan_collectionscheck appears in Health diagnostics, ensuring long-term awareness