Mnemosyne
Zero-cloud AI memory layer, SQLite-backed, single pure-Python dependency, works with any agent framework.
Evidence shows: local-first design, no telemetry by default, data stays on machine; sync is optional and supports client-side encryption; environment variables are clearly documented. Deductions: user confirmation mechanism is weak (no explicit confirmation flow); dependency security relies only on version ranges, no pinning or audit; rollback mechanism only mentions built-in memory as a rollback point, no concrete implementation; publisher identity is unverified, source attribution based only on repository metadata.
Evidence shows: code and tests are consistent, CI covers multiple Python versions; dependencies are clearly declared but not pinned; error handling is tested (e.g., export failure does not leak paths). Deductions: dependency availability not verified (no check that dependencies are obtainable); failure messages are not explicit in some scenarios.
Evidence shows: supports multiple platforms and integration methods, provides environment variable configuration; capability boundaries are documented (e.g., embedding model choices); trigger mechanisms (e.g., MCP, CLI) are clear; environment fit considers low-resource devices. Deductions: some scenarios (e.g., specific platforms) are not fully covered in configuration details.
Evidence shows: documentation structure is clear, with installation guides, examples, FAQ; naming is stable (e.g., mnemosyne command); known limitations are mentioned in README (e.g., benchmark version labels); MIT license is explicit; CHANGELOG and release process exist. Deductions: maintenance responsibility is unclear (publisher identity unverified, maintainer info unclear).
Evidence shows: output format (e.g., JSON) is suitable for programmatic use; multiple integration methods provide high marginal value (local-first, zero-dependency); cost-benefit is reasonable (lightweight, suitable for low-resource environments). Deductions: some features (e.g., vector search) require additional dependencies, potentially increasing cost.
Evidence shows: benchmark results have version labels and explanations, distinguishing different metrics; tests cover key functionality; documentation separates facts and inferences (e.g., benchmark caveats). Deductions: cross-source corroboration is insufficient (relies only on own docs and tests, no independent verification).
- Publisher identity is unverified; verify source before installation.
- Dependencies are not pinned, posing supply chain risk.
- User confirmation mechanism is weak; sensitive operations may proceed without prompt.
- Rollback mechanism is unclear; be aware of data loss risk.
What does this agent do, and when should you use it?
Mnemosyne is a local-first, Hermes-first memory layer for AI agents. It provides persistent memory through a single SQLite file with hybrid retrieval (vector + FTS5 + importance). The BEAM architecture includes working memory, episodic memory, and a temporal knowledge graph. It supports MCP (stdio/SSE/streamable-http) and Python SDK, integrating with Cursor, Claude Code, Codex, OpenWebUI, and more. Installation is a simple pip install with no external services. Data stays on your machine by default. Advanced features include CLI, sync, and client-side encryption.
Mnemosyne launches an MCP server via mnemosyne mcp or exposes remember() and recall() functions in Python. Under the hood, it uses SQLite with sqlite-vec and FTS5, scoring by 50% vector similarity + 30% keyword + 20% importance. It offers a temporal knowledge graph (TripleStore) and memory banks for domain isolation. CLI commands include store, recall, stats, export/import, and sync. Sync supports bidirectional delta updates with optional encryption.
- Developers who want cross-session memory in Claude Code or Cursor without uploading data to the cloud
- Teams deploying agents on a VPS that need centralized memory and sync
- Hermes Agent users who want built-in memory and automatic context injection
- Privacy-sensitive users who need fine-grained control over memory (expiry, importance)
- Developers building custom Python agents and needing quick persistent memory integration
- Low-resource environments (e.g., Raspberry Pi) that need a minimal-dependency memory system
What are this agent's strengths and limitations?
- Local-first by default, no data leaves the machine, no telemetry
- Single SQLite file, simple deployment with zero external dependencies
- Built-in MCP server, works with multiple agent platforms out of the box
- Strong benchmark results: 65.2% on BEAM 100K, low latency (35ms at 10M messages)
- Client-side encryption for sync, server cannot read memory content
- Benchmark numbers may be outdated; BEAM scores from v3.0.0 not re-run
- Default embedding model is English-optimized; multilingual requires configuration
- Full features (local embeddings, LLM consolidation) require significant RAM
- Sync feature requires additional server setup and key management, adding operational complexity
How do you install or deploy this agent?
Install with pip install mnemosyne-memory (core) or pip install "mnemosyne-memory[all]" (full with vector search and MCP). Requires Python 3.10+.
How do you use this agent?
- Add MCP server config to your client (e.g., Cursor) with
command: "mnemosyne", args: ["mcp"]. 2. Or in Python:from mnemosyne import remember, recall, then callremember("User prefers dark mode")andrecall("preferences"). 3. Use CLI directly:mnemosyne store "...",mnemosyne recall "...". 4. Configure environment variables for embedding model and database path.
How does this agent compare with similar options?
Compared to alternatives like mem0, Letta, and Honcho, Mnemosyne stands out for its local-first, zero-dependency approach, built-in MCP server, and multi-platform support. On benchmarks, it scores 87.4% on LongMemEval (vs. mem0's 49%), but 65.2% on BEAM (vs. Hindsight's 73.4%, though with a different judge).
FAQ
Do I need external API keys?
How is data security handled?
Does it support non-English languages?
paraphrase-multilingual-MiniLM-L12-v2 via environment variables.