WARM

Memory serverOfficial Writerslogic project

Created by Writerslogic

Published in writerslogic/warm. Publisher page

27 GitHub starsUpdated 2026-11-11

What it is

WritersLogic Adaptive Retention & Memory (WARM): local document search (BM25 + embedding cosine) and vector-symbolic associative memory.

— the description by Writerslogic

AutoGineer overview, from the brain’s own files

WARM (WritersLogic Adaptive Retention & Memory) is a local-first memory engine designed to provide AI agents and applications with persistent storage and retrieval. It combines traditional document search—using stemmed BM25 and vector-based cosine similarity—with a vector-symbolic layer for associative memory and multi-hop queries. The system is built in Rust and can be deployed as an embedded library, an HTTP server, or an MCP server, allowing it to integrate with various agent hosts and development environments. It emphasizes local control, offering optional encryption and provenance features while avoiding external service calls or telemetry.

How it works

Memory model: Hybrid

AutoGineer overview, from the brain’s own files

The system stores text, vectors, and facts in a local directory. It uses a hybrid approach where document search combines chunking and BM25 with vector embeddings. The vector-symbolic layer utilizes sparse hypervectors to support associative memory, triples, and multi-hop queries. It provides an API for memory management including remember, recall, and forget operations, with support for source provenance and atomic storage updates.

Folders
Folder	Role	Files
.github	agent-config	37
assets	attachments	10
docs	docs	1850
examples	examples	47
scripts	scripts	77
src	source-code	327
tests	tests	362
benches	folder	7
benchmarks	folder	2898
bindings	folder	273
deploy	folder	18
figures	folder	6
fuzz	folder	54
integrations	folder	225
interop	folder	3
notebooks	folder	3
npm	folder	1
proptest-regressions	folder	1
schemas	folder	9

The agent reads

query_batch evidence: README.md
get_document evidence: README.md
list_documents evidence: README.md
get_document_info evidence: README.md
list_document_info evidence: README.md

Requirements

Runtimes: Node.js, Python >=3.9, Rust

Databases: SQLite

API keys (by name): WARM_API_KEY

Works with: Gemini CLI

Set it up

This brain runs code automatically: 1 hook (claude-code), 1 script. Review benchmarks/results/sbg_positions_development/setup.sh, integrations/editors/claude-code/plugin/hooks/hooks.json before opening the folder in Claude Code. No step below turns a hook on for you.
- benchmarks/results/sbg_positions_development/setup.sh: sh benchmarks/results/sbg_positions_development/setup.sh
- integrations/editors/claude-code/plugin/hooks/hooks.json: node
Not scanned by AutoGineerThe author’s README also describes installing it from a clone of its repository. Read its install section: AutoGineer did not scan that path. https://github.com/writerslogic/warm/blob/e176d5572dd86bf2233bcb120e3a485dc109ea3a/README.md#get-started
Not scanned by AutoGineerThe author’s README also describes installing it as the npm package writerslogic-warm. Read its install section: AutoGineer did not scan that path. https://github.com/writerslogic/warm/blob/e176d5572dd86bf2233bcb120e3a485dc109ea3a/README.md#get-started
Created by Writerslogic. Published in writerslogic/warm. Licence: Apache License 2.0.

Usage

AutoGineer overview, from the brain’s own files

Integrating memory into an AI agent via the MCP server.
Building local-first applications that require embedded search and storage.
Providing a multi-tenant memory service via the HTTP server.
Using the Rust library for in-process memory management.

“Remember that the project deadline is Friday.”: The agent stores the fact with associated metadata, making it available for future retrieval.
“Recall information about the project deadline.”: The agent retrieves the stored fact using hybrid search and provides the information with source provenance.

Documentation by Writerslogic

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.

Image: CI Image: MSRV 1.89 Image: OpenSSF Scorecard Image: OpenSSF Best Practices Image: License: Apache-2.0 Image: WARM MCP server: quality and maintenance score on Glama

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. HTTP clients connect to the server you configure; model stages are opt-in.

Capability	What you get
Document search	Chunking, stemmed BM25 over blocked postings, Boolean and phrase queries, hybrid fusion with embeddings you supply, metadata filters, byte offsets
Vector index	Graph index with a memory-mapped vertex file, an updatable delta for inserts and deletes, optional query-aware routing trained on sample queries
Memory API	`remember`, `recall`, `forget` and `explain` with time validity and supersession; conversation memory with source provenance
Storage	Atomic replace and delete, crash-safe journal and checkpoints, verified compaction, one writer per store
Security	Optional AES-256-GCM storage encryption with documented coverage and limits, signed audit log, COSE/SCITT provenance
Vector-symbolic layer	Sparse hypervectors with bind, bundle and permute, triples with multi-hop queries, Hopfield cleanup

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	`warm-server` over HTTP with tenants and scoped keys, or the library in-process

Get started

For an editor or agent host, start with the MCP integration. For an application, choose the Rust library or HTTP server below. WARM runs locally or on your own infrastructure; this repository does not provide a managed cloud service.

To try the offline memory demo from source:

git clone https://github.com/writerslogic/warm
cd warm
cargo run --release --example demo-offline-agent

From your own Rust project, add the current Apache-2.0 source. The crate is warm-rust; the library is imported as writerslogic_warm. The MSRV is Rust 1.89; local-models and --all-features need Rust 1.94 or newer.

cargo add warm-rust

The historical v0.6.1 source remains AGPL-3.0-or-later; it is available from that Git tag, not as a warm-rust 0.6.1 release on crates.io.

use writerslogic_warm::{DocumentInput, WarmCore, SearchOptions};

let dir = tempfile::tempdir()?;
let warm = WarmCore::new(4096, Some(dir.path().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: Some(serde_json::json!({ "project": "alpha" })),
    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);

Rust API change in 0.6.6 (0.6.5 returns these values directly): WarmCore::query, query_batch, and analyze_components return Result. Handle the result with ? or an explicit error branch; deferred-encoding failures no longer become successful partial query results. get_document, list_documents, get_document_info, and list_document_info also return Result; retained-text and checkpoint decoding failures propagate instead of panicking, and reads no longer hydrate the entire checkpoint or hold store locks during text I/O.

</details>

<details> <summary>JavaScript and TypeScript: portable client</summary>

warm-sdk 0.2.1 is the portable HTTP client for a separately running warm-server. It has no native binaries or runtime dependencies and uses standard Fetch and Web Streams APIs (Node 18 or newer). Installing or importing it does not load the embedded engine or download models. For a published release, install the client in your application:

npm install [email protected]

Check the available npm versions. To build the client from this checkout:

npm ci --prefix bindings/js/warm-sdk
npm run build --prefix bindings/js/warm-sdk

In your application, install that directory with npm install /absolute/path/to/warm/bindings/js/warm-sdk.

Start the server in a separate terminal:

cargo build --release --features server --bin warm-server
WARM_API_KEY=change-me target/release/warm-server --input-dim 384

import { WarmClient } from 'warm-sdk'

const warm = new WarmClient({
  url: process.env.WARM_URL ?? 'http://127.0.0.1:8080',
  apiKey: process.env.WARM_API_KEY, tenantId: 'demo',
})
await warm.memory.remember('Restore deleted documents from verified backups.', {
  id: 'backups', metadata: { project: 'alpha' },
})
const hits = await warm.memory.recall('restore backups', { filter: { project: 'alpha' } })
console.log(hits[0]?.text)

Set WARM_API_KEY to the server's key before running the client. This memory example uses lexical retrieval and needs no embedding model. A runnable source example also checks retrieval and deletion in an isolated namespace:

WARM_URL=http://127.0.0.1:8080 WARM_API_KEY=change-me \
  node examples/quickstart/js-client/quickstart.mjs

See the client API and release availability. Browser deployments must permit the application's origin at the HTTP service boundary.

</details>

<details> <summary>Node.js: optional embedded engine</summary>

writerslogic-warm embeds the Rust engine in Node. For a published engine release, install it explicitly with npm's optional dependencies enabled:

npm install [email protected]

Check the available npm versions. To build from the cloned repository, with Rust installed:

npm ci --omit=optional
npm run build

The portable client and embedded engine are separate packages with different APIs. listDocuments supports scoped pruning. See the integration guide for source provenance, namespace isolation, dry runs and deletion limits.

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) })

</details>

<details> <summary>Server and Python</summary>

The Python package warm-sdk is an HTTP client for warm-server, which stores vectors you supply. (warm-python, imported as writerslogic_warm, provides native vector indexes and phase vectors, but no document search.)

cargo build --release --features server --bin warm-server
WARM_API_KEY=change-me target/release/warm-server --input-dim 384 &
uv pip install warm-sdk

from writerslogic_warm_sdk import WarmClient

client = WarmClient(url="http://127.0.0.1:8080", api_key="change-me", tenant_id="demo")
client.add_documents([{"id": "a", "vector": [0.1] * 384, "text": "hello", "metadata": {}}])
print(client.query([0.1] * 384, top_k=1)["matches"][0]["id"])

Endpoints, flags, tenants and limits are in the server docs. A runnable Python quickstart with a toy embedder is in examples/quickstart/python.

</details>

warm-mcp serves a store to any Model Context Protocol client over stdio or HTTP:

npx -y writerslogic-warm-mcp                                # stdio; downloads a verified binary on first run
npx -y writerslogic-warm-mcp --transport http               # http://127.0.0.1:8765/mcp

The MCP package is a separate launcher. To build the server from source:

cargo build --release --features mcp,security --bin warm-mcp   # add local-models for semantic recall
./target/release/warm-mcp                                       # stdio
./target/release/warm-mcp --transport http                      # http://127.0.0.1:8765/mcp

Client setup, data directory and the one-writer rule: MCP integration.

For normalized content from multiple applications, see the organizational knowledge adapter.

</details>

