{
  "markdown": "![The AI Memory Bible](assets/banner.png)\n\n# THOR - a memory for your AI coding assistant\n\n**Your assistant forgets you the second you close the window. THOR does not.**\n\nTell it once:\n\n- *never deploy on a Friday*\n- *the invoice number goes in the payment reference, never in the description*\n- *the dough is 65% water and rests overnight, not two hours*\n\nWeeks later, in a conversation that has never heard of any of it, the right one\ncomes back on its own - while you are deploying, while you are invoicing, while\nyou are making dough. You did not search for it. You did not remind anyone.\n\nIt was built for code and it turned out not to care what the subject is. The\nsame memory holds your deploy rules, how your company does its billing, and what\nyou learned the last time you made pizza.\n\nRuns on your own machine. No account, no key, nothing sent anywhere.\n\n---\n\nTHOR is free and GPLv3. If it earns its keep, you can support the work:\n**[buy me a Ko-fi](https://ko-fi.com/noizieworks)** or\n**[become a YouTube member](https://www.youtube.com/channel/UCrEZc_oJR9mywNjqY115mRg/join)** -\nno pressure, no paywall, everything stays open either way.\n\n> **Are you an AI assistant, setting THOR up for the person you work with?** Go\n> straight to **[AGENTS.md](AGENTS.md)**. It is written for you.\n\n[![Watch: THOR explained on YouTube](https://img.youtube.com/vi/tCQOUdkhErQ/maxresdefault.jpg)](https://youtu.be/tCQOUdkhErQ)\n\n*Prefer watching? The video above walks through what THOR is and why it exists.*\n\n## What it does\n\n**Remembers what you tell it.** A rule, a gotcha, a decision, the shape of the\nproject. Once, in your own words. It stays until you change it.\n\n**Hands it back at the right moment.** Not a search box you have to remember.\nThe note arrives while you are touching the file or running the command it is\nabout, in a conversation that never heard it.\n\n**Stops a wrong change, not just warns about it.** A note carrying something\ncheckable can refuse the write outright. Most notes only inform, and that is\ndeliberate: a rule that blocks honest work is the most expensive thing this\nsystem can do.\n\n**Keeps projects apart.** Every project has its own memory. One repo's rules\nnever leak into another.\n\n**Says when it has rotted.** It counts its own dead ends: notes pointing at\nfiles that moved, notes nothing ever reads, notes crowded out by louder ones.\nOut loud, in plain language, so you can fix them.\n\n**Stays on your machine.** No account, no key, no server. Nothing is sent\nanywhere, ever.\n\n## What that looks like in practice\n\nMonths ago you found out the hard way that this project is pinned to an older\nNode, and anything newer breaks the build. You said so once, and moved on.\n\nToday a fresh conversation opens `package.json` to add a dependency, sees an\nengine range that looks out of date, and is one helpful edit away from bumping\nit. Right then, before it types, your own sentence is in front of it.\n\nThat is the whole idea. Not a search box you remember to use. A memory that\nshows up on time.\n\n### \"I already have a CLAUDE.md for that\"\n\nMost assistants read a rules file at startup - `CLAUDE.md`, `AGENTS.md`,\n`.cursorrules`. It helps, and it runs out of road quickly.\n\nPast a certain size it becomes a phone book, and nobody reads a phone book front\nto back. Your assistant skims it, takes the gist and moves on. The rule was in\nthere. It got skipped. Nothing looks wrong afterwards, because the line is still\nsitting in the file, so you go on believing you are covered.\n\nHere is the part that is genuinely different. Picture a fresh agent, no history,\nno idea what this project has already cost you, one keystroke away from the\nexact write that broke production last spring. A rules file would have mentioned\nit somewhere on page four. THOR stops the keystroke. The write does not happen -\nand what stops it is the note *you* wrote, the day it broke.\n\nThat is the whole promise: not better advice, but a wrong change that does not\nland.\n\nGetting there is not free, and it is worth knowing before you start. A note only\nearns that power if it is written to earn it: tied to a real file or command,\ncarrying something checkable that shows it still applies. THOR ships with a\nhandful of starting notes that teach exactly that, and refuses the ones that\ncannot work. [AGENTS.md](AGENTS.md) spells out the rules of the game in full.\n\nThree things make that work, and they all live in one file on your machine:\n\n**1. Nothing is ever lost.** Every note is kept forever. Change your mind and\nthe old version stays too, so you can always look back at what you used to\nthink and when it changed. If two versions of a note ever conflict, THOR keeps\nboth and tells you, rather than quietly picking one and throwing the other away.\nIt is the same care you would give your source code, given to the things you\nknow.\n\n**2. It arrives at the right moment.** THOR checks your memory on every message\nyou send. And the first time your assistant reaches for a file or runs a command\nthat one of your rules is about, that rule gets put in front of it right then.\nBefore the mistake, not after.\n\n**3. Your assistant looks after it.** It is not a notebook you have to fill in\nby hand. Your assistant can add notes, correct them, retire ones that stopped\nbeing true, and flag which ones actually helped. A THOR that is used well is a\nTHOR your assistant is quietly tidying as you work.\n\nIt reads your code too. Point it at a project and it takes in the source and the\ndocumentation, so \"how does this bit work here\" gets answered from your actual\nproject instead of a guess.\n\nEverything stays on your machine. No cloud, no account, no subscription, and\nnothing to sign up for. If some optional piece is missing, THOR quietly falls\nback to a simpler way of working instead of breaking.\n\n## A note that can actually stop you\n\nShowing a warning at the right moment is worth a lot, and for a long time that\nwas all THOR could do. A note could speak. It could not refuse.\n\nVersion 2 lets a note carry a **proof of its own currency**: a small check THOR\ncan run right now to see whether the note is still true of your project. \"This\nfile still contains that line.\" \"That file is still there.\" \"This character\nnever appears in anything we write.\" Or, for catching something left out\nrather than something wrong: \"every agent I spawn names which model to do the\nwork with.\"\n\nThat changes what a note is allowed to do:\n\n- A note whose proof **runs and holds right now** may stop a wrong change\n  outright.\n- A note backed by words alone may warn, and only warn. It can inform your\n  assistant; it can never forbid.\n- If the proof **cannot run** - the file moved, the path is gone - nothing is\n  blocked. It is reported as needing a look.\n\nThat first kind of stop reaches further than an edit made through your\nassistant's own tools: deleting the protected file, emptying it out, or\noverwriting it from a command your assistant runs counts as the same wrong\nchange, and is stopped the same way.\n\nThe reason for the split is uncomfortable and worth saying out loud. Notes rot.\nYou write one, the project moves on, and the note quietly becomes wrong. A tool\nthat let any old note block your work would spend most of its time blocking you\nfor reasons that stopped being true months ago. So THOR only hands that power to\nnotes that can prove, at that exact second, that they still describe your\nproject.\n\nWhich is why, as the top of this page already said, most of your notes will\nnever block anything. The health check prints how many can, and you should look\nat it. On the author's own memory, when this was first measured, 2 notes out of\n2999 could prove themselves; a day of deliberate work took that to 256. It moves\nby hand, because deciding what proves a note is a judgement about that one note.\n\nThat the number is printed at all is the point: a safety net nothing is attached\nto looks exactly like a safety net that works.\n\n### THOR asks, so you do not have to remember to\n\nLeaving that to whoever thinks of it means it never happens. So THOR asks, by\nitself, in two places.\n\n**When a note is written.** A note you call expensive, or one that spells out a\ncommand, a flag or a filename, is not stored until one question is answered: is\nthere a text whose presence *means* the mistake is happening? If there is, the\nnote gets a proof built on exactly that text. If there is not - and often there\nis not, because \"check with me first\" has nothing to catch - you say so and the\nnote goes in unchanged. Both are real answers. Only saying nothing is not.\n\n**For the notes you already had.** Once per session, THOR picks one note that\nnames something concrete, has never been asked, and holds the turn until it is.\nOne at a time, forever, so a memory written before any of this existed still\ngets worked through instead of being declared hopeless.\n\nA caution worth stating plainly: THOR can prove that a note is *wired* so a\nmatching change would be stopped. It cannot know whether the text you typed is\nthe text the real command uses. A misspelled fragment is wired perfectly and\nguards nothing. That is why the health check reports two different numbers - how\nmany notes could refuse something, and how many ever actually did. Trust the\nsecond one.\n\n## What changed in version 2\n\nVersion 1 remembered well and never argued. It would hand your assistant a note\nat the right moment and hope. Version 2 is the same memory with a spine.\n\n- **A note can refuse.** The headline, and the rest of this section is about it.\n  Version 1 could only speak.\n- **Bad notes no longer get in.** A note that cannot ever fire, has nothing that\n  would prove it wrong, runs on for a page, or simply repeats one you already\n  have: turned away at the door, with the reason and the fix. Version 1 stored\n  whatever it was given, and you found out months later that half of it was\n  unreachable.\n- **It counts what it actually did.** How many notes can refuse something, how\n  many ever have, how much of your memory nothing re-reads. Version 1 had no\n  number for the one thing it was built to do, which is how a safety net stays\n  broken for a year.\n- **Maintenance is no longer optional.** At the end of a turn it asks for one\n  thing: judge a note that keeps firing, fix one you just filed where it will\n  never be seen, answer whether an expensive note can refuse anything. One at a\n  time, and it will not be waved off with a promise to do it later.\n- **It costs almost nothing to carry.** A note is capped at 300 characters and a\n  block at four notes and 1200 characters, so what lands in the conversation is\n  a few hundred tokens, not a whole rules file re-read on every turn. A memory\n  of ten thousand notes costs the same per turn as one of fifty. Nothing calls\n  out to a model to decide what to send - it is a local program reading a local\n  file, so there is no network round trip in front of your keystroke. The one\n  exception is the handful you deliberately pin: those are read out in full at\n  the start of a conversation, so pin sparingly and the cap does the rest.\n  Measured on the author's own machine and memory: about 110 ms per call and\n  around 1500 characters delivered when something applies, against roughly 660\n  ms for version 1. One machine, one memory - treat it as an order of magnitude,\n  not a specification.\n- **Stale notes are hunted, not left to rot.** A note whose proof comes out\n  false is reported instead of quietly going on being wrong. A note that keeps\n  firing without anyone ever saying whether it belonged gets asked about, and\n  two verdicts of \"this did not belong\" retire it from every channel while\n  leaving it findable. In version 1 a note that went wrong simply stayed.\n- **Crowding is visible and refused.** Only a few notes fit in a block, so notes\n  compete. Version 2 counts that competition, tells you when you have just\n  stored something onto a spot too crowded to ever show it, names what is\n  holding the place, and refuses the write outright when every spot the note\n  could take is already full of heavier ones. A note tied to one file, folder\n  or command is refused the moment that single place already holds as many as\n  it can ever show - lighter rivals count too, so a heavier note can no longer\n  bump a lighter one out of sight unnoticed. Version 1 accepted it and said\n  nothing, which is how a memory fills up with advice nobody will ever see.\n\n## New in 2.1: a second memory, for everything that is not code\n\nThe memory above is built for work. It has a gate, notes that interrupt you,\nand a hard cap on how much ever reaches the conversation - all of which is\nexactly wrong for a recipe.\n\nSo 2.1 adds a library, and it is a genuinely separate thing: its own file, its\nown two commands, and no way to reach the first memory at all. Nothing you put\nin it can ever interrupt you, compete with a note, or take up room in a block.\nYou only ever see it because you asked.\n\nIt works the way a shelf works.\n\n- **Everything lives on a shelf**, and shelves do not nest. Books, recipes, a\n  training log, what you spent. Filing something without naming a shelf is\n  refused, and the refusal lists the shelves you have, so your assistant picks\n  from real ones instead of inventing a name.\n- **Only you create a shelf.** If nothing fits, your assistant has to ask you\n  what the new one should be called. This is the rule that stops a tidy list of\n  eight from becoming a sprawl of sixty.\n- **A shelf that grows gets labels, never a split.** Two hundred recipes on one\n  shelf, filtered by \"bbq\" or \"dessert\", stays one shelf. That is what keeps the\n  list of shelves short enough to hold in your head.\n- **You get an index, not a wall of text.** Open a shelf and you see one line\n  per entry. Ask for one by number to read it whole.\n- **The same thing twice is refused**, pointing at the entry you already have.\n- **Nothing is ever deleted.** Retiring an entry takes it out of the listing and\n  leaves it readable.\n- **A search never answers \"nothing\".** If your words miss - and they will, since\n  the words you ask with are rarely the words you wrote - it hands you the shelf\n  to read instead. Asking for \"ribbetjes\" when you wrote \"ribben\" finds it.\n\n## Getting started\n\n**The short way - one command.** It downloads the latest release, checks the\ndownload against the checksum published next to it, unpacks it into your home\nfolder, and runs the whole setup.\n\nWindows, in PowerShell:\n\n```powershell\nirm https://raw.githubusercontent.com/nworks3d/THOR-memory-bible-for-AI/main/install.ps1 | iex\n```\n\nLinux:\n\n```sh\ncurl -fsSL https://raw.githubusercontent.com/nworks3d/THOR-memory-bible-for-AI/main/install.sh | sh\n```\n\nNo administrator rights, and nothing is installed outside your own user folder.\n**The automated setup targets Claude Code today.** It touches two of its files -\nClaude Code's own settings and the list of tools it may use - and backs up both\nbefore it does. Rather read the script before you run it? Open that same link\nin a browser first. There is no macOS build yet, so on a Mac take the route\nbelow. Using a different assistant? See\n[Using it from another assistant](#using-it-from-another-assistant) below.\n\n**Or build it yourself.** You need a Rust toolchain. Nothing else: no key to\nget, no model to download first, no account.\n\n```sh\ncd thor2 && cargo build --release --features semantic\n```\n\n> **`--features semantic` is not optional, and leaving it off fails silently.**\n> Without it everything still builds, still runs, and still answers every\n> word-for-word search correctly. What stops working is searching by meaning: it\n> returns nothing at all, with no error anywhere. The reliable way to tell the\n> two apart is size. Look at `thor2/target/release/serve.exe` - over 20 MB is\n> the right build, a few MB is the wrong one. Build it again with the flag.\n\nThen run the setup yourself. That is the same step the one-command install ends\nwith, and in the normal case you type no paths at all:\n\n```sh\nthor2/target/release/install.exe\n```\n\nIt finds your assistant's own two configuration files by itself, creates your\nmemory if you do not have one yet, wires THOR into your assistant, and registers\nthe part your assistant writes through. It backs up both files before it touches\nthem, it never removes anything it did not put there, and running it twice\nchanges nothing the second time.\n\nA brand new memory does not arrive empty. It gets a handful of short notes on\nhow to write a note that comes back to you later, and your assistant is handed\nthem at the start of every conversation from then on. That matters more than it\nsounds: an assistant with nothing in front of it writes notes in a shape that\nnever fires again, and neither of you would notice for weeks. They are ordinary\nnotes - unpin one, rewrite it in your own words, or throw it out. An existing\nmemory is never seeded, so upgrading never pushes anything into your own notes.\n\nYou only reach for a flag if your setup is unusual: `--settings` and `--mcp-json`\nsend it at other files, `--db` and `--serve-exe` override where it looks, and\n`--no-mcp` sets up a memory your assistant can read but not write, on purpose.\nIf a program it needs is missing, it stops and says so rather than installing\nsomething that would sit silent.\n\n**Then restart your assistant.** The part it writes through only comes alive\nafter a restart. Until then, it can already read the memory but not add to it.\n\n**Step 3 - check it.**\n\n```sh\nthor2/target/release/doctor.exe --db \"C:\\Users\\you\\AppData\\Local\\thor2\\thor.db\"\n```\n\nFourteen plain-language lines, one per part: whether your memory is healthy,\nwhether searching by meaning is switched on, how many of your notes can prove\nthemselves, how many point at files that are no longer there, and how many are\nbound to something that can never happen. It changes nothing.\n\nOne of those lines only speaks up when it has something to report: if it ever\nsays your memory's own log file has outgrown the memory itself, something is\nstopping a save from ever finishing - close any other program that might have\nthat same memory open, and run the check again. Newer builds also cap how big\nthat log file is allowed to grow, so this should be rare.\n\n**Step 4 - give each project its own memory.** From that project's folder:\n\n```sh\nthor2/target/release/install.exe --project \"my-project\"\n```\n\nThis matters more than it sounds. Skip it and THOR gets *worse* the more you use\nit, because every search starts competing with projects you were not asking\nabout. All it does is write a small file called `.thor-project` holding that\nname, so you can also just create that file yourself. It refuses to change a\nname that is already there, because renaming a project's scope would strand\nevery note already filed under the old one.\n\nIf you are the assistant doing the setup, [AGENTS.md](AGENTS.md) is the\nwalkthrough for the steps above.\n\n## Using it from another assistant\n\nThe automated setup above is for Claude Code specifically. Any other assistant\nthat can be pointed at an external tool server can still use THOR, through the\ncontainer published alongside every release instead of a local build.\n\nA generic client config, the shape most tool-calling assistants expect:\n\n```json\n{\n  \"mcpServers\": {\n    \"thor\": {\n      \"command\": \"docker\",\n      \"args\": [\n        \"run\", \"-i\", \"--rm\",\n        \"-v\", \"thor-data:/data\",\n        \"ghcr.io/nworks3d/thor-mcp:2.3.1\",\n        \"mcp\", \"--db\", \"/data/thor.db\"\n      ]\n    }\n  }\n}\n```\n\n### Run it as a container\n\n```bash\ndocker run -i --rm -v thor-data:/data ghcr.io/nworks3d/thor-mcp:2.3.1 mcp --db /data/thor.db\n```\n\nThe container does not build a fresh memory by itself - point `-v` at a folder\nor named volume that already holds a `thor.db` (a copy of the one your own\nbuild created, say). `-i` keeps input open, which is what talking to it over\nstdio needs; drop `--rm` if you would rather keep the stopped container around\nthan have it clean up after itself.\n\n## Stay in one conversation\n\nThe old advice was to start a fresh chat often, because long ones got worse and\nyou lost everything anyway. With THOR that advice is out of date. **One long\nconversation is now the better habit.**\n\nWhen a conversation gets long, the assistant's tools squeeze out the older parts\nto make room. THOR covers that moment: your standing rules come straight back,\nand it nudges your assistant to write down anything important that was never\nsaved. Starting a fresh chat is covered too - your rules and your project's\nbackground are loaded in from the start.\n\nSo stay in one conversation while you are on one piece of work. Start a fresh\none on purpose - because you have moved on to something else, or because this\none has talked itself into a corner - not because it is getting long.\n\n## What the first week actually looks like\n\nWorth knowing before you start, because the beginning is the least impressive\npart and it is easy to conclude too early that nothing is happening.\n\n**Day one, it stops nothing.** A fresh memory holds a handful of starting notes:\nhow to write one that comes back, plus the honesty and agent-spawning habits\nthat hold on any project. The part of THOR that can refuse a\nwrong change only works on notes that carry a proof, and you have not written\nany yet. So on the first day you get those notes at the start of a conversation\nand a nudge at the end, and no refusals at all. That is not a fault; there is\nsimply nothing yet to refuse with.\n\n**Your first note will probably be turned down.** It asks for two things most\npeople leave out: when the note should come back to you, and what would show it\nhad gone wrong. If the note is about something expensive, or names a command or\na filename, it asks a third: is there a text whose presence means the mistake is\nhappening? Answering \"no, there is nothing to catch here\" is enough, and often\nit is the truthful answer. The refusal names everything that is missing at once\nand says what to write instead, so the second attempt usually lands. It is\nstrict on purpose - a note nobody can ever prove wrong is a note that quietly\nstops being true.\n\n**The value arrives once you have notes about real places.** A note tied to a\nfile, a folder or a command comes back exactly when you touch that thing. A\nhandful of those is worth more than fifty general ones, and after a week or two\nof writing them down as you go, your assistant stops asking you the same\nquestions.\n\nThen check what you have built with `doctor`. It tells you plainly how much of\nyour memory can actually stop a wrong change, how often it has, and which parts\nnothing ever re-reads.\n\n### If you arrive with a memory you already have\n\nEverything above describes a memory that starts empty. If you are coming from\nversion 1, or from any pile of notes written before proofs existed, the shape is\ndifferent and worth saying plainly, because the obvious plan does not work.\n\nTHOR asks you about one old note per session. That is a brake, not a broom. It\nkeeps the pile from growing while you work, and it was never meant to clear one:\nat one a day, a backlog of thousands outlives you.\n\nThe broom is the health check, pointed at the folder your projects actually live\nin:\n\n```bash\ndoctor --db <your thor.db> --checkouts <the folder holding your projects> --full\n```\n\nThat names every note whose anchor points at nothing, every proof that now comes\nout false, and every note stored somewhere too crowded to ever be shown. Set\naside an afternoon rather than a coffee, and go through it in one sitting. The\nlist is long because the memory is old, not because anything is broken.\n\nTwo things make that afternoon safe to be decisive in. Correcting a note keeps\nthe old version, so nothing you wrote is lost and you can always read back what\nit used to say. And removing one does not delete it either: it stops being\nhanded to anyone, stays findable, and the reason you gave stays attached to it.\n\n## Does it work?\n\nUse it for a week and see whether your assistant stops asking you the same\nthings. That is the only test that answers the question you actually have.\n\nTHOR was measured head to head against another memory tool for months, and those\nnumbers are not here any more. Not because they were bad - they were good - but\nbecause a score measured on someone else's notes tells you about them, not about\nyou. The tool is here. The verdict is yours.\n\n## The sixteen tools\n\nWhat your assistant actually calls, grouped the same way the memory itself is\nsplit in two.\n\n**Code lane** - projects, rules, how to work:\n\n- `remember` - store a new rule, note, report or lookup entry\n- `revise` - correct one that already exists, instead of a near-duplicate\n- `retract` - remove one that turned out wrong (a reason is required; nothing\n  is deleted)\n- `resolve` - settle two versions of the same fact that diverged apart\n- `pin` - make an existing note a standing rule, served at every session start\n- `unpin` - stop it being one\n- `get` - show one item whole, by id\n- `lookup` - search everything - every project, by scope, by key, or by free\n  text\n- `history` - walk one item's whole past, oldest first\n- `mark` - judge whether something you were served actually helped\n- `status` - how much of the memory can actually stop a mistake, and how much\n  has gone stale\n- `search_code` - search the project's own indexed source code\n- `where_used` - find every place one function, struct or variable is defined\n  and used\n- `outline` - see everything one file declares, in line order\n\n**Library lane** - recipes, books, training, expenses, kept apart from the\ncode lane:\n\n- `library` - read a shelf's index, one entry, or search across shelves\n- `shelve` - file a new entry, or correct one that already exists\n\n## Documentation\n\n| page | what it answers |\n|---|---|\n| [AGENTS.md](AGENTS.md) | for your AI assistant: how to set THOR up |\n| [thor2/README.md](thor2/README.md) | the version 2 program: how it is built and what each part does |\n| [thor2/CONTRACT.md](thor2/CONTRACT.md) | the standard version 2 is judged against, and the test enforcing each rule |\n| [thor2/SPEC-ENFORCEMENT.md](thor2/SPEC-ENFORCEMENT.md) | how a note proves itself, in detail |\n| [CONTRIBUTING.md](CONTRIBUTING.md) | changing THOR: the bar for a pull request |\n\n## Thanks\n\n- **MakerViking** - for the inspiration and the great fight. This project would\n  not exist without the spark, and it would not be half as good without someone\n  worth pushing against. Skål!\n- **mimir** ([MakerViking/mimir](https://github.com/MakerViking/mimir)) - the\n  reason THOR exists at all. In the old Norse stories, Mimir guards the well of\n  knowledge; here it set the bar THOR had to clear, and for a long stretch it\n  cleared plenty of its own. Every early comparison in this project was against\n  mimir, wins and losses both published on purpose, because a rival that good\n  deserves honest numbers.\n- **Ideas borrowed, both ways.** Two things THOR does came from mimir's own\n  work and were rebuilt here in THOR's own way, and mimir in turn credits THOR\n  for reading code into memory and for checking memory on every message -\n  exactly the kind of exchange open source is for. Thanks, MakerViking.\n\n## Support this project\n\nTHOR is built by [N-Works 3D](https://www.youtube.com/channel/UCrEZc_oJR9mywNjqY115mRg). If it has\nearned its keep - saved you an explanation, caught a mistake before it cost you,\nor just meant you did not have to start from scratch - there are two easy ways\nto help keep it going:\n\n- **[Buy me a Ko-fi](https://ko-fi.com/noizieworks)** - a one-off, whenever you\n  feel like it.\n- **[Become a YouTube member](https://www.youtube.com/channel/UCrEZc_oJR9mywNjqY115mRg/join)** -\n  monthly, if you want to keep it going.\n\nNo pressure and no paywall - it all stays open either way. Skål, and thanks for\nreading this far.\n\n## Contributing\n\nBug reports and pull requests welcome. THOR is a memory your assistant is\nsupposed to trust, so the bar is being right rather than having more features.\nThe checklist is in **[CONTRIBUTING.md](CONTRIBUTING.md)**.\n\n## License\n\nGPLv3.\n",
  "bytes": 28071,
  "sha": "d515dbf19db4ba894b9ed6e1b4cb32023b8f4a29fa8c15b3a9732a11e0cd1dfb",
  "repo_slug": "nworks3d/thor-memory-bible-for-ai",
  "fonte": "repo",
  "truncated": false,
  "api": "https://agentalog.com/api/listings/mcp_io_github_nworks3d_thor_005138af/readme"
}