Show HN: LLM Memory Solved?

An associative memory you can run anywhere. Write facts in plain language, recall them by meaning. No tables, no schema, no embeddings, no model required. The core is pure Rust with zero dependencies and compiles to WebAssembly; durable storage, encryption, and an HTTP server are opt-in features.

./build.sh
neuron --db app.db turn me 'my plan is pro'
neuron --db app.db get  me 'what plan am i on?'      # -> pro

A fact is a sentence ("the api key is zeta-9931"

); neuron-db keeps the surprising word as the retrievable value and indexes the rest as cues. A scope is a named bag of facts (user:42

), and a database is a file of scopes. You insert by stating things and read by asking questions — retrieval is associative (cue overlap), so you never declare a column or write SQL. Full model and every operation: ** docs/API.md**.

use neuron_core::db::NeuronDB;
let db = NeuronDB::open("app.db", 500);
db.observe("user:42", "the plan is pro");
db.get("user:42", "what plan?");            // Some("pro")
db.forget("user:42", Some("plan"));         // delete by substring

— in-memory associative store (default, std-only). Recall in microseconds.Neuron

— recall adapts: strength on use, decay on disuse, Hebbian links, and a neurotransmitter-style spreading-activation recall.PlasticNeuron

— shard across many small neurons and fan a query out (NeuronRouter

--features

none).— durable database of scopes in one SQLite file (NeuronDB

--features sqlite

).— AES-256-GCM values, per-scope secret never stored (SecureNeuronDB

--features secure

).HTTP server +— one endpoint per scope (serve

binary--features server

).

Tiny. A fact's retrieval state is stems and scalars, not a dense vector — about 48 bytes/fact serialized, roughly130× more facts per GiB than a 1536-dim float vector store. See.docs/STORAGE.mdFast and dependency-free. Microsecond recall, no GPU, no model. The default build runs in a 1 MB WebAssembly worker.Adaptive. The plastic tier learns from use with O(1) scalar updates — no re-embedding, no re-indexing.

The trade: it does cue and association recall, not semantic similarity. "the thing I use to get online"

won't match "wifi password"

without an embedding. It's scalar-first by design.

./build.sh                                            # sqlite + secure + server
cargo build --release --features "sqlite secure server"
cargo install --path rust/neuron-core --features "sqlite secure server"

Default build is zero-dependency and targets wasm32-unknown-unknown

; the native tiers are opt-in features so they never touch the wasm build. Running it as a service (and Docker): ** docs/DEPLOY.md**.

Embedded SQLite has no login — control access by filesystem permissions, the HTTP server's NEURON_DB_KEY

bearer token, or per-scope encryption with SecureNeuronDB

. Details: ** SECURITY.md**.

The store and service tiers are canonical in Rust (rust/neuron-core/

). A Python reference implementation — including the gary-neuron cortex bridge and training tooling — is preserved on the ** legacy-python** branch.

Runnable code and integration guides are in ** examples/** — quickstart, a chatbot-memory loop, per-user profiles, sharding, encrypted secrets, HTTP clients (curl/browser/Node/Python), and guides for wiring neuron-db into a

or an

chatbot.

existing APIdocs/API.md— data model and every operation (library / CLI / HTTP)docs/DEPLOY.md— build, install, Docker, env, backupsdocs/STORAGE.md— storage density vs vector databasesSECURITY.md— encryption and access model

MIT licensed. Author: gary23w.