LaPis MCP
Local persistent memory for coding agents on SQLite: decisions, fixes and code context survive between sessions.
- 57 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- Installation writes MCP configuration and lifecycle hooks, and memory stores project code and discussion snippets in a local database.
Install
- Works in
Manual install
pi install git:github.com/GeneGulanesJr/LaPisFor Pi Coding Agent; for Claude Code use `npx -y @genegulanesjr/lapis claude-code install`.
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Installation writes MCP configuration and lifecycle hooks, and memory stores project code and discussion snippets in a local database.
This is third-party code. Review the repository files before installing.
What it does
LaPis keeps project knowledge in a single SQLite database and loads what is relevant into new sessions. Memory holds architectural decisions and their reasons, past bugs and fixes, conventions and constraints, discoveries from earlier sessions and code context. Documentation is indexed by section, link and example, and `web-tree-sitter` parses JS, TS, TSX, Go, Python, Rust and SQL sources for semantic lookup. Trust in a memory drops when its linked code changes and recovers when the code is stable. Similar saves are merged or flagged before they clutter recall. For Pi Coding Agent the extension installs with `pi install git:github.com/GeneGulanesJr/LaPis`, Claude Code and Hermes have `claude-code install` and `hermes install` commands, and other clients run the MCP server as `npx -y @genegulanesjr/lapis mcp`.
Who it is for. Developers tired of re-explaining decisions and project history to an agent every session and maintaining files like `CLAUDE.md` for it.
Good fit when
- An agent should remember why the architecture looks as it does and not bring back a reverted decision.
- A fixed bug came back and you need the history of its cause.
- You want memory with no cloud service and no keys.
- One MCP server must serve several clients without hooks.
Not a fit when
- Hand-written instruction files for one small project are enough.
- The tool must not write `.mcp.json` and hooks into `.claude/settings.json`.
- You need hosted memory shared by several people.
Example request
Recall why we chose this cache design and which bug we fixed last time.MCP
- Transport
- stdio
- Authentication
- not required
Limitations
It needs Node.js 20 or newer and `better-sqlite3`; no Python is required. For Claude Code installation writes `.mcp.json` and lifecycle hooks into `.claude/settings.json`, and on first use you approve the LaPis server with `/mcp` in an interactive session. For Hermes it writes `config.yaml`. Memory is local: the database does not sync across machines. The README benchmark was run by the author on his own tasks and shows token savings in those conditions; your project will differ. Code indexing covers the listed languages and other files stay unparsed.
How to disable. Reverse the setup: remove the LaPis entries from `.mcp.json` and the hooks from `.claude/settings.json` or `config.yaml`. Delete the SQLite database by hand.
FAQ
How do I install it for Claude Code?
Run `npx -y @genegulanesjr/lapis claude-code install`, then `... claude-code doctor` to verify. On first use approve the server with `/mcp`.
How do I install it for Pi Coding Agent?
Run `pi install git:github.com/GeneGulanesJr/LaPis` and restart Pi: memory wires up at session start. Update with `pi update --extensions`.
How do I run it as a plain MCP server?
With `npx -y @genegulanesjr/lapis mcp` for clients that need the LaPis tools without hooks.
Do I need a cloud or keys?
No. SQLite on your machine is the default store and no memory service or keys are needed.
What happens to stale memories?
Memories linked to changed code lose confidence, and a stale code index is flagged so you verify or reindex it.
Discussion
No questions or reviews yet.
Related
MCP serversA local-first MCP memory server for agents: session history, codebase index and a concept graph in one SQLite database
Shared memory for coding agents: messages in SQLite, old context compacted into a summary tree and MCP tools to search it.
Local memory for AI agents: Pensyve keeps facts, conversations and action outcomes in SQLite and returns them in later sessions.
Coding memory across sessions, machines and teammates: decisions and dead ends flow into later prompts on their own.
Memory for the Pi agent: facts and lessons persist, past chats are searched via SQLite and API keys never reach memory.
LongMemory keeps project memory in local SQLite and serves it to an agent over MCP: decisions, task state, skills and a code graph
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| LaPis (this card) | no | not required | 57 | |
| agentmemory | yes | not required | 30,340 | hook-based local memory for several agents; LaPis adds code and docs indexing and trust scoring by code changes |
| Claude-Mem | no | 116,457 | a memory plugin for Claude Code; LaPis also installs into Pi and Hermes and as a standalone MCP |
README in short
The repository holds a Pi extension, Claude Code and Hermes Agent integrations, an MCP server and a Rust indexing core. It includes a memory benchmark with five test categories.