Today
- Claude Code JSONL —
~/.claude/projects/<slug>/*.jsonl - Codex CLI rollouts
aider and Cursor are next. The formats are read where they lie; nothing is moved or rewritten.
Apache-2.0 · one binary · v0.1.1
Every memory cites where it came from.
loregraph reads the transcripts your coding agents already write to disk, fuses them with your repository, and builds a durable graph of decisions and implementations — where every value node is anchored to a session id and the commit that was HEAD when that session ran. So the agent can recall what was decided, and cite it.
$ lore ask "redb durable store decision" --data-dir /tmp/lore
recalled 3 memor(ies) for: redb durable store decision
1. [Turn] durable store (score 0.615, via semantic)
↳ source claude_code · session 38168410-… · commit ec584aa3… · conf 1.00
2. [Symbol] ts (score 0.500, via semantic)
3. [Symbol] diff (score 0.500, via semantic)
That is a real run, printed as it came out. The right memory surfaces with
full provenance — and two near-useless single-word symbols
(ts, diff) crowd the list behind it. That is the
default embedder’s ranking, and §04 is about not pretending otherwise.
§01 — the input
Nothing new to write. It reads what is already there.
Your agents already leave transcripts on disk. loregraph ingests them read-only — it is not a write-API you have to call from your tooling, and it is not screen capture.
Fused with the repo
Files, symbols, manifests and git history are crunched into the same graph, so a decision in a transcript connects to the code it actually shaped.
Secrets redacted on ingest
Detected secrets are replaced with <redacted:kind:hash> before anything is written to the store — on the way in, not on the way out.
Two ways out
A pan-and-zoom canvas served from the binary itself (no Node toolchain), and a read-mostly MCP server the agent queries to self-recall — read tools plus one append-only memory.note.
The default build is pure Rust, static musl, with zero Python, C, ML or network dependencies. It runs disconnected: on a laptop, in a locked-down CI runner, or on an air-gapped host.
§02 — the wedge
A hard edge, not an inferred one
Local transcript-graph tools infer session scope heuristically. loregraph
writes the edge: every value node carries the session_id it came
from and the repository commit that was HEAD at the time
— so “who decided what, when, and which code it shaped” is a
query rather than an archaeology exercise.
Contemporaneous, not approximate
The commit anchored is the one that was HEAD when that session ran. A session in a subdirectory of the repo is anchored to the repo it lives under, not only to an exact path match.
Idempotent
Re-running index is content-addressed, so it is safe to wire into a cron job or a post-commit hook without accumulating duplicates.
Crash-safe
Two producers — chat ingest and repo crunch — feed one durable graph through a write-ahead log and a redb commit protocol. Consumers only read.
$ lore index --sessions ~/.claude/projects --repo . --data-dir /tmp/lore
source claude_code: 72 transcript file(s)
repo at HEAD 9967ec0c: 1000 commit(s) for provenance anchoring
ingested 72 session(s), 45560 turn(s)
crunched repo .
graph: 24421 nodes, 27155 edges, 23270 embeddings → /tmp/lore
$ lore serve --addr 127.0.0.1:7700 --data-dir /tmp/lore
loregraph canvas + API on http://127.0.0.1:7700
§03 — measured
47,000 turns into a graph in under two seconds
Measured against a real ~/.claude/projects — 72
sessions, roughly 47,000 turns — fused with a working monorepo. The
resulting graph is 24,686 nodes, 27,404 edges and 23,558 embeddings.
index, cold and full
1.76 s
47k turns parsed, redacted and embedded, plus the repo crunch, git history and the store checkpoint.
ask — open and recall
~0.25 s
Almost all of it rehydrating 24.7k nodes and 23.5k vectors from disk. The recall itself is sub-millisecond.
serve, resident
148 MB
The whole graph and its vector index held in RAM, with no spill to disk.
search, k=8
6.2 ms
Exact brute-force cosine over all 23.5k vectors — no approximation, no index to tune.
| warm API endpoint | latency | payload | note |
|---|---|---|---|
| /healthz | 0.8 ms | 2 B | — |
| /v1/graph?limit=400 | 2.6 ms | 113 KB | summaries, not full bodies |
| /v1/search?q=…&k=8 | 6.2 ms | 4.9 KB | brute force, O(N) over 23.5k |
| /v1/graph/neighbors?depth=1–2 | 0.7–0.8 ms | — | adjacency-indexed, O(degree) |
| /v1/node/{id} | 0.8 ms | — | full body |
Release build with the shipped size-optimised profile, Windows 11, local SSD, last measured 2026-06-29. These are performance figures — time, memory, disk. They are not recall quality, which is a different question and one §04 answers less flatteringly.
§04 — stated bluntly
Most of this is not a moat, and we are not going to pretend it is
“A knowledge graph of your chats” is one of the most crowded spaces in developer tooling right now. Four things on this page are commodity, and saying so is cheaper than being found out.
Not ours
Transcript ingest into a decision graph is being done elsewhere, local-first. We do not claim this leg.
Table stakes
Read-only over MCP is commodity on the code side. It completes the loop; it does not win anything.
We will lose it
A retrieval benchmark at v1. A pure-Rust HNSW will not beat the published numbers in the field, and we do not compete on that axis.
Vendored
The visualisation. Force-directed graph rendering is an MIT-licensed commodity. We did not invent it.
And the default ranking is genuinely weak
Look again at the recall at the top of this page: alongside the right answer
sit
ts and diff — single-word symbols with no
business being there. The default HashEmbedder is a
dependency-free lexical token-bag, and it is poor at semantic
ranking. That is the price of the zero-dependency default build. Real
local embeddings are a runtime switch rather than a rebuild
(LORE_EMBED_BACKEND=static with a local vectors file), and
--features neural goes further — but the shipped default
leads with exact matches and structural links, not with ranking.
So what is left is a four-way intersection. Provenance-grade decision edges, transcript-native ingest, read-only MCP, and an air-gapped pure-Rust binary. The first is thin but real — and easy to copy, which is why it ships first. The last is the most durable: hosted memory products are disqualified offline outright, and the existing open-source transcript tools are TypeScript and Python supply chains without hard provenance.
If you live inside one agent's cloud, you do not need this. If you need verifiable who-decided-what-when memory that runs disconnected — regulated, classified, offline — you do.
§05 — getting it
Five platforms, four channels, one default build
Every channel ships the same default build — pure Rust, static,
zero Python, C, ML or network dependencies. The crate is
loregraph; the binary it installs is lore.
# prebuilt binary, no toolchain — picks the right release asset for your platform
$ cargo binstall loregraph
# Homebrew — the repository is its own tap. macOS and Linux.
$ brew tap lucheeseng827/loregraph https://github.com/lucheeseng827/loregraph
$ brew install lore
# distroless container, linux/amd64 + linux/arm64, runs as nonroot
$ docker run --rm mancube/loregraph:latest version
# or with a Rust toolchain
$ cargo install loregraph
Or verify a tarball
Each tagged release publishes static-musl archives for x86_64 and aarch64, macOS archives for both, a Windows zip, and a SHA256SUMS to check them against.
What is in the released binary
mcp is built in — it is pure Rust, so the air-gap invariant holds. neural, byo-llm and index-hnsw stay source-only: build with cargo install loregraph --features <name>.
Apache-2.0
Point it at a directory you already have
Nothing to instrument, nothing to call, nothing to send anywhere. The transcripts are already on your disk; this reads them where they lie and gives the graph back with citations attached.