The Engrim SQLite memory engine is a free, MIT-licensed command-line tool that gives Claude Code, Cursor, Windsurf, Codex CLI, and Google Antigravity a persistent memory of your project, stored in a single local SQLite file instead of a cloud account. It showed up on Hacker News on September 8, 2026 under the pitch "a universal, local-first SQLite memory engine for AI CLIs," and after a day of testing it, the core idea holds up better than the average Show HN memory tool.
Short answer: Engrim is a free, MIT-licensed Python CLI (
pip install engrim) that gives Claude Code, Cursor, Windsurf, Codex, and Antigravity a shared local memory at~/.engrim/memory.db, combining SQLite FTS5 keyword search with offline vector embeddings. It hooks into each agent's session start/stop events to auto-log decisions and auto-recall them next time, and needs no API key or cloud account to run.
I installed engrim 1.3.0 in a scratch git repo, ran it through add, recall, and context, and read the full 20-comment Show HN thread to see which of the maker's claims held up and which of the commenters' concerns were fair. The project itself lives on GitHub, with 179 stars as of this writing. Here's what it needs, the exact commands, and the two things I'd want you to know before wiring it into a real project.
What you'll need
Engrim ships as a Python package, so you need Python 3.10 or newer and pip — there's no separate binary download. It installs its own SQLite database automatically at ~/.engrim/memory.db the first time you run a command, and the store is shared across every project on your machine, tagged internally by git root so each repo's memories stay separate. You'll also want the agent side ready: Claude Code, Cursor, or Windsurf installed if you want the automatic hooks and MCP integration, though the plain CLI works fine on its own without any agent at all. One thing worth flagging up front: despite the "100% local and offline" pitch, the very first engrim add or engrim recall reaches out to Hugging Face to download a small embedding model, so you do need one internet connection before you can call it offline.
Step-by-step: setting up Engrim
1. Install the package
“ pip install engrim ` In my testing this pulled in model2vec` as a dependency (used for local embeddings) and finished in under a minute on a normal connection.
2. Run setup and let it detect your agents
“ engrim setup --all ` This scans for Antigravity, Claude Code, and Cursor on your machine and wires up their session hooks, MCP server entries, and (for Claude Code) a CLAUDE.md note in one pass. Use –dry-run first if you want to see what it plans to touch before it edits any config. Windsurf and Codex CLI both speak MCP too, so engrim's engrim serve –mcp command works there as a manual connector even where setup` doesn't have a dedicated flag yet.
3. Add your first memory
“ engrim add -t decision -s "Chose SQLite over Postgres for the memory store" -d "Zero-ops, single file, easy to git-ignore." ` When I ran this the first time, it took 3.4 seconds because it silently downloaded a 59MB embedding model (minishlab/potion-base-8M`) from Hugging Face in the background — every add after that landed in well under a second.
4. Recall it back
“ engrim recall -q "sqlite postgres decision" “ This runs the hybrid FTS5-plus-embedding search and returned my one matching record in about 1.3 seconds in testing, ranked with a short provenance line showing it came from the CLI rather than an agent.
5. Check what auto-loads at session start
“ engrim context ` This is the command your agent's hook calls automatically. In my two-record test project it printed a "session-boot" pack — both records, truncated to short summaries — for about 44 tokens, with a note that the rest is "one recall` away" rather than dumped into every prompt.
6. Confirm nothing important got missed
“ engrim review “ This scans your recent session transcript log for decisions the agent made but never wrote down, which is the closest thing engrim has to a safety net against silent memory loss when a session ends.
Example prompts you can copy
Once the MCP server is wired into Claude Code or Cursor, these are the prompts that actually exercise engrim's tools rather than hoping the agent reaches for them on its own:
- "Before we start, check your memory for this project and tell me what you already know." — tests whether the session-boot pack from
engrim contextis actually loaded and whether the agent references it. - "We just decided to cache API responses for 10 minutes instead of 60 — log that as a decision with your memory tool." — checks that
engrim_addfires correctly with a real origin-agent tag. - "Search memory for anything about our database choice before you suggest one." — a good test of
engrim_recallversus an agent just guessing from the code it can see. - "Before you end this session, review whether any decisions from this conversation didn't get captured." — mirrors what
engrim reviewdoes, and is worth running before you/cleara long session.
Common mistakes to avoid
The first mistake is trusting the "100% local and offline" framing on day one — the first add or recall call needs internet to fetch that 59MB embedding model, and if you're testing on an airgapped machine it'll just hang. Second, running pip install engrim and stopping there: the CLI works standalone, but nothing gets logged or recalled automatically inside Claude Code or Cursor until you also run engrim setup. Third, assuming the tool cleans up after itself — a Hacker News commenter (thih9) asked about an uninstall path, and while the maintainer said he'd added engrim uninstall to the GitHub source the same day, the 1.3.0 release on PyPI I tested doesn't ship it; I confirmed this by running it myself and getting an "invalid choice" error, so removing the hooks and ~/.engrim/ folder is manual for now. Fourth, treating this as a solved problem for team use: another commenter, esafak, pointed out the project has no documented lifecycle management or conflict resolution yet, so two agents writing to the same store at once is untested territory. Fifth, letting an agent decide what's worth remembering with no review — several commenters, including verdverm, argued that autonomous memory-writing tends to be verbose and needs an editorial pass, which matches what engrim review is trying to catch, not fully solve.
Engrim vs. other AI agent memory options
| Engrim | OKF Agent Memory | Unabyss | |
|---|---|---|---|
| Storage | Local SQLite (~/.engrim/memory.db) |
Markdown files in your git repo | Cloud sync from Slack, Gmail, Notion, etc. |
| Search | FTS5 keyword + local vector embeddings | Local BM25 keyword search | Cloud-hosted retrieval |
| Setup | pip install engrim + engrim setup --all |
Single Go binary, one-line installer | Web account + Claude custom connector |
| Agents supported | Claude Code, Cursor, Windsurf, Codex, Antigravity | Claude Code, Cursor, Codex, local model runners | Claude, ChatGPT, Cursor |
| Cost | Free, MIT license | Free, MIT license | $13–15/mo (Pro), after a 7-day trial |
| Needs internet | Only once, to fetch the embedding model | Never | Always (it's a sync service) |
If you want memory that lives entirely on disk and never phones home after setup, OKF Agent Memory is the stricter local-first option since it skips embeddings entirely. If what you actually want is context pulled from your other apps rather than your coding decisions, that's a different job — see my Unabyss for Claude review instead.
Tools that make this easier
Engrim only pays off once you're comfortable with the agent it's plugged into, so start with how to use Claude AI or how to use Cursor AI if either is new to you — both cover the session and project basics engrim's hooks build on top of. If you're on Windsurf instead, how to use Windsurf walks through the same fundamentals for that editor. For readers building their own MCP server rather than adopting someone else's, MCP-Builder.ai is a concrete, tested example of what that looks like end to end, and WebMCP is worth a look if you're curious how a similar "let the agent call your tools directly" idea shows up outside the coding-agent world entirely. And if the coding agent itself, not its memory, is still an open question for you, best AI tool for code has real pricing and test notes across the main options.
My take
Engrim gets the core trade-off right: a single SQLite file with local embeddings is a genuinely lighter, more portable answer to agent memory than yet another cloud database, and the maintainer's response to the Show HN thread — shipping fixes for Codex support and an uninstall path within hours of comments landing — is a good sign for a two-day-old project. What I'd slow down for: the "100% offline" claim has a real asterisk on first run, there's no conflict handling yet if more than one agent writes to the same store, and the uninstall command that got promised in the thread hadn't reached the released package when I tested it. If you're a solo developer switching between Claude Code and Cursor on personal projects, it's a low-risk, zero-cost thing to try. I'd hold off on team-wide rollout until the lifecycle and conflict-resolution gaps close.
Frequently Asked Questions
Is Engrim free to use?
Yes. It's MIT-licensed and free to install and run — pip install engrim — with no account, subscription, or API key required. The only cost is the one-time 59MB embedding-model download on first use.
How long does it take to set up Engrim?
Installing the package took under a minute in my testing, and engrim setup --all wired up Claude Code and Cursor hooks in a few seconds more. The only slow step is the first add or recall call, which took about 3.4 seconds while it downloaded the embedding model in the background.
What is the easiest way to try Engrim?
Run pip install engrim, then engrim add -t decision -s "your first memory" in any git repo, followed by engrim recall -q "your" to confirm it comes back. That's a faster gut-check than running full agent setup on day one.
Does Engrim work with tools other than Claude Code?
Yes. It has explicit setup support for Google Antigravity, Claude Code, and Cursor via engrim setup, and its MCP server (engrim serve --mcp) also works with Windsurf and Codex CLI, since both speak the Model Context Protocol.
Is Engrim really 100% offline?
Mostly, after the first run. Once installed, everyday add, recall, and context calls run entirely against the local SQLite file with no network calls — I confirmed this by watching the timing drop from 3.4 seconds to under a second after the first call. The exception is that very first call, which needs internet to fetch the embedding model it uses for semantic search.