The five-minute quickstart walks through ingest, search, a SQLite FTS5 comparison and encryption in Rust, Python and Node, and CI runs that code on every pull request. For a whole agent memory with no embeddings and no network, run cargo run --example demo-offline-agent.

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 (`+required`, `-excluded`, quoted phrases)	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 (`qgraph` vertex graph, memory-mapped)	Ships	Build time and serving RSS behind hnswlib on SIFT-1M (gaps)
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 (`conversation-memory`)	Ships	Bounded context with exact source provenance; native recall not yet benchmarked on LongMemEval end to end
Meaning memory: triples, multi-hop, Hopfield cleanup	Ships (runtime opt-in)	Tested on synthetic and 2,120-fact sets (`research_bench_16384_256.json`)
Union-bundle membership (`experimental`)	Research	At D = 16,384: positive gap to N = 500 (4% false positives), tested to 2,500 (`benchmark_scaling_results.json`)
Sparse vector index (`memorize_vector`)	Experimental	Not competitive with HNSW (results)
Encrypted stores (`security`)	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/SCITT/C2PA (`provenance`)	Ships	Host must authenticate DIDs; PoSME, RATS, `did:web` not implemented
On-device models (`local-models`: Qwen3 embed/rerank/LLM)	Ships	Local weights only; never downloads
`warm-server` HTTP API, multi-tenant (`server`)	Ships	Single node; TLS, per-tenant scoped keys (guide)
MCP server (`mcp`: `warm-mcp`, stdio and HTTP)	Ships	Encryption needs `security`; semantic recall needs `local-models`
JavaScript/TypeScript client (`warm-sdk` 0.2.1)	Source and release builds	Portable HTTP client; requires a separately running server
Embedded Node.js (`writerslogic-warm` 0.6.8)	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 (`warm-sdk`); native vector indexes and phase vectors (`warm-python`)	No in-process document search
Query-private search (`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

flowchart TB
  subgraph bindings["Bindings and servers"]
    rust["Rust crate"]
    node["Node: writerslogic-warm (napi)"]
    ffi["C, WASM, UniFFI"]
    clients["JavaScript and Python: warm-sdk"]
    server["warm-server (HTTP)"]
    mcp["warm-mcp (stdio, HTTP)"]
  end
  subgraph engine["Engine API"]
    core["WarmCore: documents, vectors, facts, mutation gate"]
    prov["Security and provenance: signed audit log, COSE/SCITT"]
  end
  subgraph indexes["Indexes and memory"]
    text["Text index: blocked postings, BM25, Boolean and phrase"]
    vector["Vector index (qgraph): vertex file, updatable delta, query-aware projection"]
    memory["Memory API: remember, recall, forget, conversation memory"]
    vsa["Vector-symbolic layer: bind, bundle, Hopfield cleanup"]
  end
  subgraph storage["Storage"]
    journal["Journal and checkpoints"]
    segments["Append-only segments (CRC32, LZ4)"]
    mapped["Memory-mapped files"]
    crypto["AES-256-GCM encryption (optional)"]
  end
  clients --> server
  rust --> core
  node --> core
  ffi --> core
  server --> core
  mcp --> core
  core --> text
  core --> vector
  core --> memory
  core --> vsa
  core --> prov
  memory --> text
  text --> journal
  vector --> journal
  memory --> journal
  journal --> segments
  segments --> mapped
  segments --> crypto

Module map: docs/ARCHITECTURE.md.

Limits

Not anonymous. Hypervector sketches and term counts are not encryption; anyone with a store can encode candidate text and compare. storeText: false keeps term counts, IDs and embeddings, so it is not a privacy control.
Document search is conventional. It does not use the hypervectors; the holographic parts are the algebra and the meaning memory.
One writer per store. A second writing process fails at open with a lock error.
Capacity numbers are points, not guarantees, and are stated only over the tested range (capacity).
Benchmark results are single machines. Conditions are in each results file; the single-core ann-benchmarks run and the VIBE high-recall points are losses (see Where it's behind).
Masking is obfuscation. Client-side vector masking preserves every pairwise similarity.
A store is a directory and WarmCore::new(.., None, ..) uses the current directory.

Full statement: docs/PRIVACY.md. 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.

CHANGELOG.md

Changelog

All notable changes to this project are generated from the commit history. Format: Keep a Changelog + Conventional Commits.

v0.6.3 migration and integrity notes.

[0.6.8] - 2026-11-11

Fixed

Prepare the release with nonblocking tenant admission (#432)
Reject tenant admission during exclusive maintenance
Publish the JavaScript SDK from an explicit local path

[0.6.7] - 2026-11-11

Added

Add portable JavaScript client and retain optional embedded engine
Load immutable index snapshots shared across Linux processes
Measure and repair bottom-layer reachability, and expose the build options to the VIBE adapter

Documentation

Lead JavaScript installation with registry packages
Focus the public repository on product usage
Integrate historical Big ANN evidence with qualified comparisons
Record the requested benchmark stopping point
Record frozen Azure streaming and filter confirmations
Record low-level ablations and immutable sharing tradeoffs
Record the Ice Lake filter-track tuning with held-out selection and ablation
Add the second control run and the official-protocol logs to the Ice Lake filter results
Record the llama test-set confirmation of the held-out selection
Record the generation-2 screens and the routed-placement full run; keep only the retrain phase log
Record the local-rebalance full runs L5a and L5b and the gen-2 conclusion
Record the balanced warm-retrain streaming study and Ice Lake runs
Record the second E2 Ice Lake run
Record the rescore-budget A/B and the pending consolidation measurements
Correct the streaming run hosts to Zen 4 and Zen 2 and note the live leaderboard CSV
Mark the filter operating point in the pinned-run table

Fixed

Defer documentation search loading until requested
Render documentation styles and version notice before paint
Harden release dependencies and benchmark tooling
Widen quantized dot products before integer overflow
Bound Python result allocations and stabilize extreme cosine queries
Check specialized Python result allocations before search
Reject duplicate IDs in persisted graph mappings
Reject overflowing strides in empty Python result arrays
Close files with context managers and drop unused imports in the VIBE scripts
Close files with context managers and drop unused imports in the L22 scripts
Remove an unused import and variable and return explicitly in the L22 scripts
Upgrade rmcp to 3.9 for RUSTSEC-2026-0462 (#420)
Upgrade rmcp to 3.9 for RUSTSEC-2026-0462
Close files with context managers in the LongMemEval context-assembly scripts
Drop an unused import and tighten the blind-rankings test assertions
Use assertLessEqual in the compact-context fill test
Skip already-published npm versions so a partial release can be re-run (#418)
Skip already-published npm versions so a partial release can be re-run
Model background-compaction tail schedules in the simulation (#419)
Model background-compaction tail schedules in the simulation
Close the export file in summ.py and drop an unused import in ga.py
Close files with context managers in the ann-benchmarks campaign scripts

Performance

Validate shared snapshot bindings without rereading vectors
Share query loads and bound rerank prefetch
Speed up the filtered index and retune it for the yfcc-10M filter track (#417)
Block the multi-label filter and skip the tombstone probe when nothing is deleted
Cache the intersection of repeated label sets in a sorted filtered batch
Size-banded inverted-file target for the filtered index
Add result-preserving filter tuning (tag-grouped batch order, prefetch distance, zmm VNNI)
Make the result-preserving filter execution choices the default
Keep ef 175 and add ef 320 to the WARM VIBE grid (56 points) and record the llama test re-measures
Restore ef 500/800 in the WARM VIBE grid (52 points) and record the llama test re-measure
Balanced warm retrain for streaming L22 (study and Ice Lake results) (#413)
Add route_inserts and the knob override for coarse placement
Drop an unused binding in place
Expose the local rebalance knobs to the knob override
Route row placement through super-centres (route_cands, route_lists) for inserts and retrains
Fix the python binding for route_cands and satisfy clippy
Add a local rebalance that splits only the oversized lists
Route warm-retrain placement through the nearest new centres and log retrain phases
Default the python partition index to the balanced-retrain streaming configuration
Add retrain, per-live-size nprobe and selective spill knobs to the partition tier
Rebalance near-empty centres between k-means iterations and log retrains
Honour rerank on a base with deletes; bench: compact LongMemEval context (#391)
Rescore only the rerank best live candidates on a base with deletes

Bench

Held-out search for the VIBE recall tail, learn-heavy builds and a rerank-dense grid (#410)
Add the learn-heavy VIBE builds and a rerank-dense grid, with held-out search tooling and results
LongMemEval dev context-assembly screen (partial, no 500 confirmation) (#407)
Add the LongMemEval dev context-assembly screen (summaries, facts, date references)
Record the LongMemEval_S k30+preopen reader passes
LongMemEval_S 500-question held-out run (#394)
Re-pin the LongMemEval 500 frozen config to the single-turn export
Record the LongMemEval_S 500-question held-out run
Create the LongMemEval 500 state directory before writing the spend ledger
Export each LongMemEval turn once, at its first position
Freeze the LongMemEval 500-question protocol at the implementation commit
Re-pin the LongMemEval 500 frozen config to the out-of-memory fix
Add a sealed LongMemEval 500-question run with a label-blind rankings export
Derive the per-item rate without the container start time in the LongMemEval Modal waves
Retry LongMemEval embed and rerank batches at half size on CUDA out-of-memory
Re-pin the LongMemEval 500 frozen config and raise the Modal GPU cap to 30 USD
Measure compact LongMemEval context and user-turn fill under a fixed reader-token budget
Keep compact-layout LongMemEval runs in their own summary arm
Add base-with-deletes search and staged consolidation cgroup fixtures
Re-measure the ann-benchmarks entry through the harness and add the held-out candidate search tooling
Add the 8 GiB streaming final-runbook run
Record the pinned-commit yfcc-10M filter and msturing-30M streaming harness runs

Research

Validate upper seed bounds and reject speculative traversal
Validate certificate arithmetic and audit benchmark instruments
Bound navigation headroom and verify audit provenance
Record mission baselines and rejected frontier mechanisms

[0.6.6] - 2026-11-09

Added

Add adaptive per-query probe rules to the partition tier
Expose the partition tier to Python and record the L22 full-stream run (#398)
Validate the query width in PartitionIndex and record the L22 test B run
Expose the experimental partition tier to Python as PartitionIndex
Report the partition scan split and take acceptance nprobes from the environment
Add the experimental partition tier (IVF, SOAR spill, LUT16 residual codes) (#396)
Record per-phase timings of the last partition search
Add the experimental partition tier with SOAR spilling and LUT16 residual codes
Write document checkpoints with block-packed postings (version 2) (#390)
Write document checkpoints with block-packed postings (version 2)
Land the supersession probes, k-mer, FPE timestamp and AVX2 popcount work (#388)
Land per-store language analyzers, cheaper history views and a simulation harness (#387)
Refuse replaying chunks whose analyzer mark disagrees with the store
Run WARM store analyzers and summarize the closed gap in the MIRACL harness
Add a persisted per-store lexical analyzer with language stemmers and Persian and Hindi normalization
Add a MIRACL multilingual lexical comparator with Lucene analyzers
Add the supersession probe harness for STALE
Add bounded background compaction with progress and cancellation
Add k-mer encoder retrieval evaluation harness
Add the FPE timestamp retrieval harness
Add read-only historical views over the journal
Add fractional power encoding of timestamps behind experimental
Add K-mer sparse encoder for DNA and RNA sequences
Add default-off query-reinforced edge repair for the vector graph
Add AVX2 and AVX-512 screen popcount candidates with paired microbenchmark
Add qgraph navigation diagnostics with serving-search replay
Add work-bounded filtered dense search
Integrate Vectra filtering and validated retrieval work
Improve vector retrieval and expand comparisons
Add native vector migration and retire bincode (#378)
Add experimental prefix retrieval and rename the Node SDK (#376)
Integrate qualified Vectra migration adapter
Integrate native vector records and schema upgrade support
Add lossless native vector records with atomic revisions
Add an owned Vectra migration adapter
Rename the Node SDK package to warm-sdk
Add an explicit document retrieval embedding task
Add opt-in Matryoshka graph candidates
Add opt-in Matryoshka graph candidates
Add an explicit document retrieval embedding task
Expose verifiable audit records through public interfaces (#356)
Expose verifiable audit records through public interfaces
Recover committed audit effects after restart (#353)
Recover committed audit effects after restart
Name the Rust distribution warm-rust
Use concise Python package names and distinct publishers
Rename the product and integrations to WARM
Verify scoped remote authorization and SCITT inclusion receipts (#340)
Add organizational knowledge integration examples

Changed

Remove obsolete Python compatibility aliases
Rename the benchmark package to warmbench

Documentation

Bring the README and project docs up to date for 0.6.6 (#416)
List every Cargo feature and remove rename artifacts
Correct package names, release steps and API names
Update benchmark method notes and streaming status
Fix README sources, install notes and anchors for 0.6.6
Record the low-level systems candidates, proxy results and miss audit
Record the Ice Lake full-run confirmation, the graph runs and the read-ahead patch
Record the Ice Lake np650 streaming run (recall 0.9942 in 2,722 s) (#411)
Record the Ice Lake np650 streaming run (recall 0.9942 in 2,722 s)
Record the Ice Lake streaming runs (recall 0.9848 in 2,666 s) (#404)
Record the Ice Lake streaming runs (recall 0.9848 in 2,666 s)
Record that the streaming entry takes 5,618 s on Ice Lake, over the hour
Mark the VIBE 4-bit risk table as superseded for the submission grid
Record the board-config streaming run (#399)
Document the experimental PartitionIndex Python class
Record the fork CI outcome in the PR 357 body copy
Record the board-config streaming run (recall 0.9726, 2,550 s) in the README and benchmark docs
Record the L22 partition-tier research, search profile and nprobe selection (#397)
Record the L22 search profile, live sweep and nprobe selection
Record the L22 partition-tier kill tests, kernels and acceptance with their scripts and results
Avoid an intra-doc link to the private fastscan module
Correct the RSS range and the measured binary commit in the consolidation heap peak record
Record the consolidation heap peak measurement
Record the landed checkpoint hit decode in the FiQA QPS gap lever
Record the removed per-hit document rebuild in the QPS lever
Name nDCG in its glossary entry so site search finds it
Record the measured checkpoint serving costs in the QPS lever
State the pinned text wins and the FiQA QPS loss with profiled levers
Label each README benchmark row with the machine it was measured on
Drop intra-doc links to private analyzer items
Record MIRACL ru, es, fr and de results for the store analyzers
Record MIRACL results for the store analyzers
Note that kept history views also hold their index
Correct the counting-Bloom capacity claim with an equal-bits comparison
Update the time-travel cost section for bulk indexing and reuse
Disclose the label caveats and the interval in the cue-tag result
Record MIRACL multilingual BM25 results for the tokenizer variants
Record the cue-tag supersession kill test on STALE (KILL)
Pre-register the cue-tag supersession kill test
Record the supersession probe result on STALE (NO-GO)
Record the executed scope of the supersession probe before the run
Pre-register the supersession probe protocol on STALE
Correct the short as_of list count
Register the as_of overfetch protocol before running it
Cite edge repair and entry point prior art
Record measured time-travel view cost
Record edge repair results on GloVe and SIFT and park it
Correct the as_of filter cost range in the FPE write-up
Record the FPE timestamp kill test result and decision
Add k-mer encoder evaluation write-up
Add k-mer encoder evaluation result and user guide
Record the screen popcount kill test and its x86 results
Fix the FPE timestamp protocol and decision rule before the run
Define time-travel semantics over the journal
Design bounded background compaction
Record 2026-11-02 milestone qualification evidence
Point historical AGPL release at the v0.6.1 tag
Fix broken server documentation link (#384)
Investigate dynamic switching combinations
Record repaired comparison resource failures
Preregister a possible repaired comparison
Record offline library compile check
Qualify default graph recall
Preserve user-requested study stop
Bind completed 100k graph result
Preserve 100k graph quality failure
Preserve initial graph quality failure
Record comparison preparation admission
Record verified comparison input freeze
Clarify comparison execution admission
Preserve WARM progress at the requested stopping point
Preserve merged SDK and prefix retrieval qualification
Ground memory selection and Vectra evaluation in prior evidence
Clarify comparison persistence and reader boundaries
Plan bounded Vectra quality and scale comparisons
Ground memory selection evaluation in prior work
Specify schema 7 vector records
Keep prefix retrieval experimental after fresh quality checks
Record the completed recovery followup merge
Track temporal workflow and fresh Matryoshka qualification
Explain full-vector reranking and candidate limits
Record completed recovery and query qualification
Clarify the remaining graph delta scan
Store hosted vector evidence as its exact compressed export
Record proposed quality-preserving memory reduction experiment
Record hosted qualification and queued migration preparation
Align readiness and configuration with durable retries
Preserve canonical cleanup regression evidence
Record recovery gates and unresolved performance qualification
Record query memory allocation evidence and timing limits
Clarify serial validation evidence
Record verified retrieval gains and audit validation limits
Preserve audit benchmark validation and measurement limits
Record repository cleanup and quality findings
Record completed WARM migration and release verification
Record verified MCP publication and legacy retirement
Remove the former name explanation from README
Install the verified WARM registry releases
Record WARM publication and bound external link checks
Record verified audit repairs and validation evidence
Record managed analysis deferral
Record ToIP collaboration introduction

Fixed

Allow the partition-only scan helpers to go unused without experimental
Bump oauthlib to 4.0.1 in the chroma benchmark requirements (#400)
Bump oauthlib to 4.0.1 in the chroma benchmark requirements
Decode checkpoint hits at capture so nothing reads the mapping after its locks
Install a pinned Temurin 21 in the Modal bench image for Lucene 10
Drop the chunk flags check now that every bit is assigned
Normalize lexical text to NFC and fold Turkish dotted and dotless I
Regenerate Node declarations for background compaction
Label Lucene in published tables with the version the result recorded
Report the finished stage and compare vector counts in compaction tests
Look up renamed evidence sessions in the cached embeddings
Distinguish unset mem0 arguments and correct integration test boundaries
Account warmbench server memory across detached descendants
Skip tenants already holding unknown receipts when invalidating durable limits
Route exclusive file locks through flock on Android
Skip embeddings for lexical search
Embed fact-expanded document keys
Validate direct staged search embedder identity
Return large vector results through typed bindings
Use local embeddings with model stages
Honor ingest spans in model pipelines
Bound stale graph delta capture
Improve vector recall and harden storage boundaries
Bind comparison provenance to host and runtime
Qualify combined comparison accounting
Gate comparison results on complete timed quality
Integrate bincode removal with native vector records
Remove bincode while preserving durable event compatibility
Reject nonportable Vectra metadata filenames
Exclude research results from crate archives
Allow reusable npm workflow attestations
Complete durable retry and query-efficiency followups (#375)
Close retry receipt readers before replacement
Resolve durable retry modules in the fuzz target
Preserve scrub retries during canonical compaction
Preserve HTTP retry protection across restarts
Prepare retained text before commit and retry cleanup
Complete recovery, retrieval and native binding readiness (#374)
Preserve checkpoints during vector maintenance (#373)
Propagate checked Memory API reads (#372)
Bound MCP exports and select text reads (#371)
Propagate checkpoint metadata read failures (#370)
Propagate checked document read failures (#369)
Delete aged CrewAI memories across all pages (#368)
Secure maintained integration dependency profiles (#367)
Propagate query failures and bound snapshot archives (#366)
Retire legacy SDK integrations and refresh dependencies (#365)
Preserve retained text integrity and report cache failures (#364)
Tighten document summaries and Haystack contracts (#363)
Enforce Python framework adapter contracts (#362)
Harden archive restores and dependency exposure (#360)
Harden SDK transport and migration durability (#361)
Correct HTTP errors and expand Windows service coverage (#359)
Reject ambiguous authentication and retry headers (#358)
Reject ambiguous authentication and retry headers
Make conditional HTTP validators reflect response contents (#357)
Derive cache validators from observed response bytes
Honor weak HTTP entity-tag comparison semantics
Upgrade Candle to remove vulnerable ZIP dependencies (#355)
Upgrade Candle to remove vulnerable ZIP dependencies
Require audit history after store initialization
Preserve retry safety under failures and cache pressure (#352)
Preserve retry safety under failures and cache pressure
Preserve audit alignment and reject malformed records (#351)
Complete WARM cleanup and validate the combined changes (#350)
Integrate scoped recall and Windows spill review repairs (#347)
Upgrade mem0 integration and preserve locked test environments
Resolve quality gates and harden documentation redirects
Allow legacy npm deprecation without deletion retries
Release corrected MCP metadata in version 0.6.5
Preserve the MCP reserved metadata contract in release schemas
Complete example renaming and record registry retirement
Use the accepted warm-python distribution name
Repair renamed examples and benchmark provenance
Repair the five verified October 30 audit defects (#343)
Support audit repairs in docs and Windows test fixtures
Validate and bound Python phase operations
Make shared framework history clearing recoverable
Fail closed when provenance evidence is incomplete
Preserve and verify complete framework source text
Enforce framework embedding identity before opening stores
Validate campaign integration and restore quality gates (#342)
Preserve durable identities and bound security lifecycle failures (#341)
Share memory validation and preserve adapter ownership (#339)
Resolve temporal eligibility before memory ranking (#338)
Resolve additional bounded audit concerns (#335)
Resolve audited integrity and retrieval defects (#334)

Performance

Test the low-level system defaults of the L22 streaming path (#409)
Add an opt-in transparent-huge-page allocator for the Python extension and a runbook replay driver
Expose the partition centres and per-id lists for the miss audit
Gate the wheel allocator behind a cfg and load mimalloc with dynamic TLS
Add opt-in list-order slot placement for the partition tier and held-out miss audit in the replay driver
Read WARM_PLACE for the partition index placement switch
Drop the killed allocator and placement arms, keep the miss-audit diagnostics
Cut the L22 scan overhead around the quad kernel and batch the reorder (#406)
Cut the L22 scan overhead around the quad kernel and batch the reorder
Fuse admission into the LUT16 scan and add AVX-512 and VNNI quad paths (#403)
Fuse admission into the LUT16 scan and add a VNNI quad layout
Add an AVX-512BW path to the LUT16 block scan
Balance partition search threads by estimated scan work
Restore the fused table-build loop
Accumulate the AVX2 block scan in 16-bit words and vectorise the table build
Build the upper layers before the adjacency during consolidation (#393)
Build the upper layers before the adjacency and free the slot maps early
Decode checkpoint hits without a chunk vector and fuse the streaming rescoring pass (#392)
Prefetch and fuse the base rescoring pass on the tombstone path
Decode a checkpoint hit's record without a chunk vector and share repeated metadata
Read checkpoint hit fields only for final results instead of rebuilding a document per hit
Decode two-byte checkpoint postings without leaving the loaded word
Make history view reuse opt-in
Index a history view once and reuse built views
Land AVX2 screen popcount, background compaction and historical views (#386)
Add the postings block-size sweep driver and build script
Make the posting block length a build-time parameter
Batch document installs in historical views and record their cost
Land working tree, journal segment sizing and query hot lists (#385)
Dispatch the AVX2 screen popcount from four words on x86
Keep decoded weighted postings of long checkpoint lists per thread
Count single-chunk ASCII documents without collecting word spans
Start the active journal segment at 1 MiB
Start the active journal segment at 1 MiB
Add native Vectra filters and preserve development evidence
Avoid copying encoded vectors during reads
Reduce vector query overhead
Track vector snapshot changes by document
Isolate stale vector ranking from the fresh path
Release the store lock before stale exact scoring
Reuse query capture storage for sorted owner addresses
Reduce retrieval capture allocations and validate audit write cost (#354)
Reduce document retrieval capture allocations
Remove the docs hero image fetch from the critical path
Prune inactive documentation navigation
Preload the documentation landing image
Reuse filtered eligibility and bounded dense mutation deltas (#337)

Security

Pin AML runtime artifacts and document model dependency reachability

Bench

VIBE OOD check, and the streaming entry's Ice Lake timing (#401)
Record that the VIBE submission grid reaches 0.95 and 0.99 on OOD sets
Report every repetition of the partition step with mean, median and p90
Carry the reused table's base and scale in the scan-only mode
Time one partition-tier search step over the LUT16 block scan
Pin the text comparison and speed up mapped-checkpoint posting decode (#389)
Rerun SIFT-1M against hnswlib at a pinned commit
Rerun the text comparison at pinned commits against the current comparator pins
Measure default and opt-in history view opens
Measure cold and reused history view opens
Record local paired old-vs-new comparator run for nfcorpus and memory
Re-pin text comparators to tantivy 0.27.0, Lucene 10.6.0 and SQLite 3.53.1 with previous-pin version controls

Merge

Lever/repin-comparators
Lever/as-of-overfetch
Issue/163-time-travel
Issue/42-background-compaction
Issue/1-hamming-simd
Integrate the documentation loading improvement

Release

Publish the MCP Python launcher as warm-mcp

Research

Commit the regression check evidence and the pre-filter check
Record the as_of overfetch test and its no-go
Add per-query dump and filter-after-top-k arms to the memory API LME harness
Add mutation, source and temporal trace studies
Add filtered dense and certified association studies
Add vector topology information and navigation studies
Land the frozen Matryoshka prefix study
Add navigation trace mode to vector topology diagnostics
Preserve fresh native Matryoshka evidence and source history
Record fresh native Matryoshka quality limits
Bind native retrieval to fresh SciFact vectors
Tighten preflight accounting before measurements
Freeze native Matryoshka retrieval harness
Freeze fresh native Matryoshka generation
Record the frozen Matryoshka prefix results
Freeze the Matryoshka prefix retrieval study

Style

Satisfy clippy 1.99 in the partition tier
Format the record walker
Format the checkpoint block codec and its tests
Close files with pathlib in the remaining probe scripts and drop an unused import
Close files with pathlib reads and writes in the cue-tag and probe scripts
Satisfy clippy 1.99 and rustfmt in the merged FPE timestamps evaluation
Close the result file in the equal-bits script
Format the multilingual analyzer tests
Format the merged history and engine modules
Satisfy clippy in the supersession probe example
Name the revision tuple in the time-travel test
Format edge repair sources
Format the FPE timestamp module
Format the storage import in admin

[0.6.4] - 2026-10-28

Added

Add optional AML provenance and evidence research tools

Changed

Organize bindings and research source modules

Documentation

Align landing page with retrieval architecture
Add Glama score badge (#316)
Explain crate recovery environment policy (#322)
Explain npm registry propagation gate

Fixed

Bootstrap Python docs from the current source layout
Synchronize release and OpenAPI versions
Preserve guarded final benchmark allocations
Enforce provenance semantics and cached status expiry
Preserve Mem0 recovery and completion integrity
Clarify MCP tool behavior for Glama (#317)
Reduce crate archive for crates.io (#321)
Verify every npm platform before install (#320)
Verify every npm platform before install

[0.6.3] - 2026-10-26

Added

Add reproducible AML GCE installer
Add persistent AML host launcher
Add AML Cycle 2 adapter and query repair
Make MCP server scorable by Glama (#313)
Add a blocked learned-sparse inner-product index (big-ann sparse track) (#294)
Scale query-aware projection to millions of learn queries (#295)
Add label-filtered exact uint8 search with per-label inverted files (#291)
Add direct IP serving and independent candidate retention (#207)
Add compact adjacency and publish ANN cost results (#206)
Assemble bounded conversation context with exact source provenance (#203)
Add optional query-aware graph routing (#204)
Improve memory recall within a small round budget (#202)
Diagnose streaming recall and verify crash boundaries (#201)
Add exact Boolean lexical search and blocked postings (#200)
Batch inserts and a Python UpdatableIndex for the updatable vector graph (#190)
Count matching documents and ingest unstemmed terms (#193)
Persist and update mapped vector graphs (#181)
Preserve original conversation evidence and audit memory quality (#184)
Add VIBE diagnostics and rotation controls (#183)
Euclidean and inner-product metrics in the Python VectorIndex (#186)
Clustered private ranking of dense codes at n = 1280 (#177)
Server-mode comparators and an hms-server row in the harness (#157)
Raise HolographicError with the server's error code and message (#145)
Add NGT, ScaNN, PyNNDescent, Voyager and DiskANN to the ANN harness (#156)
Euclidean metric for the vertex index and SIFT in the harness (#150)
Expose the vector index to Python and add ann-benchmarks and VIBE wrappers (#149)
Framework adapters for agent and RAG stacks (Python and JS) (#106)
Stable C ABI with Go, Java and .NET bindings (#109)
Index-routed server vector queries, deferred ingest modes, memoized encoder, and round-2 research kill tests (#139)
Local embeddings (pure-Rust engine, pinned model packs, LocalEmbedV1) (#132)
Evidence manifest, fetch script and worktree audit record (#117)
Format verifier, golden stores for every format, drift gate, crash-window fixes (#126)
WebAssembly build of the document store (@holographic-memory/wasm) (#129)
Production hms-server (scoped auth, observability, TLS, snapshots, deploy artifacts) (#127)
UniFFI mobile bindings (Swift, Kotlin/Android) (#121)
Hms-mcp MCP server, launchers, memory-tool backends and editor integrations (#110)
Memory API with temporal validity, supersession, explain and opt-in policies (#114)
Hms-import, one-command migration into HMS (#108)
Platform kernels (AVX512-VNNI, NEON fallback) with kill-test results (#107)
Integrate the parallel sessions' document store, compaction and server work (#81)
Document store with compact postings and file-backed text, staged compaction, multi-tenant server and the evidence client
Learned-sparse impact index served by HMS, measured against Anserini
One series per patience value in the ANN comparison tables
Stemmed BM25 and min-max score blend in the document API
Patience stop rule, opt-in 1-bit screen and error-returning builds for the vertex graph index
Competitor ANN harness for SymphonyQG, RaBitQ, NGT and Lucene HNSW
Check the graph cache header and verify the merged qgraph defaults
Add integer vector stores and per-vertex codes to qgraph
Batch Qwen3 decoding and padded encoder batches on Metal and CUDA
Add per-vertex 8-bit code graph index with residual re-rank
Add held-out tuning mode to public-bench ann-qgraph
Add on-device Qwen3 model stages behind local-models
Add quantized graph ANN index and its public benchmark mode
Add hms-server HTTP service for the Python SDK
Subset-union bundle experiment and capacity sweep
Add experimental query-private similarity scoring behind private-search

Changed

Clean up memory API, provenance, security and core modules (#214)
Clean up the full-text storage engine (#213)
Clean up bindings, server and MCP (#212)
Clean up qgraph kernels, projection and update format (#211)
Prune uncited experimental research code (#210)
Consolidate audit entry serialization (#185)
Drop rejected intersection kernel candidates

Documentation

Prepare npm listing and runtime release (#318)
Surface holographic operations in search
Note npm and runtime release
Prepare npm listing and runtime release
Document Glama release and score verification
Polish MCP package pages and link website (#311)
Make source quickstart accurate
Refresh branding and improve integration and search guides (#308)
Drop host names and local install notes, fix the open-test citation (#221)
Replace private paths and hosts, route large result JSON to LFS (#217)
Rewrite README with sourced benchmark badges and current architecture (#215)
Serve the documentation at docs.holographic-memory.com (#189)
List every Cargo feature and correct the server and MCP rows (#173)
Build the rustdoc with warnings denied in CI (#148)
Remove internal scoreboards, session records and process notes (#140)
Remove session logs, handoffs and planning files (#137)
Embeddings default-build check and handoff update (#135)
Render OpenAPI boolean property schemas (#131)
Passage text is encrypted at rest; document the text segment layout (#115)
Redesigned site with landing page, generated API reference, search and browser checks (#125)
Persisted file format specification and stability policy (#119)
Versioned site, quickstarts, offline agent demo, README, contributor guides (#105)
Ideas tree for October 2026 with its 10-minute proxies
Preliminary nytimes VGraph comparison on the M4 and the next-session specs
Record the green CI and the clippy toolchain for the gate
Record that main is pushed and in sync
Record that all work is on main and what was superseded
Record the merged qgraph state and what is unverified
Record the integration state
Standardize README header (#71)
Update continuation state
Record the index and model-stage outcomes
Record the holographic prototype outcome
Record continuation state for the next session
Plan the holographic fact memory and its tests
Plan local model stages inside HMS
Define the single-run protocol for LongMemEval_M
Set the speed and accuracy targets and record the compute limits
Plan the LongMemEval_M run with larger models
Record the encoder test and the agent-memory benchmark plan
Attribute semantic search to the document API
Update changelog [skip ci]
Record the outcomes of the algorithm work
Give the SDK README the project header, badges and a quick start
Use absolute logo URLs so the README renders on package registries
Update changelog [skip ci]

Fixed

Keep Python source archive within PyPI limit (#314)
Wait for MCP package indexes before registry publish (#312)
Rename Python packages and polish PyPI pages (#310)
Persist ANN benchmark indexes before serving
Update benchmark harnesses for current Clippy
Complete graph search results after component exhaustion (#301)
Refuse web-page and rebound-host requests on an unauthenticated server (#285)
Check checkpoint table sizes, stage model packs and semantic indexes privately, keep oversized fact turns out of range (#281)
Reject damaged delta offsets, save vertex indexes under unique temp names and assert re-rank row lengths (#280)
Domain-separate Sigstore signing and close KERI, CAWG, revocation and DID verification gaps (#279)
Scope tenant metrics to the key, clean up abandoned restore uploads and stop insight growth (#278)
Sync migrated and snapshot copies and the API-key directory before reporting success (#276)
Normalize extreme angular rows, bound graph-cache reads and stage Python deletes all or none (#275)
Persist revocations before applying them and add a strict status-list mode (#273)
Keep documents and format scans consistent after failed rebuilds and malformed frames (#272)
Keep tenant generations unique across reopen and harden tenant lifecycle (#265)
Leave the journal unchanged when a commit sync or segment rotation fails (#263)
Apply a journaled batch in full when one mutation fails (#264)
Domain-separate batch provenance Merkle trees and version the signed root (#243)
Decode sigstore base64 strictly and write the key event log atomically (#257)
Bind provenance signatures to the record they verify (#242)
Track VIBE job CPU per process and kill orphaned config processes in the Modal runner (#232)
Update ctutils past RUSTSEC-2026-0385 (#234)
Build the updatable index with alpha 1.0 by default (#229)
Read vector result text under the store lock (#227)
Mark the gzip LFS exception as binary (#225)
Read search result text under the mutation gate (#223)
Core review fixes for provenance, memory API and server (#219)
Measure one durable ANN mutation per operation (#180)
Make a purged store match one that never held the document (#179)
Durability-fair server verdicts and harness adapter checks (#175)
Match server durability on macOS and build ScaNN with the dataset's metric (#171)
Score docs search on the answer to the full query (#170)
Judge recall status from the index of the revision searched (#168)
Modal shard runner, text harness defects and the x86 text results (#152)
Make each journal commit durable on macOS with F_FULLFSYNC (#151)
Name the passphrase when an encrypted store cannot be decrypted (#144)
Strip debuginfo only so macOS 27 can load the native addon (#136)
Clear code-scanning alerts and restore the server_requests fuzz target (#134)
Zero replaced document text in the text segment (#128)
Purge physically erases deleted text (#124)
Encrypt the document text segment at rest (#111)
Windows compaction rename, changelog drift, dependabot npm 404 (#112)
Check tenant directories against the canonical tenants root
Fail open on arena corruption, checksum the manifests, zeroize the AES key schedule
Scrub 256 KiB of stack below the key derivation and locate surviving key copies in the scan test
Gate scrub_stack and the AES cipher impl behind the security feature
Satisfy clippy 1.99 lints in the qgraph kernels and graph cache
Keep greedy decoding at batch 1 unless a batch is set
Reserve Modal wave cost before launch so preemption cannot bypass the cap
Run HMS model stages on L4 on Modal
Decode benchmark data with as_chunks for the current clippy
Serve SDK queries by exact cosine through the document API
Resolve leftover merge markers in .bestpractices.json
Return query results best-first on exact-scan, multi-shard and federated paths

Performance

Accelerate lexical query execution and decoding
Improve phase memory and recover conversation premises
Add opt-in vector search improvements and memory controls
Reduce filtered-search allocation and scoring overhead
Share immutable position sources by document slot (#305)
Add an opt-in bound-gated exact re-rank to the vertex graph search (#296)
Resolve phrase positions through posting ordinals (#290)
Decode packed posting blocks with AVX2 (#293)
Skip frontier searches for noncompetitive delta neighbours (#289)
Spill delta rows during vector consolidation (#286)
Release old graph pages before delta insertion during consolidation (#284)
Score construction candidates four at a time and with VNNI on AVX-VNNI cores (#283)
Avoid copying surviving vectors to replace a deleted graph entry (#282)
Reduce maintenance allocations and fix retrieval regressions (#274)
Skip inverted-index hits no better than the worst kept one (#277)
Prune lexical top-k with block-max MaxScore and best-blocks-first term scans (#237)
Merge the delta into the streaming base instead of rebuilding it (#271)
Reuse warm ingest interners across rayon splits and batches (#268)
Return inverted-index hits as slot numbers instead of decimal strings (#267)
Score Hopfield queries against the stored patterns in place (#266)
Cut Python SDK per-call overhead (#269)
Fuse the first three Walsh-Hadamard stages per block of eight (#260)
Sign batch provenance credentials in parallel (#258)
Keep the pool's expanded flags in a bitmask (#252)
Clear the streaming delete-runbook baseline and drop the insert row copy (#238)
Count majority bundles in a per-thread histogram (#259)
Count majority-vote encoder levels at the touched indices (#256)
AVX-VNNI traversal kernels with the query sum computed once per query (#251)
Huge-page advice on by default, with counters and a refusal fallback test (#241)
Track visited vertices in a bitset cleared by touched word (#240)
Reuse construction scratch buffers across insertions, merges and fills (#248)
Prepare single document writes with the store's kept interner (#254)
Build chunk ids at their exact size and check them without allocating (#253)
Reuse one output buffer when recovery tests a damaged journal tail (#250)
Rebuild a checkpoint without the postings of its dead documents (#249)
Single-thread vertex search (prefetch terms, SIMD re-rank, 8-bit codes in the harness) (#226)
Open text stores from a durable document checkpoint (#235)
Persist the hms-server vector graph and open it at start (#228)
Qgraph review fixes (#220)
Full-text engine and storage review fixes (#218)
Eliminate redundant graph construction and query work (#209)
Reduce posting block allocation overhead (#208)
Bound streaming consolidation memory with mapped rows (#205)
Rank unfiltered lexical queries in the slot table at any store size (#197)
Store construction adjacency in one fixed-slot array (#182)
Faster single-threaded text ingest (#178)
Lean BM25 search endpoint and in-place fact replacement in hms-server (#176)
Build the vertex graph faster (#174)
Serve the vertex index from a memory-mapped file (#172)
Binary journal frames, in-place posting deletes and an ingest word interner (#155)
Rank unfiltered lexical queries in a per-thread slot table (#154)
Round-3 ingest, memory and ANN work with research results (#143)
Quantized construction search for the graph build; cache header records it
Keep the default neighbour loop free of the delta decoder and the cap counter
Quantized construction search and owned-input build for the proximity graph
Neighbour cap for the per-row search, lint fixes, x86 paired rows
Byte visited marks for the unfused block path; close the neighbour-block mechanism
Neighbour-block fast-scan codes with evidence fusion and a certified exit for the vertex graph
Unbiasing scale for block codes, sorted candidate pool, delta-coded adjacency
NEON per-row 1-bit screen kernel with its microbenchmark kill test (screen stays off)
Screen exact distances in vertex graph construction with 8-bit bounds
Add 4-bit traversal codes, aligned rows, BFS reorder and 3-byte ids to the vertex index
Measure Metal batching and set per-stage defaults
Prefetch rows ahead in qgraph fill, prune inputs and edge encoding
Use a bitset visited set and prefetch adjacency in qgraph construction
Scan both planes of 2-bit qgraph edge codes in one NEON pass
Speed up qgraph construction without changing the built index
Add FastScan edge kernel, batched pool merge and 2-bit qgraph edge codes
Gallop before AVX2 on skewed sizes; add intersection kernel bench
Speed up from_dense with branchless term compaction and add encoder-eval
Route sparse queries to the exact inverted index

Bench

Sync the VIBE fork and current engine pins (#307)
Record ordered payload rank prototype evidence (#306)
Record frozen bounded-consolidation tradeoffs (#303)
Record rejected consolidation scratch reuse (#302)
Verify PGO gains with an uncontended paired repeat (#300)
Record the rejected low-rank OOD experiment (#299)
Add Gorder window locality diagnostics (#298)
Record quantized delta heldout recall rejection (#297)
Record the neighbour-major block kill test against the per-row path (#292)
Build the VIBE image for x86-64-v3 and pre-register the OOD grid (#287)
Attribute the streaming runs to the measured commit (#231)
Add an HMS backend for Mem0's memory-benchmarks harness (#262)
Measure memory API write costs and record host-layer findings (#245)
VIBE wrapper with 8-bit codes, query-aware OOD builds and huge pages (#255)
Add a LoCoMo captions variant measured against the matched protocol (#261)
Profile vector-index build allocations and vertex-order locality (#247)
Count heap allocations per write-side phase of the document store (#246)
Add LoCoMo retrieval round 2 diagnosis and gated packing levers (#239)
Add LoCoMo results (#236)
Add a batch mode for the LongMemEval reader and judge (#233)
Run llama-128-ip and yi-128-ip on Modal with mlann-rf and roargraph arms (#230)
Add a crash-safe Modal runner for the VIBE float datasets (#224)
VIBE adapter for euclidean and ip datasets (#194)
Add single-core ann-benchmarks harness results on the Core Ultra 9 (#198)
Run the Bemula forgetting benchmark against the memory API (#199)
LoCoMo adapter and partial results (#196)
Score LongMemEval dev under the official reader and judge protocol (#195)
Pin the ann-benchmarks image and run euclidean datasets (#187)
Add Oct 21 2026 Core Ultra 9 competitive results (SIFT-1M, BEIR text) (#158)
Reproducible comparison harness and self-updating table (#122)
Per-session quota on the tuned LongMemEval turn ranking fails on cached dev scores
Add grid-matched vertex search pairs and correct the alignment claim
Record paired held-out timing of the vertex search encodings
Narrow the FAISS comparison and vendor the clean edge baselines
Record paired held-out timing of the per-vertex code index
Add paired-timing sync to ann-qgraph
Record held-out recall and memory of the per-vertex code index
Record timed held-out glove run of i8 vertex-code qgraph
Correct reference eval counts in memory-first results
Record held-out recall screening of qgraph memory layouts
Record the s-dev-hms cost overrun and stop
Record held-out qgraph tuning on nytimes
Measure HMS fact extraction against the Python stage on S dev
Add seeds and an equal-bytes index control to the holographic prototype
Record quantized graph results against HNSW
Prototype the holographic fact memory and measure it on LongMemEval_S dev
Make the Modal cost cap cumulative across relaunches
Key LongMemEval fact extraction by content and re-tune on dev
Record the LongMemEval dev results and the Modal dry run
Tune the LongMemEval pipeline on dev and record the ablation
Add the LongMemEval multi-key pipeline, Modal job and dev sweep
Freeze the LongMemEval 100 dev / 400 held-out split
Add LongMemEval_S retrieval baseline (dense, lexical, hybrid)
Add public BEIR and ann-benchmarks comparisons
Report encoder candidate recall after exact rerank

Deps

Rand 0.10, rand_chacha 0.10, getrandom 0.4 for bindings/wasm (#120)

Fuzz

Targets for every untrusted-input parser (#116)

Merge

Include AML GCE installer on main
Include persistent AML host launcher on main
Include AML Cycle 2 adapter on main
Integrate vector search improvements

Research

Harnesses, result files and notes from the parallel sessions
X86 confirmation of the kernel fix and the build lever on Modal (#80)
X86 confirmation of the kernel fix and the build lever on Modal
Superiority session, October 16 to 17 (#76)
Record the V37 compact-postings serving row and the session handoff
Accept V40 serving row, record the V38 transport and 2C relevance measurements
Security and privacy matrix harness and first matrix
Durability matrix harness and first matrix against SQLite and Lucene
Checkpoint native harness validation draft
Record native benchmark gate checkpoint
Establish checked LongMemEval dev answer results
Checkpoint final local reader batch and faster validation
Preserve dev reader progress and speed pilot audits
Checkpoint local reader evidence and judge progress
Checkpoint judge instability and local evidence
Checkpoint dev answer scores and repeat study
Freeze dev reader protocol and checkpoint quota blocker

Style

Address code quality findings in the integrated harness scripts
Use as_chunks for the fixed four-byte float and id decoding in the ANN bins
Read cpuinfo once and drop an unused import
Address code quality findings in the benchmark scripts
Close files with pathlib and unpack the tamper case explicitly
Rustfmt

[0.6.1] - 2026-10-05

Added

Introduce IdentityRegistry enforcing W3C DIDs, Verifiable Credentials, and POSME Receipts for queries
Add AsyncHolographicClient, batch uploading, and metadata filtering
Add Pydantic AI and SmolAgents tool wrappers
Add Phidata integration and fix broken Rust examples
Add Semantic Kernel and DSPy integrations to Holographic SDK
Add LlamaIndex SDK adapter and CI pipeline
Pivot to Zero-Trust Edge Architecture (FHE-Lite, AGPL-3.0, SIMD)
Python bindings + PyPI packaging for holographic-vsa (maturin/pyo3)
PhaseResonator reusable-index API + clean re-export + doctest (§20 capability)
PhaseHVec core type + real Frady/Kent resonator on quantized-phase substrate
Counting membership store with Poisson z-score readout (4x Bloom capacity)
Real SHA-256 commitment for verifiable phasor mutation (lane 3)
Multi-hop reasoning over the phasor memory (retrieve_path)
PhaseGraph -- phasor relational memory with relation algebra + retrieval
Presence-gate the observer effect (no confabulation-on-query)
Persist ConnectionGraph via its event log; survives restart
ConnectionGraph -- plastic event-sourced relation store, wired into engine
Trust-anchored provenance verification and sharded ANN persistence
Runnable cross-verification of the cogmem C2PA sample
Add provenance system with COSE, VCs, C2PA, JUMBF, Sigstore, KERI, CAWG
Multi-scale encoding, morphological decomposer, fault-tolerant federation
Add research-grade benchmarks, scaling analysis, and visualizations
Add sparse Clifford algebra multivector type (CliffordVec)
Add Hopfield-Fenchel-Young energy-based associative retrieval
Define HolographicAlgebra trait boundary for future geometric algebra
Improve SOTA for analogy, planner, and concept synthesis
Add cost/total_cost fields to planner N-API types
Evidence-weighted multi-hop confidence, ranked results
Expose cleanup_vector N-API method for standalone Hopfield denoising
Add agency layer (GoalStore, Planner, QuestionGenerator, SelfModifier)
Add cognition layer, distributional refiner, CI coverage
N-API bindings, persistence, load_from_log, compact for meaning memory (G6)
Integrate meaning memory into HmsCore, wire write/delete paths (G5)
Fuzzy_structural_query + multi_hop_query pipelines (G4)
AtomMemory, CompositeMemory, TripleStore, RuleStore, Decomposer (G3)
Shared utilities + IndexedMemory with Hopfield attractor (G1-G2)
Rename to holographic-memory, fix npm logo, update all URLs
Graph engine with multi-hop traversal, inference, temporal, federated queries
Complete security integration, DP wiring, docs, LF readiness
Add security features behind feature flag for LF Decentralized Trust readiness
Migrate to writerslogic org, add npm publish pipeline
Eliminate remaining gaps, expose train_nsg/train_ivf via N-API
Expose diffusion config through HmsConfig and N-API
Configurable thresholds, N-API config constructor, status getters
Add query_sequence, elevate test coverage for weak features
Add multi-shard support with auto-sharding
Initial release of Holographic Memory System (HMS)

Changed

Centralize SDK HTTP client and add CrewAI + Embedchain platforms
Consolidate LangChain, LlamaIndex, and Haystack adapters into unified holographic-sdk
Extract shared wire codec (write/read_lp_str, write/read_deltas)
Remove dead self-inverse resonator; move ResonatorConfig to phase_resonator
Extract meaning_ctx() helper shared by structural_query and multi_hop
Gate experimental VSA modules behind experimental feature
Migrate HMS agent identity from did.cose to CAWG ICA
Deduplicate RNG pruning, unify patterns, add doc comments
Eliminate dead code, add delete/compact with persistence
Remove redb dependency, use in-memory FxHashMap with arena log persistence

Documentation

Update changelog [skip ci]
State the AGPL-3.0-or-later license in the security policy
Record algorithm findings and private-search threat models
Update changelog [skip ci]
Rewrite README to highlight Zero-Trust Enterprise Security and Python SDK
State the testing policy explicitly in CONTRIBUTING.md (#66)
Sync changelog (#54)
Align guidance and track deferred production work (#52)
Update changelog [skip ci]
Update changelog [skip ci]
Standardize badges (add OpenSSF Scorecard; consistent order/format)
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Overnight closeout — queue exhausted, 337 tests green, flag pre-existing §21 bin lint
Retract 'info-theoretically impossible' framing; 0.1D Plate is a readout artifact, closing gap to ceiling is open (§22)
Block codes also floor (§24); capacity gap is retrieval-vs-information, open not impossible
DETERMINISTIC-RESONATOR.md — §20 validation write-up from in-loop 24-seed run
Reproducibility header for resonator-factorize (fixed seeds, correct repro command)
Correct resonator-factorize repro command — bin is std-only, no experimental feature
Wire deterministic-resonator capability into RESEARCH.md (discoverability + correct citation)
§29 confirmed on unseen seeds — 4-bit matches float, 8-16x footprint win; log floor-exploration findings
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Record why presence gate uses an absolute margin, not SNR
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Pre-register non-self-inverse binding + nonlinear readout experiment
Update changelog [skip ci]
Update changelog [skip ci]
Replace logo with continuous-rotation animation
Update changelog [skip ci]
Update changelog [skip ci]
Restructure README with collapsible sections
Update changelog [skip ci]
Update changelog [skip ci]
Rewrite README — fix logo for npmjs, restructure with quick start first, improve clarity
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Update changelog [skip ci]
Add agent-provenance stack cross-reference to README
Update changelog [skip ci]
Update all documentation for v0.5.0 accuracy
Add meaning memory architecture, structural queries, attractor cleanup
Add meaning memory architecture, structural queries, attractor cleanup

Fixed

Remove unimplemented security claims and retired cloud code
Add missing experimental feature gate to zero_trust_demo
Add missing experimental feature gate to zero_trust_demo
Resolve CodeQL alerts and README formatting
Resolve clippy::chunks_exact_to_as_chunks lint regression on main (#61)
Resolve workflow code scanning alerts (#53)
Give relations a distinct magic byte (0xFA), accept legacy 0xFE on read
Clippy needless_range_loop in resonator-bundle (§21 bin) — enumerate rewrite, outcome-neutral
Close remaining provenance trust-anchor gaps (cawg, vc-only records)
Use sort_by_key to satisfy clippy 1.96 unnecessary_sort_by
Repair --all-features build (port SCITT to ureq 3 API, drop dead CliffordVec bench, gate provenance example)
Allow CDLA-Permissive-2.0 license from webpki-roots via ureq
Remove dead CliffordVec code and fix clippy warnings
Replace bare unwrap() with expect() or total_cmp in production code
Perf and safety improvements from audit
5 bugs from audit (deadlock, double-decay, over-count, double-start, stale-used)
Cargo fmt
Use sort_by_key for clippy on newer Rust
Cargo fmt formatting
Benchmark crate rename, cargo fmt
Resolve all clippy warnings for CI
Quality pass on G1-G4 code
Use absolute URL for logo on npmjs, add project.yaml for orchestrator
Resolve 15 audit findings (3 critical, 8 high, 4 medium)
Crash-safety, error propagation, and compaction correctness
Propagate errors from shard insert/remove, guard ShardManager invariant
Use .clamp() instead of .max().min() to satisfy clippy

Performance

Optimize Zero-Trust FHE-Lite key generation and eliminate string cloning in hot loops
Use posting-list candidate generation for synthesizeConcepts (>500 vectors)

Security

Remediate repository alerts and dependencies (#38)
Harden signing-key file perms, zeroize copies, bound JUMBF recursion

Assets

Simplify logo — strip floating decorative specks, keep the connected graph mark
Replace logo with self-contrasting node-graph mark (animated gif + static svg), drop garbled-text variants
Static transparent logo from first frame, text removed

Deps

Land 10 Dependabot major bumps with API fixes (#26)

Example

Story_memory -- HMS reasoning memory serving a writer (scrivener-mcp)

Research

Fractional-power encoding gives the phasor memory continuous 'near'
Phase memory retrieves under load where sparse collapses
Rotation binding gives relation algebra the current substrate lacks
Path-plasticity -- holographic generalization a cache can't do
Living-connection-graph slice -- plasticity beats saturation, verifiably
#2 density-matched control rules out the confound
#2 involution control disconfirms the self-inverse framing
#2 hardening RETRACTS the sparse-wins claim (AUC artifact)
#2 step-1 binding discriminator harness + result
#2 strong baselines HRR + MAP vs sparse permutation

Style

Apply rustfmt to experiment binaries

512 files · 481 not served here

.bestpractices.json (not served here)
.dockerignore (not served here)
.editorconfig (not served here)
.gitattributes (not served here)
.github/CODEOWNERS (not served here)
.github/FUNDING.yml (not served here)
.github/ISSUE_TEMPLATE/bug_report.yml (not served here)
.github/ISSUE_TEMPLATE/config.yml (not served here)
.github/ISSUE_TEMPLATE/feature_request.yml (not served here)
.github/SECURITY.md (not served here)
.github/SUPPORT.md (not served here)
.github/badges/coverage.json (not served here)
.github/dependabot.yml (not served here)
.github/pull_request_template.md (not served here)
.github/workflows/bench-refresh.yml (not served here)
.github/workflows/bindings.yml (not served here)
.github/workflows/changelog.yml (not served here)
.github/workflows/ci.yml (not served here)
.github/workflows/coverage.yml (not served here)
.github/workflows/dco.yml (not served here)
.github/workflows/dependency-review.yml (not served here)
.github/workflows/docs.yml (not served here)
.github/workflows/examples.yml (not served here)
.github/workflows/format.yml (not served here)
.github/workflows/fuzz.yml (not served here)
.github/workflows/importers.yml (not served here)
.github/workflows/js-sdk.yml (not served here)
.github/workflows/links.yml (not served here)
.github/workflows/mcp-container.yml (not served here)
.github/workflows/npm-packages.yml (not served here)
.github/workflows/python-wheels.yml (not served here)
.github/workflows/release.yml (not served here)
.github/workflows/reproducible.yml (not served here)
.github/workflows/retire-legacy-npm.yml (not served here)
.github/workflows/scorecard.yml (not served here)
.github/workflows/standards-interop.yml (not served here)
.github/workflows/warm-js-sdk-release.yml (not served here)
.github/workflows/warm-mcp-release.yml (not served here)
.github/workflows/warm-models-release.yml (not served here)
.github/workflows/warm-py-release.yml (not served here)
.github/workflows/warm-sdk-release.yml (not served here)
.gitignore (not served here)
.lychee.toml (not served here)
.npmignore (not served here)
ATTRIBUTION.md
AUTOGINEER-RUNS.md
CHANGELOG.md
CITATION.cff (not served here)
CODE_OF_CONDUCT.md
CONTRIBUTING.md
Cargo.lock (not served here)
Cargo.toml (not served here)
Dockerfile (not served here)
LICENSE
README.md
SECURITY.md
assets/crystal-halo/README.txt (not served here)
assets/crystal-halo/crystal-detailed-loop.apng (not served here)
assets/crystal-halo/crystal-detailed-loop.svg (not served here)
assets/crystal-halo/crystal-detailed-loop.webp (not served here)
assets/crystal-halo/crystal-detailed-static.png (not served here)
assets/crystal-halo/crystal-detailed-static.svg (not served here)
assets/crystal-halo/source/build_additional_exports.py (not served here)
assets/crystal-halo/source/build_crystal_halo.py (not served here)
assets/crystal-halo/source/crystal-halo-geometry.json (not served here)
assets/social-preview.png (not served here)
benches/audit_delivery.rs (not served here)
benches/ingest_alloc.rs (not served here)
benches/intersection_kernels.rs (not served here)
benches/query_alloc.rs (not served here)
benches/vector_record_query.rs (not served here)
benches/vector_updates.rs (not served here)
benches/warm_benchmark.rs (not served here)
benchmarks/ann-benchmarks/campaign/ga.py (not served here)
benchmarks/ann-benchmarks/campaign/gen_heldout.py (not served here)
benchmarks/ann-benchmarks/campaign/mkdefs.py (not served here)
benchmarks/ann-benchmarks/campaign/mkdefs_ivf.py (not served here)
benchmarks/ann-benchmarks/campaign/mkreport.py (not served here)
benchmarks/ann-benchmarks/campaign/plans/b1-sift.json (not served here)
benchmarks/ann-benchmarks/campaign/plans/b2-glove.json (not served here)
benchmarks/ann-benchmarks/campaign/plans/g1-sift.json (not served here)
benchmarks/ann-benchmarks/campaign/prebuild.py (not served here)
benchmarks/ann-benchmarks/campaign/prof.sh (not served here)
benchmarks/ann-benchmarks/campaign/profq.py (not served here)
benchmarks/ann-benchmarks/campaign/run_gen.py (not served here)
benchmarks/ann-benchmarks/campaign/summ.py (not served here)
benchmarks/ann-benchmarks/campaign/test_campaign_integrity.py (not served here)
benchmarks/ann-benchmarks/campaign/warm_module_campaign.py (not served here)
benchmarks/ann-benchmarks/campaign/warmivf_module.py (not served here)
benchmarks/ann-benchmarks/warm/Dockerfile (not served here)
benchmarks/ann-benchmarks/warm/config.yml (not served here)
benchmarks/ann-benchmarks/warm/module.py (not served here)
benchmarks/competitive/GAPS.json (not served here)
benchmarks/competitive/README-block.md (not served here)
benchmarks/competitive/ann_updatable_measure.py (not served here)
benchmarks/competitive/lucene/LuceneBm25.java (not served here)
benchmarks/competitive/modal_run.py (not served here)
benchmarks/competitive/predictions/heavy-20261021T093821.json (not served here)
benchmarks/competitive/repin_compare.py (not served here)
benchmarks/competitive/requirements/annoy.footprint.in (not served here)
benchmarks/competitive/requirements/annoy.footprint.txt (not served here)
benchmarks/competitive/requirements/annoy.in (not served here)
benchmarks/competitive/requirements/annoy.txt (not served here)
benchmarks/competitive/requirements/bm25s.footprint.in (not served here)
benchmarks/competitive/requirements/bm25s.footprint.txt (not served here)
benchmarks/competitive/requirements/bm25s.in (not served here)
benchmarks/competitive/requirements/bm25s.txt (not served here)
benchmarks/competitive/requirements/chroma.footprint.in (not served here)
benchmarks/competitive/requirements/chroma.footprint.txt (not served here)
benchmarks/competitive/requirements/chroma.in (not served here)
benchmarks/competitive/requirements/chroma.txt (not served here)
benchmarks/competitive/requirements/diskann.footprint.in (not served here)
benchmarks/competitive/requirements/diskann.footprint.txt (not served here)
benchmarks/competitive/requirements/diskann.in (not served here)
benchmarks/competitive/requirements/diskann.txt (not served here)
benchmarks/competitive/requirements/duckdb.footprint.in (not served here)
benchmarks/competitive/requirements/duckdb.footprint.txt (not served here)
benchmarks/competitive/requirements/duckdb.in (not served here)
benchmarks/competitive/requirements/duckdb.txt (not served here)
benchmarks/competitive/requirements/faiss.footprint.in (not served here)
benchmarks/competitive/requirements/faiss.footprint.txt (not served here)
benchmarks/competitive/requirements/faiss.in (not served here)
benchmarks/competitive/requirements/faiss.txt (not served here)
benchmarks/competitive/requirements/hnswlib.footprint.in (not served here)
benchmarks/competitive/requirements/hnswlib.footprint.txt (not served here)
benchmarks/competitive/requirements/hnswlib.in (not served here)
benchmarks/competitive/requirements/hnswlib.txt (not served here)
benchmarks/competitive/requirements/lancedb.footprint.in (not served here)
benchmarks/competitive/requirements/lancedb.footprint.txt (not served here)
benchmarks/competitive/requirements/lancedb.in (not served here)
benchmarks/competitive/requirements/lancedb.txt (not served here)
benchmarks/competitive/requirements/milvus.footprint.in (not served here)
benchmarks/competitive/requirements/milvus.footprint.txt (not served here)
benchmarks/competitive/requirements/milvus.in (not served here)
benchmarks/competitive/requirements/milvus.txt (not served here)
benchmarks/competitive/requirements/ngt.footprint.in (not served here)
benchmarks/competitive/requirements/ngt.footprint.txt (not served here)
benchmarks/competitive/requirements/ngt.in (not served here)
benchmarks/competitive/requirements/ngt.txt (not served here)
benchmarks/competitive/requirements/pynndescent.footprint.in (not served here)
benchmarks/competitive/requirements/pynndescent.footprint.txt (not served here)
benchmarks/competitive/requirements/pynndescent.in (not served here)
benchmarks/competitive/requirements/pynndescent.txt (not served here)
benchmarks/competitive/requirements/qdrant.footprint.in (not served here)
benchmarks/competitive/requirements/qdrant.footprint.txt (not served here)
benchmarks/competitive/requirements/qdrant.in (not served here)
benchmarks/competitive/requirements/qdrant.txt (not served here)
benchmarks/competitive/requirements/scann.footprint.in (not served here)
benchmarks/competitive/requirements/scann.footprint.txt (not served here)
benchmarks/competitive/requirements/scann.in (not served here)
benchmarks/competitive/requirements/scann.txt (not served here)
benchmarks/competitive/requirements/server-clients.footprint.in (not served here)
benchmarks/competitive/requirements/server-clients.footprint.txt (not served here)
benchmarks/competitive/requirements/server-clients.in (not served here)
benchmarks/competitive/requirements/server-clients.txt (not served here)
benchmarks/competitive/requirements/sqlite-vec.footprint.in (not served here)
benchmarks/competitive/requirements/sqlite-vec.footprint.txt (not served here)
benchmarks/competitive/requirements/sqlite-vec.in (not served here)
benchmarks/competitive/requirements/sqlite-vec.txt (not served here)
benchmarks/competitive/requirements/stdlib-prev.footprint.in (not served here)
benchmarks/competitive/requirements/stdlib-prev.footprint.txt (not served here)
benchmarks/competitive/requirements/stdlib-prev.in (not served here)
benchmarks/competitive/requirements/stdlib-prev.txt (not served here)
benchmarks/competitive/requirements/stdlib.footprint.in (not served here)
benchmarks/competitive/requirements/stdlib.footprint.txt (not served here)
benchmarks/competitive/requirements/stdlib.in (not served here)
benchmarks/competitive/requirements/stdlib.txt (not served here)
benchmarks/competitive/requirements/tantivy-prev.footprint.in (not served here)
benchmarks/competitive/requirements/tantivy-prev.footprint.txt (not served here)
benchmarks/competitive/requirements/tantivy-prev.in (not served here)
benchmarks/competitive/requirements/tantivy-prev.txt (not served here)
benchmarks/competitive/requirements/tantivy.footprint.in (not served here)
benchmarks/competitive/requirements/tantivy.footprint.txt (not served here)
benchmarks/competitive/requirements/tantivy.in (not served here)
benchmarks/competitive/requirements/tantivy.txt (not served here)
benchmarks/competitive/requirements/usearch.footprint.in (not served here)
benchmarks/competitive/requirements/usearch.footprint.txt (not served here)
benchmarks/competitive/requirements/usearch.in (not served here)
benchmarks/competitive/requirements/usearch.txt (not served here)
benchmarks/competitive/requirements/voyager.footprint.in (not served here)
benchmarks/competitive/requirements/voyager.footprint.txt (not served here)
benchmarks/competitive/requirements/voyager.in (not served here)
benchmarks/competitive/requirements/voyager.txt (not served here)
benchmarks/competitive/requirements/whoosh.footprint.in (not served here)
benchmarks/competitive/requirements/whoosh.footprint.txt (not served here)
benchmarks/competitive/requirements/whoosh.in (not served here)
benchmarks/competitive/requirements/whoosh.txt (not served here)
benchmarks/competitive/tests/test_ann_systems.py (not served here)
benchmarks/competitive/tests/test_common.py (not served here)
benchmarks/competitive/tests/test_server.py (not served here)
benchmarks/competitive/tests/test_table.py (not served here)
benchmarks/competitive/tests/test_text_systems.py (not served here)
benchmarks/competitive/tests/test_warm_ann_build.py (not served here)
benchmarks/competitive/warm-bench (not served here)
benchmarks/competitive/warmbench/__init__.py (not served here)
benchmarks/competitive/warmbench/_spawner.py (not served here)
benchmarks/competitive/warmbench/analyze.py (not served here)
benchmarks/competitive/warmbench/analyzer_latency.py (not served here)
benchmarks/competitive/warmbench/ann_worker.py (not served here)
benchmarks/competitive/warmbench/cli.py (not served here)
benchmarks/competitive/warmbench/common.py (not served here)
benchmarks/competitive/warmbench/data.py (not served here)
benchmarks/competitive/warmbench/envs.py (not served here)
benchmarks/competitive/warmbench/h5_convert.py (not served here)
benchmarks/competitive/warmbench/jars.py (not served here)
benchmarks/competitive/warmbench/land.py (not served here)
benchmarks/competitive/warmbench/multilingual.py (not served here)
benchmarks/competitive/warmbench/registry.py (not served here)
benchmarks/competitive/warmbench/runner.py (not served here)
benchmarks/competitive/warmbench/server_proc.py (not served here)
benchmarks/competitive/warmbench/server_registry.py (not served here)
benchmarks/competitive/warmbench/server_runner.py (not served here)
benchmarks/competitive/warmbench/server_worker.py (not served here)
benchmarks/competitive/warmbench/servers.py (not served here)
benchmarks/competitive/warmbench/table.py (not served here)
benchmarks/competitive/warmbench/text_worker.py (not served here)
benchmarks/competitive/warmbench/textdata.py (not served here)
benchmarks/cue_tags/cue_tagger.py (not served here)
benchmarks/cue_tags/labels.csv (not served here)
benchmarks/cue_tags/measure.py (not served here)
benchmarks/cue_tags/sample.py (not served here)
benchmarks/cue_tags/stale_arms.py (not served here)
benchmarks/embedding/agreement.py (not served here)
benchmarks/embedding/agreement_sample.json (not served here)
benchmarks/embedding/assemble_selection.py (not served here)
benchmarks/embedding/bench_torch_cpu.py (not served here)
benchmarks/embedding/embed_store_bench.rs (not served here)
benchmarks/embedding/pin_model.py (not served here)
benchmarks/embedding/reference_granite-embedding-30m-english.json (not served here)
benchmarks/embedding/run_engine_eval.py (not served here)
benchmarks/embedding/run_store_eval.py (not served here)
benchmarks/embedding/select_model.py (not served here)
benchmarks/evidence/MANIFEST.json (not served here)
benchmarks/evidence/README.md (not served here)
benchmarks/evidence/retired-inputs.json (not served here)
benchmarks/modal_benchmark.py (not served here)
benchmarks/private_search/lattice_estimate.py (not served here)
benchmarks/private_search/lwe_core_svp.py (not served here)
benchmarks/public/accuracy_qualification/PLAN.json (not served here)
benchmarks/public/accuracy_qualification/analyze.mjs (not served here)
benchmarks/public/accuracy_qualification/prepare.py (not served here)
benchmarks/public/accuracy_qualification/pyproject.toml (not served here)
benchmarks/public/accuracy_qualification/run.mjs (not served here)
benchmarks/public/accuracy_qualification/test-analyze.mjs (not served here)
benchmarks/public/accuracy_qualification/test_prepare.py (not served here)
benchmarks/public/accuracy_qualification/uv.lock (not served here)
benchmarks/public/aml_cycle2/README.md (not served here)
benchmarks/public/aml_cycle2/adapter.py (not served here)
benchmarks/public/aml_cycle2/experimental/__init__.py (not served here)
benchmarks/public/aml_cycle2/experimental/citation_matches.csv (not served here)
benchmarks/public/aml_cycle2/experimental/evidence_selection.py (not served here)
benchmarks/public/aml_cycle2/experimental/findings.json (not served here)
benchmarks/public/aml_cycle2/experimental/semantic_cases.json (not served here)
benchmarks/public/aml_cycle2/experimental/test_evidence_selection.py (not served here)
benchmarks/public/aml_cycle2/gce_install.sh (not served here)
benchmarks/public/aml_cycle2/local_host.py (not served here)
benchmarks/public/aml_cycle2/modal_deploy.py (not served here)
benchmarks/public/aml_cycle2/runtime-requirements.in (not served here)
benchmarks/public/aml_cycle2/runtime-requirements.txt (not served here)
benchmarks/public/aml_cycle2/test_adapter.py (not served here)
benchmarks/public/aml_cycle2/test_local_host.py (not served here)
benchmarks/public/aml_cycle2/test_query.py (not served here)
benchmarks/public/analyze_glove_batch_pool.py (not served here)
benchmarks/public/analyze_glove_batch_pool_feature.py (not served here)
benchmarks/public/analyze_glove_batch_pool_isolation.py (not served here)
benchmarks/public/analyze_glove_development.py (not served here)
benchmarks/public/ann_extra.py (not served here)
benchmarks/public/ann_failure_map.py (not served here)
benchmarks/public/ann_modal_confirm.py (not served here)
benchmarks/public/ann_modal_graph.py (not served here)
benchmarks/public/ann_modal_repair.py (not served here)
benchmarks/public/audit_calibration.py (not served here)
benchmarks/public/audit_serving_job.py (not served here)
benchmarks/public/batching_assemble.py (not served here)
benchmarks/public/batching_compare.py (not served here)
benchmarks/public/batching_inputs.py (not served here)
benchmarks/public/batching_timing.py (not served here)
benchmarks/public/bemula/README.md (not served here)
benchmarks/public/bemula/run_warm.py (not served here)
benchmarks/public/bemula/summarize.py (not served here)
benchmarks/public/bemula/warm_adapter.py (not served here)
benchmarks/public/build_native_bridge.py (not served here)
benchmarks/public/check_algebraic_codebook_report.py (not served here)
benchmarks/public/check_compaction_updates.py (not served here)
benchmarks/public/check_competitive_ann.py (not served here)
benchmarks/public/check_document_competition.py (not served here)
benchmarks/public/check_document_operations.py (not served here)
benchmarks/public/check_document_search_compare.py (not served here)
benchmarks/public/check_document_sqlite_rank_control.py (not served here)
benchmarks/public/check_encoder_version_diagnostic.py (not served here)
benchmarks/public/check_evidence_budget.py (not served here)
benchmarks/public/check_evidence_completeness.py (not served here)
benchmarks/public/check_factored_evidence.py (not served here)
benchmarks/public/check_geometry_report.py (not served here)
benchmarks/public/check_learned_sparse.py (not served here)
benchmarks/public/check_lexical_relevance.py (not served here)
benchmarks/public/check_longmemeval_answers.py (not served here)
benchmarks/public/check_longmemeval_complete_history.py (not served here)
benchmarks/public/check_longmemeval_full_history.py (not served here)
benchmarks/public/check_longmemeval_production.py (not served here)
benchmarks/public/check_longmemeval_role_reader.py (not served here)
benchmarks/public/check_longmemeval_user_first.py (not served here)
benchmarks/public/check_longmemeval_verifier.py (not served here)
benchmarks/public/check_manifold_report.py (not served here)
benchmarks/public/check_manifold_schema_report.py (not served here)
benchmarks/public/check_native_harness.py (not served here)
benchmarks/public/check_operand_report.py (not served here)
benchmarks/public/check_operand_tampering.py (not served here)
benchmarks/public/check_phase_path_report.py (not served here)
benchmarks/public/check_publication_serving.py (not served here)
benchmarks/public/check_reader_suspensions.py (not served here)
benchmarks/public/check_sparse_composition.py (not served here)
benchmarks/public/check_superiority_checkpoint.py (not served here)
benchmarks/public/check_weak_reader_evidence.py (not served here)
benchmarks/public/compact_owned_publication.py (not served here)
benchmarks/public/compaction_updates.py (not served here)
benchmarks/public/compare_fact_caches.py (not served here)
benchmarks/public/competitive_ann.py (not served here)
benchmarks/public/direct_commit_publication.py (not served here)
benchmarks/public/document_competition.py (not served here)
benchmarks/public/document_search_compare.py (not served here)
benchmarks/public/document_sqlite_rank_control.py (not served here)
benchmarks/public/durability_matrix.py (not served here)
benchmarks/public/encoder_version_diagnostic.py (not served here)
benchmarks/public/evaluate.py (not served here)
benchmarks/public/evidence_budget_diagnostic.py (not served here)
benchmarks/public/evidence_completeness.py (not served here)
benchmarks/public/factored_evidence_diagnostic.py (not served here)
benchmarks/public/geometry_experiments.py (not served here)
benchmarks/public/instrument_publication.py (not served here)
benchmarks/public/learned_sparse_dense_tune.py (not served here)
benchmarks/public/learned_sparse_encode.py (not served here)
benchmarks/public/learned_sparse_results.py (not served here)
benchmarks/public/lexical_relevance_tune.py (not served here)
benchmarks/public/lme_context/README.md (not served here)
benchmarks/public/lme_context/breakdown.py (not served here)
benchmarks/public/lme_context/extract_modal.py (not served here)
benchmarks/public/lme_context/prep_extract.py (not served here)
benchmarks/public/lme_context/render.py (not served here)
benchmarks/public/lme_context/run_arm.py (not served here)
benchmarks/public/locomo/assemble_results.py (not served here)
benchmarks/public/locomo/locomo_bench.py (not served here)
benchmarks/public/locomo/mem0_prompts.py (not served here)
benchmarks/public/locomo/test_locomo_bench.py (not served here)
benchmarks/public/locomo_comparison.py (not served here)
benchmarks/public/longmemeval_500_frozen_config.json (not served here)
benchmarks/public/longmemeval_answer_evidence.py (not served here)
benchmarks/public/longmemeval_compact_context.py (not served here)
benchmarks/public/longmemeval_complete_history.py (not served here)
benchmarks/public/longmemeval_config.json (not served here)
benchmarks/public/longmemeval_dev_conversations.py (not served here)
benchmarks/public/longmemeval_dev_sources.py (not served here)
benchmarks/public/longmemeval_full_history.py (not served here)
benchmarks/public/longmemeval_history_budget.py (not served here)
benchmarks/public/longmemeval_incremental_judges.py (not served here)
benchmarks/public/longmemeval_local_modal.py (not served here)
benchmarks/public/longmemeval_local_reader.py (not served here)
benchmarks/public/longmemeval_memory_recall.py (not served here)
benchmarks/public/longmemeval_modal.py (not served here)
benchmarks/public/longmemeval_obligations.py (not served here)
benchmarks/public/longmemeval_official_qa.py (not served here)
benchmarks/public/longmemeval_official_qa_500.py (not served here)
benchmarks/public/longmemeval_pipeline.py (not served here)
benchmarks/public/longmemeval_production.py (not served here)
benchmarks/public/longmemeval_qa_l01.py (not served here)
benchmarks/public/longmemeval_quality.py (not served here)
benchmarks/public/longmemeval_quota.py (not served here)
benchmarks/public/longmemeval_reader_api.py (not served here)
benchmarks/public/longmemeval_reader_api_v2.py (not served here)
benchmarks/public/longmemeval_reader_budget.py (not served here)
benchmarks/public/longmemeval_retrieval.py (not served here)
benchmarks/public/longmemeval_retrieval_limits.py (not served here)
benchmarks/public/longmemeval_role_reader.py (not served here)
benchmarks/public/longmemeval_role_retrieval.py (not served here)
benchmarks/public/longmemeval_run_preopen.sh (not served here)
benchmarks/public/longmemeval_run_preopen_r3.sh (not served here)
benchmarks/public/longmemeval_session_closure.py (not served here)
benchmarks/public/longmemeval_sota.py (not served here)
benchmarks/public/longmemeval_sota_closure.py (not served here)
benchmarks/public/longmemeval_sota_context.py (not served here)
benchmarks/public/longmemeval_sota_expand.py (not served here)
benchmarks/public/longmemeval_sota_hybrid.py (not served here)
benchmarks/public/longmemeval_sota_receipts.py (not served here)
benchmarks/public/longmemeval_sota_replay.py (not served here)
benchmarks/public/longmemeval_sota_report.py (not served here)
benchmarks/public/longmemeval_split.json (not served here)
benchmarks/public/longmemeval_split.py (not served here)
benchmarks/public/longmemeval_sweep.py (not served here)
benchmarks/public/longmemeval_user_first.py (not served here)
benchmarks/public/longmemeval_verifier.py (not served here)
benchmarks/public/longmemeval_verifier_sources.py (not served here)
benchmarks/public/longmemeval_weak_reader.py (not served here)
benchmarks/public/lucene_hnsw/LuceneHnsw.java (not served here)
benchmarks/public/matched_server/PLAN.json (not served here)
benchmarks/public/matched_server/adapters.py (not served here)
benchmarks/public/matched_server/calibrate.py (not served here)
benchmarks/public/matched_server/check_adapters.py (not served here)
benchmarks/public/matched_server/check_measure.py (not served here)
benchmarks/public/matched_server/check_qualification.py (not served here)
benchmarks/public/matched_server/claim_gate.py (not served here)
benchmarks/public/matched_server/diagnose_search.py (not served here)
benchmarks/public/matched_server/distribution.py (not served here)
benchmarks/public/matched_server/measure.py (not served here)
benchmarks/public/matched_server/oracle.py (not served here)
benchmarks/public/matched_server/prepare_inputs.py (not served here)
benchmarks/public/matched_server/pyproject.toml (not served here)
benchmarks/public/matched_server/qualify.py (not served here)
benchmarks/public/matched_server/seal_qualification.py (not served here)
benchmarks/public/matched_server/test_claim_gate.py (not served here)
benchmarks/public/matched_server/test_distribution.py (not served here)
benchmarks/public/matched_server/test_measure.py (not served here)
benchmarks/public/matched_server/test_prepare_inputs.py (not served here)
benchmarks/public/matched_server/test_protocol.py (not served here)
benchmarks/public/matched_server/test_qualify.py (not served here)
benchmarks/public/matched_server/test_seal_qualification.py (not served here)
benchmarks/public/matched_server/uv.lock (not served here)
benchmarks/public/matched_server/verify_evidence.py (not served here)
benchmarks/public/mem0_protocol/README.md (not served here)
benchmarks/public/mem0_protocol/budget_ledger.py (not served here)
benchmarks/public/mem0_protocol/clear_failed.py (not served here)
benchmarks/public/mem0_protocol/grade_validation.py (not served here)
benchmarks/public/mem0_protocol/live_smoke.py (not served here)
benchmarks/public/mem0_protocol/manifest_template.json (not served here)
benchmarks/public/mem0_protocol/openai_proxy.py (not served here)
benchmarks/public/mem0_protocol/price.py (not served here)
benchmarks/public/mem0_protocol/protocol_scope.py (not served here)
benchmarks/public/mem0_protocol/quota_resume.py (not served here)
benchmarks/public/mem0_protocol/retrieval_config.json (not served here)
benchmarks/public/mem0_protocol/retrieval_config_count_matched.json (not served here)
benchmarks/public/mem0_protocol/retrieval_config_hybrid_dev.json (not served here)
benchmarks/public/mem0_protocol/retrieval_config_ordered_dev.json (not served here)
benchmarks/public/mem0_protocol/reuse_locomo_dev.py (not served here)
benchmarks/public/mem0_protocol/run_mem0_protocol.py (not served here)
benchmarks/public/mem0_protocol/shim.py (not served here)
benchmarks/public/mem0_protocol/test_budget_ledger.py (not served here)
benchmarks/public/mem0_protocol/test_clear_failed.py (not served here)
benchmarks/public/mem0_protocol/test_openai_proxy.py (not served here)
benchmarks/public/mem0_protocol/test_quota_resume.py (not served here)
benchmarks/public/mem0_protocol/test_reuse_locomo_dev.py (not served here)
benchmarks/public/mem0_protocol/test_run_mem0_protocol.py (not served here)
benchmarks/public/mem0_protocol/test_shim.py (not served here)
benchmarks/public/mobile_qualification/ANDROID-PLAN.json (not served here)
benchmarks/public/mobile_qualification/IOS-PLAN.json (not served here)
benchmarks/public/mobile_qualification/PLAN.json (not served here)
benchmarks/public/mobile_qualification/RecoveryConsumerTest.kt (not served here)
benchmarks/public/native_bridge/Cargo.toml (not served here)
benchmarks/public/native_bridge/build.rs (not served here)
benchmarks/public/native_bridge/src/lib.rs (not served here)
benchmarks/public/native_bridge/src/vertex_support.rs (not served here)
benchmarks/public/native_harness.py (not served here)
benchmarks/public/native_recovery/PLAN.json (not served here)
benchmarks/public/native_recovery/Program.cs (not served here)
benchmarks/public/native_recovery/RecoveryConsumer.java (not served here)
benchmarks/public/native_recovery/recovery.c (not served here)
benchmarks/public/native_recovery/recovery.go (not served here)
benchmarks/public/native_recovery/run.py (not served here)
benchmarks/public/native_recovery/test_protocol.py (not served here)
benchmarks/public/node_recovery.cjs (not served here)
benchmarks/public/operand_experiment.py (not served here)
benchmarks/public/platform_microbench_aggregate.py (not served here)
benchmarks/public/platform_modal_avx512.py (not served here)
benchmarks/public/platform_modal_e2e.py (not served here)
benchmarks/public/platform_paired.py (not served here)
benchmarks/public/prepare.py (not served here)
benchmarks/public/prepare_ann_scale.py (not served here)
benchmarks/public/proxies/ann_proxies.py (not served here)
benchmarks/public/proxies/beir_proxies.py (not served here)
benchmarks/public/proxies/lme_proxies.py (not served here)
benchmarks/public/proxies/qgraph_sim.py (not served here)
benchmarks/public/proxies/stop_screen_report.py (not served here)
benchmarks/public/publication_serving.py (not served here)
benchmarks/public/publication_serving.rs (not served here)
benchmarks/public/publication_trace.rs (not served here)
benchmarks/public/python_sdk_recovery.py (not served here)
benchmarks/public/qag_serving_execute.py (not served here)
benchmarks/public/qag_serving_module.py (not served here)
benchmarks/public/qgraph_paired.py (not served here)
benchmarks/public/qgraph_table.py (not served here)
benchmarks/public/reader_protocol_v1.json (not served here)
benchmarks/public/remote_document_pilot.py (not served here)
benchmarks/public/replay_capacity_publication.py (not served here)
benchmarks/public/report_sparse_composition.py (not served here)
benchmarks/public/restore_ann_checkpoint.py (not served here)
benchmarks/public/resume_longmemeval_readers.py (not served here)
benchmarks/public/run_glove_batch_pool_ablation.py (not served here)
benchmarks/public/run_glove_batch_pool_feature.py (not served here)
benchmarks/public/run_glove_batch_pool_isolation.py (not served here)
benchmarks/public/run_glove_candidate_checks.py (not served here)
benchmarks/public/run_glove_development.py (not served here)
bindings/js/warm-sdk/LICENSE
docs/ARCHITECTURE.md
docs/COMPARISON.md
docs/DETERMINISTIC-RESONATOR.md
docs/GOVERNANCE.md
docs/INTEGRATION.md
docs/PREREGISTRATION-binding-readout.md
docs/PRIVACY.md
docs/PRIVATE-SEARCH.md
docs/PUBLIC-BENCHMARKS.md
docs/RELEASING.md
docs/RESEARCH.md
docs/SECURITY.md
docs/SERVER.md
docs/STABILITY.md
docs/SUPERPOSITION-FLOOR.md
docs/assets/fonts/LICENSE-OFL.txt
docs/evaluation.md
docs/index.md
docs/production-readiness.md
integrations/mcp/npm/LICENSE
integrations/mcp/pypi/LICENSE
tests/fixtures/vectra-0.15/LICENSE

Advantages

Supports local-first operation with no external service calls or telemetry. evidence: README.md
Provides a memory API that allows for explicit fact removal via a forget operation. evidence: README.md

Limitations

The system supports only one writer per store. evidence: README.md
The vector index build time and serving RSS are currently behind hnswlib on SIFT-1M benchmarks. evidence: README.md

Security

Risk level: Medium risk

This brain runs

Install scripts (1)

benchmarks/results/sbg_positions_development/setup.sh: sh benchmarks/results/sbg_positions_development/setup.sh

MCP servers (3)

integrations/editors/claude-code/plugin/.mcp.json (writerslogic-warm): npx -y writerslogic-warm-mcp
integrations/editors/claude-desktop/claude_desktop_config.json (writerslogic-warm): npx -y writerslogic-warm-mcp
integrations/editors/gemini-cli/gemini-extension.json (writerslogic-warm): npx -y writerslogic-warm-mcp

Hooks (1)

integrations/editors/claude-code/plugin/hooks/hooks.json (SessionStart): node

Medium risk: runs-mcp-server-unpinned-runner (integrations/editors/claude-code/plugin/.mcp.json)
Medium risk: runs-mcp-server-unpinned-runner (integrations/editors/claude-desktop/claude_desktop_config.json)
Medium risk: runs-mcp-server-unpinned-runner (integrations/editors/gemini-cli/gemini-extension.json)
Low risk: scripts-present (benchmarks/results/sbg_positions_development/setup.sh)

Attribution and licence

Created by

Writerslogic

Declared authors

WritersLogic, Inc. (declared in package.json)
WritersLogic, Inc. (declared in pyproject.toml)
WritersLogic Contributors (declared in CITATION.cff)

Publisher

Writerslogic (Official Writerslogic project)

Source

writerslogic/warm · commit e176d55

Licence

Apache License 2.0 (files served here)

ATTRIBUTION.md (written by AutoGineer)

Synced

2026-11-12

AutoGineer is not affiliated with or endorsed by Writerslogic.

Install from source

481 of its files are not served here, so there is no ZIP. writerslogic/warm at e176d55