ZaiMem code review: memory as infrastructure, with a deployment trap

DEEP PROJECT REVIEW · SOURCE CODE + LIVE DEMO

Open the live page and ZaiMem hands you a private token before it asks who you are. That small choice says a lot about the product: memory as infrastructure, not another chat window. Behind it runs a Next.js 16 service with 33 MCP tools in eight packs, a Prisma data model, deterministic 384-dimensional embeddings, document and meeting pipelines, and an optional private GitHub repository as a readable backup. The idea holds together. The review is about whether the implementation does too.

How it is put together

The browser dashboard and MCP clients meet the same application layer. Next.js route handlers authenticate a `zm_…` bearer token, then call domain modules under `src/lib/zaimem`. Prisma provides SQLite locally and a generated Postgres schema for managed deployments. Mutations can queue a four-second debounced snapshot to a private GitHub repo. That split is sensible: protocol, domain logic, storage, and UI are visible boundaries rather than one server file.

How recall works

The vector engine is local and deterministic. It tokenizes words, adds character four-grams, hashes features into 384 dimensions with FNV-1a, applies sublinear term-frequency damping, and normalizes the vector. Recall combines cosine similarity with keyword, recency, importance, access, pin, and project signals. A 0.94 threshold treats a memory as a duplicate; lower near-matches can merge. This avoids an embedding API and its cost, but hashed n-grams capture lexical resemblance better than deep semantic equivalence across paraphrases or languages.

Security choices worth keeping

New API tokens use 24 random bytes and are stored as SHA-256 hashes. Legacy plaintext rows migrate on successful lookup. GitHub personal access tokens are encrypted with AES-256-GCM, and only a hint is displayed. The forget tool uses preview then confirmation. Memory text is scanned for quarantine patterns. GitHub sync compares blob hashes and avoids rewriting unchanged files. These are specific controls, not a generic “secure” badge.

const score =
  cosine(query, memory) * semanticWeight
  + keywordBoost(memory)
  + recencyBoost(memory)
  + importanceBoost(memory)
  + (memory.pinned ? pinBoost : 0);

Explanatory pseudocode based on the reviewed ranking stages, not a verbatim source excerpt.

The deployment trap

The repository says this plainly: SQLite under Vercel lives in ephemeral `/tmp`, so cold starts can produce separate blank stores. A bootstrap database prevents missing tables, not data loss. The hosted demo is therefore useful for interface testing, but durable multi-instance use needs managed Postgres or the long-running Docker mode. GitHub snapshots help recovery, yet they do not turn ephemeral request storage into a consistent transactional database.

Where the code review finds weak spots

The main weakness is breadth ahead of focused tests. CI lints and builds, and the README reports end-to-end checks, but the checked-in workflow does not run a dedicated unit or integration suite. The 33-tool surface increases compatibility and authorization cases. Query-string token support is convenient but can leak through logs and browser history; headers are safer. Wildcard CORS is appropriate for broad MCP clients only because possession of the token is the security boundary. The home-built embedding should publish retrieval benchmarks before “semantic” recall is treated as proven.

How it looks and reads

The production landing page is disciplined: black canvas, clear white type, one violet accent, one primary action, and an immediate compatibility strip. It explains a technically dense system through live-looking loops rather than a feature wall. The dashboard has more surface area than the landing page, so progressive disclosure is essential. Tool packs are a good answer: users can hide whole capability groups while core memory stays locked on.

How to evaluate it for real

Build a corpus with exact repeats, paraphrases, multilingual equivalents, stale preferences, poisoned instructions, two projects with overlapping vocabulary, and a deleted document. Measure recall precision at k, cross-project leakage, false merges, time to forget, and recovery from a GitHub snapshot. Run the same set on SQLite, Postgres, and after a cold start. The product’s value is continuity; continuity should be the benchmark.

Best for: Developer teams that can run Postgres or a persistent Docker host and want inspectable agent memory.

Verdict

ZaiMem is strongest as an inspectable continuity stack for developers who want MCP-native memory without an external embedding service. Its deterministic retrieval, explicit provenance, handoff tools, and readable GitHub backup are thoughtful. The honest caveat is operational: use Postgres or a persistent Docker host for real data, and demand retrieval and isolation tests before trusting the broad tool surface with important memory.

Project links and credit

Live demo: ZaiMem. Source: GitHub.

Reviewed source at commit e15c1f9 · Live demo