One memory.
Many intelligences.

Most questions to a memory are lookups, and a lookup does not need a language model — it needs the sentence you already wrote. Chitraq tries that first, and escalates only when quoting genuinely cannot answer: when nothing matched, when the match is too weak to trust, or when the question asks for synthesis.

Outcome	of 10
answered by quoting your own words	6
served from cache	2
escalated to a model	2

Measured over ten realistic questions. 80% never reached a model. A test counts model calls directly, so a change that quietly starts sending everything to a paid provider fails the suite.

$ chitraq ask "why did we drop the redis cache"

  quoted from your own words        confidence 0.82

  The hit rate never exceeded 30% and the
  memory cost was not worth it.

  from  obj_01J8F… · user · confirmed
  cost  nothing — no model was called
  took  94ms

The cache is keyed on the content hashes of the objects an answer rests on, so editing any of them moves the key. A stale answer cannot be served, because if it could be stale the key already changed.

# Nothing to install. Node ships SQLite.
git clone https://github.com/Nulfied/Chitraq
cd Chitraq
npm test

# Point it at notes you already have
chitraq ingest ~/Documents/notes

# Then ask
chitraq ask "what did we decide about pricing"

Requires Node 24. There are no dependencies to install — package.json has an empty dependencies block and it is meant to stay that way.

Optional: make it smarter, still free

ollama pull nomic-embed-text   # semantic search
ollama pull moondream          # read images
ollama pull llama3.2           # written answers

Everything runs on your machine at no cost. Without Ollama the built-in deterministic provider still serves every capability — it is the floor the whole system stands on, and the test suite passes with no models installed at all.

Embeddings are the biggest single win: head to head on queries sharing almost no words with the notes, the built-in embedder found 1 of 3 and Ollama found 3 of 3.

$ chitraq tokens --new formfit --scope write

import { ChitraqClient } from 'chitraq/client'

const memory = new ChitraqClient({
  url: 'http://127.0.0.1:4317',
  token: process.env.CHITRAQ_TOKEN,
})

await memory.remember({
  title: 'Compress PDFs in the browser',
  kind: 'decision',
})

const answer = await memory.ask(
  'why do we compress client-side'
)

The client is one file with no dependencies. It never caches and never retries blindly — a memory client that quietly returns a stale answer leaves you unable to tell a remembered fact from a remembered response.

Presenting a token constrains you. Presenting nothing changes nothing.

On a loopback install a token cannot make access harder to obtain — anything on the machine could call the API anyway. What it does is make access narrower. A read token is refused a write even where an anonymous caller is allowed one, so a side project can hold a credential that genuinely cannot damage the memory it reads.

Scope	May
read	search, ask, recall, entities
write	read, plus capture and review
admin	everything, including erase