Holographic Memory MCP
The WARM MCP server gives an AI agent a persistent, local memory store — you can write facts, find them again by meaning or metadata, inspect and export the store, and delete entries.
Store memories (
remember): save durable facts, decisions or preferences with an id, title, tags and arbitrary JSON metadata; supports optimistic concurrency (if_version) and create-only writes.Recall by question (
recall): rank full memories against a natural-language query, optionally filtered by tags and minimum score.Filtered search (
search): metadata filters, lexical/semantic weighting, rank-fusion choice (blendorrrf) and per-hit score detail, returning previews.Fetch one memory (
get): read a known id in full, including tags, metadata, timestamps and version.Delete (
forget): remove memories by single id, batch of ids, or id prefix (prefix deletion requiresconfirm: true); reports what was deleted and what was missing.Browse (
list): page through memories in id order by prefix or tag, with previews or full text and a cursor.Inspect (
stats): see counts, recall mode, encryption-at-rest status, store size and active limits without reading contents.Export (
export): dump memories as JSON, JSONL or Markdown for backup or portability, paginated by cursor.
Everything runs against a local store directory; reads (recall, search, get, list, stats, export) are read-only, and only remember and forget modify data.
WARM
Local memory for AI agents and applications.
WARM (WritersLogic Adaptive Retention & Memory) gives agents persistent memory, full-text and vector search, and source provenance in one embeddable Rust engine. Use it inside your application, through HTTP, or from an MCP client, with storage on infrastructure you control.
Website · Docs · Get started · Standards and provenance · Evaluation · Capabilities · Limits · Contribute
What it is
WARM is a Rust library that stores text, vectors and facts in a
directory on your machine and finds them again. It ships with optional Node.js, C, WASM and UniFFI
bindings, an HTTP server with portable JavaScript and Python clients, and an MCP server.
The embedded engine makes no service calls or telemetry requests: the offline job in ci.yml runs the default-feature test suite in a network namespace without external interfaces and checks that the default dependency tree has no HTTP, TLS or socket client. HTTP clients connect to the
server you configure; model stages are opt-in. Capabilities and limits: What ships today.
Related MCP server: mnemo-mcp
Who it's for
You are building | What you get |
An agent or assistant that needs memory | A memory API with forgetting that removes facts from the store, and an MCP server for editors and agent hosts |
A local-first or offline app | Embedded search and storage in one directory, with no server process and optional encryption |
A service that needs vector or text search |
|
Get started
You are using | Install | Next |
An editor or agent host (MCP) |
| |
Rust |
| below |
Node, embedded engine |
| below |
JavaScript or TypeScript, HTTP client |
| |
Python, HTTP client |
| |
A server for the HTTP clients |
|
All options, source builds, version requirements and the HTTP-client-or-embedded choice: Install and Choose an integration. WARM runs locally or on your own infrastructure. This repository contains no hosted service. WritersLogic sells WARM Sync, a separate encrypted multi-device sync service with its own client package; the engine here does not contact it.
To try the offline memory demo from source:
git clone https://github.com/writerslogic/warm
cd warm
cargo run --release --example demo-offline-agentRust. The crate is warm-rust; the library is imported as writerslogic_warm. MSRV is Rust 1.89; local-models and --all-features need 1.94 or newer.
use writerslogic_warm::{DocumentInput, SearchOptions, WarmCore};
fn main() -> Result<(), Box<dyn std::error::Error>> {
// A store is a directory; it persists there and reopens with the same arguments.
let dir = std::env::temp_dir().join(format!("warm-quickstart-{}", std::process::id()));
let warm = WarmCore::new(4096, Some(dir.display().to_string()), None)?;
warm.memorize_document(DocumentInput {
id: "backups".into(),
text: "Restore deleted documents from verified backups.".into(),
source_uri: Some("operations.md".into()),
version: Some("1".into()),
metadata: None,
chunk_words: None, overlap_words: None, store_text: None, embeddings: None, title_weight: None,
})?;
let hits = warm.search_documents("restore backups", &SearchOptions::default())?;
println!("{} {:?}", hits[0].document_id, hits[0].source_uri);
drop(warm);
std::fs::remove_dir_all(&dir)?;
Ok(())
}Node.js (writerslogic-warm; the portable client is a separate package with a different API; listDocuments supports scoped pruning, see the integration guide):
const { WarmMemorySystem } = require('writerslogic-warm')
const { DocumentMemory } = require('writerslogic-warm/semantic')
async function main() {
const dir = require('node:fs').mkdtempSync(require('node:path').join(require('node:os').tmpdir(), 'warm-readme-'))
const memory = new DocumentMemory(new WarmMemorySystem(4096, dir))
await memory.memorize({
id: 'backups', text: 'Restore deleted documents from verified backups.',
sourceUri: 'operations.md', version: '1', metadata: { project: 'alpha' },
})
const [hit] = await memory.search('restore backups', { filter: { project: 'alpha' } })
console.log(hit.documentId, hit.sourceUri, hit.text)
await memory.flush()
}
main().catch(error => { console.error(error); process.exit(1) })The five-minute quickstart adds a SQLite FTS5 comparison and encryption in Rust, Python and Node; CI runs that code on every pull request.
Evaluation
Recorded results and limitations cover memory quality, text retrieval and vector search. Each result retains its workload, hardware, model, source revision and known losses. The full comparison and reproduction protocol provide the evidence for evaluating WARM on your own workload.
What ships today
Capability | Status | Documented limit |
Hybrid document search (BM25 + exact cosine, filters, byte offsets) | Ships | Exact scan of eligible chunks; benchmark your corpus before assuming capacity (guide) |
Boolean lexical search ( | Ships | Flat queries only, no nesting; an empty or only-excluded query matches nothing (design) |
Atomic replace/delete, crash-safe journal, verified compaction, process lock | Ships | One writer per store; compaction is not secure erasure |
Vector index ( | Ships | Builds slower than hnswlib at M=16 and M=32 on SIFT-1M on a Core Ultra 9 185H laptop (same session); faster on a GCP Ice Lake VM, where the WARM build is a separate-session rerun (results); behind ScaNN and faiss-ivfpqfs on single-core ann-benchmarks at recall 0.95 for WARM revision |
Updatable vector index (durable delta for inserts and deletes) | Ships | Single writer; format in VECTOR-UPDATES.md |
Query-aware graph routing (trained on sample queries) | Ships (opt-in) | Needs representative training queries; tested on VIBE llama and yi (report) |
Memory API: remember, recall, forget, explain | Ships | Forgetting removes a fact from the store; it does not cover what a model inferred (docs) |
Conversation memory ( | Ships | Bounded context with exact source provenance; native recall not yet benchmarked on LongMemEval end to end (the LongMemEval result in EVALUATION.md is a research pipeline with external Qwen3 models, not this API) |
Meaning memory: sparse hypervectors with bind, bundle and permute, triples, multi-hop, Hopfield cleanup | Ships (runtime opt-in) | Tested on a set of 2,000 synthetic plus 120 real facts ( |
Union-bundle membership ( | Research | At D = 16,384: positive gap to N = 500 (4% false positives), tested to 2,500 ( |
Vector API ( | Ships | Backed by the updatable vertex graph; glove-100 recall@10 0.859 at 2,092 QPS on one thread of an Apple M4 under load, on or below the hnswlib and FAISS HNSW curves in the same file, with a 478 s build ( |
Encrypted stores ( | Ships | AES-256-GCM, Argon2id; covers the log, index caches and the text segment. Metadata, file names and sizes are not encrypted |
Signed audit log, credential-gated access, COSE_Sign1 over Ed25519, | Ships | Host must authenticate DIDs; PoSME, RATS, |
On-device models ( | Ships | Local weights only; never downloads |
| Ships | Single node; TLS, per-tenant scoped keys (guide) |
MCP server ( | Ships | Encryption needs |
JavaScript/TypeScript client ( | Source and release builds | Portable HTTP client; requires a separately running server |
Embedded Node.js ( | Source and release builds | Eight optional native platform packages; separate from the client |
C, Go, .NET, Java, Kotlin, Swift and WebAssembly bindings | Source available | Require local builds; the language packages and native bundles are not yet published (runtime guides) |
Python | HTTP client ( |
|
Query-private search ( | Experimental | For searching an index someone else holds; hides the query vector from the scorer only (notes) |
Optional engine capabilities use Cargo features or runtime configuration; Cargo features lists the build choices.
The compatibility policy defines API stability, deprecation windows and storage-format migration rules.
Architecture
Diagram and module map: docs/ARCHITECTURE.md.
Limits
Limit | Detail |
Not anonymous | Sketches and term counts are not encryption; |
Document search is conventional | It does not use the hypervectors; the holographic parts are the algebra and the meaning memory. Concepts |
One writer per store | A second writing process fails at open with a lock error. A store is a directory; |
Capacity numbers are points | Stated only over the tested range. Capacity |
Benchmarks are single machines | Conditions are in each results file; the single-core ann-benchmarks run and the VIBE high-recall points are losses (Where it's behind) |
Report vulnerabilities privately via SECURITY.md.
Contributing
CONTRIBUTING.md: setup, the checks CI runs, DCO sign-off (git commit -s, no
CLA). Start with a good first issue
or Discussions. See the
Code of Conduct. Benchmark changes regenerate the results file they touch;
the README cites files, not remembered figures.
License
Apache-2.0. See LICENSE. Use, modify and embed it in open-source or proprietary software, including network services, with no copyleft obligation. The historical v0.6.1 source remains available under its AGPL-3.0-or-later license.
Available Tools
8 toolsexportExport memory contentsARead-onlyIdempotent
Read a portable snapshot of memory contents as JSON, JSONL or Markdown; use list for short previews instead. Read-only. The payload is returned as text and capped by the server's export byte limit; pass next_cursor as cursor to continue.
Inputs: tag, limit, cursor, format, +1 more. Returns: bytes, count, format, next_cursor
forgetDelete memoriesADestructiveIdempotent
Delete memories from the active store by id, ids or id prefix; use remember to update content instead. Inspect prefix matches with list first: prefix deletion requires confirm: true. Returns the deletion count and ids that were absent.
Inputs: id, ids, prefix, confirm. Returns: deleted, missing
getGet memoryARead-onlyIdempotent
Read one known memory id in full, including tags, metadata and version. Use an id from list or search; use recall when only a natural-language question is known. Read-only; an unknown id returns an error.
Inputs: id (required). Returns: memory
listList memoriesARead-onlyIdempotent
Browse memories in id order, optionally limited by id prefix or tag; use search for relevance ranking. Read-only. Returns text previews unless full is true; pass next_cursor as cursor to continue.
Inputs: tag, full, limit, cursor, +1 more. Returns: count, memories, next_cursor
recallRecall matching memoriesARead-onlyIdempotent
Retrieve full memories ranked for a natural-language question. Use this for ordinary recall; use search when you need metadata filters, ranking controls or score details. Read-only; default builds rank lexically, and a configured model adds semantic ranking.
Inputs: query (required), k, tags, min_score. Returns: count, results
rememberStore memoryADestructive
Store a durable fact, decision or preference; use recall to find one instead. A supplied id replaces that memory, while an omitted id creates a new one. Use if_version to reject concurrent changes or create_only to reject overwrites.
Inputs: text (required), id, tags, title, +4 more. Returns: id, bytes, created, version, +1 more
searchSearch memory with filtersARead-onlyIdempotent
Find memories with metadata filters or ranking controls; use recall for simpler full-text answers. Read-only. Results contain text previews and relative ranking scores, not probabilities; use get to read a result in full. Semantic scores require a configured model.
Inputs: query (required), k, tags, filter, +4 more. Returns: count, results
statsStore statisticsARead-onlyIdempotent
Inspect store counts, recall mode, encryption status, storage size and active limits without reading memory contents. Read-only; use list to inspect stored memories.
Inputs: no named parameters. Returns: limits, recall, memories, namespace, +6 more
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 8 tools
Each tool targets a distinct operation, but `recall` and `search` both perform retrieval and rely on the descriptions to separate natural-language lookup from filtered/ranked lookup; `list` also overlaps with `search` for browsing. The descriptions do a good job of redirecting between them, so an agent is unlikely to misselect in practice.
All names are short, single-word imperative/lowercase tokens (remember, recall, search, get, forget, list, export) with `stats` as the only noun form. The convention is consistent and readable, just not a strict verb_noun pattern.
Eight tools is a well-scoped surface for a memory store: write, several read modes, delete, and two introspection utilities. No tool looks redundant enough to remove, and nothing feels missing at the count level.
Covers the full lifecycle: create/overwrite (remember with id/if_version/create_only), read (get, recall, search, list), delete (forget), diagnostics (stats) and snapshot export. The notable gap is an `import`/restore counterpart to `export`, plus explicit tag/metadata-only mutation, which agents must work around by rewriting content.
Maintenance
Related MCP Connectors
Persistent memory for AI agents. Search, store, and recall across sessions.
Persistent memory and knowledge management for AI agents with semantic search and 50+ tools.
Persistent memory for AI agents. Semantic search, memory graph, W3C DID identity.
Memory system for AI agents with semantic search. Store and recall memories with ease.
Related MCP Servers
- AlicenseAqualityAmaintenanceEnables Claude AI to seamlessly interact with Scrivener projects for document management, AI-powered content analysis, and advanced writing assistance.57297 npm74AGPL 3.0
- AlicenseAqualityDmaintenancePortable cognitive memory for AI agents with semantic search, decay, and deduplication.86 npm2MIT
- AlicenseAqualityNot gradedmaintenancePersistent memory MCP server for AI agents, using SQLite with hybrid keyword and semantic search for long-term memory storage.5Do What The F*ck You Want To Public
- AlicenseNot gradedqualityBmaintenanceLocal-first, multi-user shared memory for AI agents with semantic search, offline support, and team synchronization.MIT