AI memory you can read, diff and put in git.
Attelium gives your coding agent a long-term memory that lives in ordinary text files: a knowledge graph you can open in any editor, review in a pull request and roll back with git. No vector database. No black box.
Works with any MCP client. One command sets it up for Claude Code. Open source, MIT licensed.
@Fact billing-service uses_database postgres subject: "billing-service" predicate: uses_database object: "PostgreSQL 16, not MySQL: needs row-level locking for invoice runs" updated: 2026-11-18T09:42:10 [about] → entities/objects/billing-service.kgl#billing-service
$ git diff --stat memory/ memory/graph/facts/2026-11.kgl | 14 +++++++++++++- memory/graph/preferences/adrian.kgl | 3 +++ memory/graph/entities/objects/billing… | 6 ++++--
Your agent forgets. The usual fixes hide what it learned.
Most agent memory is an opaque store you can only query through the agent itself. You can't see what it decided to remember, you can't correct one wrong belief without re-embedding, and you can't review changes the way you review code.
Can you see it?
Open the folder. Every memory is a node in a text file, with fields, tags and typed links to other nodes.
Can you review it?
Memory changes are ordinary diffs. Check them in a pull request, blame a line, revert a bad day with one command.
Can you fix it?
A wrong fact is a wrong line. Edit it, or ask the agent to delete_memory. No index to rebuild by hand.
How it works
Attelium is an MCP server over a folder of KGL files. The agent writes through typed tools and recalls through one call.
The agent takes notes
While it works, the agent calls add_fact, add_entity, record_preference and link_entities to save decisions, conventions, bugs and preferences, with links between related things.
Plain files in your repo
Everything lands as .kgl text under memory/graph/: sessions, entities, facts, preferences, reasoning. Your repo, your history, your backups.
One call brings context back
get_context runs hybrid search, follows one hop of links from each hit and adds recent messages, packed into a token budget.
Plain text vs a black-box memory
Different tools for different jobs. Attelium is built for the memory of a person or a project, where being able to inspect and correct it matters most.
| Attelium (plain-text graph) | Typical vector-store memory | |
|---|---|---|
| Inspect | Open the files, or the built-in viewer | Query the index through code or the agent |
| Review changes | git diff, pull requests, blame | Rarely diffable |
| Correct a mistake | Edit one line, or delete_memory | Delete and re-embed |
| Relationships | First-class typed links, one-hop expansion | Similarity only, unless you add a graph |
| Runs offline | Yes. Local search; optional local model (one-time download) | Often needs an embeddings API |
| Scale | One person's or one project's memory (thousands of nodes) | Built for very large corpora |
Read the honest version, including when you should not use this →
Batteries included
Graph viewer
A read-only web dashboard: pan-and-zoom graph, recent activity, sessions, search, lint warnings and the agent's own search log.
Hybrid search
Zero-dependency lexical search by default. Add one extra for real semantic matching with a small local model. Your memory never leaves your machine.
Reasoning traces
Record why a decision was made and which memories informed it, so the next session finds the reasoning, not only the facts.
Stop-hook nudge
For Claude Code, kgl-memory-init can add a hook that reminds the agent to save notes when a turn changed code but wrote no memory.
Maintenance tools
An offline duplicate scan and an optional reflection pass that synthesises higher-level insights. Nothing is merged or written without you.
Per-project memory
Each project gets its own graph, registered with an absolute path, so memories never leak between unrelated work.
The pieces
Attelium is the product. The parts are separate and open, so you can use any of them on their own.
Attelium product
The front door: docs, quickstart and the memory server setup. kgl-memory is the package and MCP server.
KGL open format
The plain-text knowledge-graph file format and its parser, linter and query engine (pip install kgl-lang).
Graxeon editor
A workspace for browsing and editing KGL graphs, with spreadsheet-style editing and a live graph preview.
Unfoldata services
Want it set up for your team's repos and workflows? Get in touch.
Built because it was needed
Attelium's memory runs on the author's own projects. Building it against KGL's write layer turned up six real bugs in that layer, all fixed before kgl 0.2 shipped. It is alpha software: the format and tools are stable enough to use, and still changing.
On the roadmap planned, not available yet
- Starter memory packs (personal assistant, project memory, research notes).
- Hosted sync and shared team memory.
- A listing in the MCP server directories.
Give your agent a memory you can actually read.
Five minutes from install to your first remembered fact.