Summary

Local retrieval that publishes its numbers, and a compact mode that matters.

Two things stand out. The retrieval is a real pipeline rather than a keyword search — a bi-encoder plus an int8 cross-encoder reranker, both local, with the reranker taking about three quarters of the roughly 14ms median latency. And recall defaults to compact mode, returning enough to choose from and leaving the full content behind `memory_detail`, which is the difference between a memory tool that saves context and one that eats it. Benchmark figures come from the `amem-core` engine on LongMemEval-S.

What it is

An MCP server that gives every AI coding tool the same persistent memory, backed by one SQLite file at `~/.amem/memory.db`. The retrieval engine lives in a separate library, `amem-core`, so recall improvements and MCP tool changes ship independently. Everything runs locally: no cloud, no API keys, no vector database.

What you get

Core memory work — `memory_store` with a type, tags and confidence (auto-redacting private content and auto-expiring contradictions), `memory_recall` for semantic search in a compact mode, `memory_detail` for the full content of one result, `memory_context` to load everything relevant to a topic under a token budget, `memory_extract` for batch saves, `memory_forget`, and `memory_inject` to surface corrections, decisions and graph neighbours before coding starts
Precision and history: `memory_patch` for a field-level edit with an automatic snapshot, `memory_versions` to view or restore any earlier version, `memory_search` for exact full-text search via FTS5, `memory_since` for temporal queries in natural ranges like `7d` or `2w`, and `memory_relate` to build a typed knowledge graph
Advanced retrieval and lifecycle — `memory_multi_recall` fusing semantic, full-text, graph and temporal search; `memory_tier` to move memories between core, working and archival; `memory_expire`; `memory_summarize` and `memory_history` for session summaries
`memory_reflect`, a reflection engine that clusters your memories, detects contradictions, identifies synthesis candidates and surfaces knowledge gaps, returning a report with suggested actions and a health score
Six memory types ranked by priority, with corrections at the top so an agent's hard constraints always surface first: correction, decision, pattern, preference, topology, fact
Three memory tiers — Core, always injected at session start; Working, session-scoped; Archival, searchable but not auto-injected — and temporal validity, where superseded facts are expired rather than deleted so you can still ask what was true in March
Admin, reminders and maintenance: `memory_doctor` and `memory_repair` for the database, `memory_config`, `memory_sync` to import and export against Claude auto-memory and Copilot instructions, four reminder tools, and `memory_log`, `memory_stats`, `memory_export`, `memory_import` and `memory_consolidate`

Requirements

No account, no API key, no cloud. Node 18 or newer. In Claude Code and GitHub Copilot CLI it installs as a plugin from the repository's marketplace; for Cursor, Windsurf or any other MCP client, `npm install -g @aman_asmuei/amem` then `amem-cli init` detects and configures the tools you have installed, and `amem-cli rules` writes extraction rules so the assistant reaches for memory on its own. `amem-cli stats` confirms it is live. The npm package is `@aman_asmuei/amem`, run over stdio.

Setup effort

One command — npm install -g @aman_asmuei/amem