memrust v0.6.1 — metrics, logs, official Docker image

Operational plumbing: the things a team checks before adopting infrastructure.

Metrics

GET /metrics serves Prometheus exposition — request counters and latency histograms by matched route (so cardinality can't blow up on user-supplied paths), plus per-namespace gauges for memories, index sizes, graph entities and WAL depth. Engine gauges are read live from the registry at scrape time, so they can't drift from reality.

memrust_memories{namespace="acme"} 1204
memrust_request_duration_seconds_bucket{route="/v1/recall",le="0.001"} 812
memrust_requests_rejected_total 3

Metrics name every namespace, so the endpoint needs an unscoped key when --api-key is set.

Structured logs

--log-format json emits one object per request — method, route, namespace, status, duration. text stays the default, off disables it.

GET /healthz

An unauthenticated liveness probe. This fixes a real bug: the Docker healthcheck hit /health, which answers 401 once --api-key is set, so every authenticated container would have been marked unhealthy. A probe shouldn't need to hold credentials.

Official Docker image

docker run -p 7700:7700 -v memrust-data:/data aianytime/memrust

Multi-arch (amd64 + arm64), non-root, with dependency layers cached so rebuilds are fast.

cargo install memrust
pip install --upgrade memrust
npm install memrust-client

memrust v0.6.0 — namespaces and API keys

The two things that stood between "interesting project" and "something I can deploy".

Namespaces

Every request selects a store with the X-Memrust-Namespace header. A namespace is a separate engine — its own indexes, WAL, checkpoint, embedding dimension and directory — not a filter over a shared index. So one tenant's ingest can't slow another's recall, two tenants can use different embedding models, and dropping a namespace deletes a directory instead of scanning a shared index.

Namespaces are created on first use and reopened from disk at startup. GET /v1/namespaces and POST /v1/namespaces/drop administer them.

API keys

# unauthenticated — fine on loopback, and the server says so at startup
memrust serve

# require keys, and scope them
memrust serve --api-key "$ADMIN_KEY" --api-key "$TENANT_KEY:acme,acme-staging"

Keys arrive as Authorization: Bearer <key> or X-API-Key. An unscoped key gets everything including admin routes; a scoped key is confined to its namespaces. Comparison is constant-time. When the server is unauthenticated and bound to a non-loopback address, it warns — the failure mode worth preventing is binding 0.0.0.0 without realizing every memory is public.

Verified over real HTTP: 401 without a key, 401 with a wrong one, 200 for a scoped key on its own namespace, 403 on another's, 403 on admin routes with a scoped key.

Upgrading is safe

A data directory written before namespaces existed is adopted as the default namespace in place. Tested by writing memories with the published v0.5.4 binary, reopening the directory with this build, and recalling them — plus a regression test. Namespace names are validated before they become path segments, so .. and / are rejected.

cargo install memrust
pip install --upgrade memrust
npm install memrust-client

memrust v0.5.4

Performance release. Every number below was measured with the scripts in benches/.

Recall is ~3x faster and now hits recall@10 = 1.000 (was 1.92 ms / 0.985 at 20k vectors, now 0.64 ms / 1.000). Profiling found the filter predicate running on every visited node even when nothing needed filtering — and its presence engaged a traversal visit cap that was quietly costing recall. Recall also no longer deep-clones hundreds of candidate records before discarding all but top-k.

Writes no longer block readers for the duration of an fsync. The write path is split: the record is persisted while holding only a read lock, then the exclusive lock is taken briefly to make it visible. Reads under a concurrent writer went from 467 to 957 QPS with p50 halved (8.52 → 4.78 ms). A commit lock brackets both phases so a checkpoint cannot land between them and lose an acknowledged write — verified with four writers racing a checkpoint loop plus kill -9: 1,000 acknowledged, 1,000 recovered.

Bulk ingest no longer fails on real batches. The HTTP body limit was axum's 2 MB default, which rejected batches over ~400 memories at 384 dims. Raised to 256 MB. Batch ingest also group-commits one fsync per batch (221 → ~990 records/s).

ef_search is settable per query, in the HTTP API and both SDKs — trade latency for accuracy without restarting.

Known limitation, stated plainly: a concurrent writer still costs about half of read throughput, because HNSW insertion (~2 ms) runs under the exclusive lock. Single-writer remains a design constraint.

cargo install memrust          # or grab a binary below
pip install --upgrade memrust
npm install memrust-client

memrust v0.5.3

The dashboard now has a light theme and a toggle.

It follows your system light/dark preference by default; the header toggle overrides it in either direction and the choice is remembered (applied before first paint, so no flash on load). Each theme's signal colors are selected against their own surface rather than auto-inverted, and both palettes pass the categorical color checks — including colorblind separation.

The Colab notebooks download this version, so they get the toggle too. Python and TypeScript SDK versions are now aligned with the engine.

pip install --upgrade memrust     # Python SDK
memrust serve                     # dashboard + HTTP API on :7700

Binaries below: Linux x86_64 (static musl — runs anywhere, including Colab) and both macOS architectures.

memrust v0.5.2

SQ8 quantization is now the default for vectors ≥ 1024 dims.

At that width and above, quantized search measures as fast as — or faster than — f32, because memory bandwidth dominates the extra decode arithmetic. So the 4× memory saving comes for free. Measured on an M-series laptop (n=6k, clustered, memrust bench):

Dim	f32 QPS	SQ8 QPS	f32 recall@10	SQ8 recall@10	Vectors
384	6,241	5,468	1.000	0.998	8.8 → 2.2 MB
1024	1,562	1,645	1.000	0.992	23.4 → 5.9 MB
1536	1,001	1,006	1.000	0.996	35.2 → 8.8 MB

Below 1024 dims f32 is faster and stays the default. Since the vector width isn't known until the first insert, the storage mode settles then (while the store is still empty) and is fixed for the life of the collection. Force it with --quantize / --no-quantize.

Checkpoints written by earlier versions still load — the old boolean quantize: false maps to Never, so an existing collection never silently changes representation.

pip install memrust      # Python SDK
memrust serve            # dashboard + HTTP API on :7700

memrust v0.5.1

Fixes found by writing the Colab notebooks — the first end-to-end consumer of the bring-your-own-embeddings path.

• Consolidation summaries are recallable by vector in BYO-embedding collections. Summaries were embedded with the engine's own embedder, which can't produce dimension-compatible vectors when callers supply their own — the summary silently degraded to lexical-only. They now use the normalized centroid of their source embeddings.
• vector_dim in engine stats — the vector index's real dimension, distinct from embedding_dim (the engine's own embedder, unused under BYO).
• Three runnable Colab notebooks: quickstart, RAG with sentence-transformers, and PDF RAG with a LangGraph agent.

Install

pip install memrust                # Python SDK
docker build -t memrust .          # or grab a binary below
memrust serve                      # dashboard + HTTP API on :7700

Binaries below cover Linux x86_64 (static, musl — runs anywhere including Colab) and both macOS architectures.

memrust v0.5.0

First public release: memory infrastructure for AI agents.

Hybrid retrieval (HNSW + BM25 + entity graph + recency) behind an agent-native
remember / recall / forget API with per-signal explained scores, an
embedded web dashboard, HTTP + MCP interfaces, multi-agent private/shared
memory, a full memory lifecycle (TTLs, consolidation, snapshots), and
zero-dependency Python and TypeScript SDKs.

Install

# Python SDK (server client)
pip install memrust

# Engine from source / Docker
cargo build --release          # or: docker build -t memrust .
memrust serve                  # dashboard + HTTP API on :7700
memrust mcp --agent-id me      # MCP server for Claude Code etc.

macOS binaries are attached below (aarch64 / x86_64); Linux binaries and
crates.io/npm publishes land via CI once the account's Actions access is
restored.

See CHANGELOG.md
for the full v0.1 → v0.5 history.