Asymptopia
Open source · MIT · on npm

Nocetta

Nocetta gives your coding agent a memory that keeps itself current: facts survive between sessions, and when what they describe changes, they flag themselves stale and step aside.

Nocetta on GitHub nocetta on npm Get started
6MCP tools: remember, search, supersede, repair, worklist, as-of
0LLM calls on the correctness path
1plain markdown file per memory — no database, no runtime

The short version

A coding agent without memory starts every session from zero: re-reading files you both know, re-asking questions you've already answered. Most memory tools fix that by remembering everything — but code changes, memories don't, and facts that used to be true come back with the same confidence as facts that still are.

That's the failure that costs you: rarely a wrong answer, usually an unflagged one — work built on context that quietly went out of date. Nocetta's answer is mechanical: anchoring kills drift. Every fact is pinned to the exact code or document it describes; when that code changes, a hash comparison marks the fact stale, keeps it away from your agent, and fails a build gate until it's re-checked.

The README calls this anchored, bitemporal memory — anchored because facts are pinned to real code, bitemporal because history is kept, never erased. The jargon is optional; the details follow.

Key features

Anchored to real code

Each fact carries a tree-sitter locator and a content hash for the exact symbol it describes — src/auth/login.ts › function issueToken, not "somewhere in the auth code". Markdown docs anchor too: headings and table rows.

Staleness is structural, not a vibe

Edit the code and the hash differs: the memory marks itself dirty, drops out of recall, and nocetta check --strict exits non-zero. A hash comparison decides — no LLM in the correctness path.

Never destructive

A contradiction deletes nothing. Supersede keeps both versions and recall resolves to the live tip; history stays browsable as of any date.

Files are the whole truth

One markdown file per memory under .nocetta/memory/, committed to your repo. Read them, hand-edit them, diff them — no database, no second source of truth.

Recall that earns its context window

Keyword search over your own store, ranked by the files in play — plus a worklist of what needs attention and a ledger of which memories are earning their keep.

Runs anywhere your agent does

An MCP server on npm with git-style repo discovery, a CLI for the terminal and CI, a TypeScript library, and a Claude Code plugin that wires the hooks for you.

Nocetta remembers itself

No scripted demo: nocetta's development runs on its own store, and the store is committed to the repo. Here's a real memory, verbatim — the project's decision on how memory files should be named: 

$ cat .nocetta/memory/memory-files-are-named-slug-id8-md-a-kebab-slug--590f5c83.md
---
id: 590f5c83-dc54-4c3b-bce6-ef341263df9c
scope: global
anchors:
  - locator: README.md#Memory file format
    hash: d8ae0285cd6318ebb63f60bb5d8f6a23a41970047a244ccdb488c5026eef34f0
    artifactPath: README.md
edges: []
validFrom: '2026-09-08T17:04:32.529Z'
validTo: null
txnTime: '2026-09-08T17:04:32.529Z'
authority: default
overrideReason: null
version: 1
kind: value
---

Memory files are named <slug>--<id8>.md — a kebab slug of the body plus
the first 8 chars of the id. The filename is a label for humans browsing
ls or git log; identity is always the frontmatter id. Settled 2026-09-08
(He): UUID-only filenames failed the human-exploration bar.

A decision, its rationale, who settled it and when — pinned to the exact README section it describes. And the pinning is live: when this page's launch rewrote the README's intro, the fact pinned to that intro went dirty on the next gate: 

$ npx nocetta check
dirty (1):
  b1dd6faa  hash changed: README.md#Nocetta
46 nodes · 1 dirty · 0 conflicts · 0 dups · 0 issues

One re-anchor — the belief untouched, only its locator and hash rewritten — and the same gate is green: 46 nodes · 0 dirty · 0 conflicts · 0 dups · 0 issues. That's the whole trick, run for real.

Get started

Nocetta is an MCP server plus a layer of hooks: the server is the memory and works alone, the hooks add citation crediting and push-recall. Pick your route:

On Claude Code — the plugin (wires both)

Server and hooks in one install: citation crediting and push-recall, with silence as the resting state.

/plugin marketplace add asymptopialtd/nocetta
/plugin install nocetta@nocetta

On other harnesses — the server, hooks by hand

Point your MCP client at npm — the six tools work with no hooks at all; the agent just searches explicitly. For crediting and push-recall, wire the three hook commands from the README. The repo root is discovered, so one registration serves every project.

{
  "mcpServers": {
    "nocetta": {
      "command": "npx",
      "args": ["-y", "-p", "nocetta",
               "nocetta-mcp"]
    }
  }
}

In your own tooling and CI — the library + CLI

npm i nocetta, then import { open } from "nocetta" hosts the whole loop; the CLI browses and gates the store.

$ npx nocetta ls
$ npx nocetta ledger
$ npx nocetta check --strict

Gate it in CI. Dirty memories, unresolved conflicts, or a broken store fail the build: 

- run: npm i nocetta
- run: npx nocetta check --strict

Your memory store becomes just another thing tests protect.

Nocetta is free and open source (MIT). Source on GitHub, package on npm.

How it compares

Against the vector-store-plus-LLM-judge memory tools, Nocetta makes the opposite trade: less magic, more accountability.

NocettaVector + LLM-judge memory
Knows a memory went stale Deterministically — locator + content hash, no LLM in the correctness path Only if an LLM happens to judge it so
On contradiction Supersede — both versions kept, recall resolves to the live tip Typically overwrite or delete the losing fact
History Bitemporal — valid time and write time, so you can ask what the store believed as of any date Usually none beyond the current index
Storage One markdown file per memory in your repo — readable, git-diffable, no database A vector index you can't open, behind a service
Retrieval BM25 over your own files, ranked by the files in play, plus anchor-gated push-recall Embedding similarity against the index

Support Nocetta

Nocetta is free and MIT-licensed. If it earns its keep in your workflow, you can chip in whatever it's worth to you — it funds the next slice.

Support Nocetta