lcm plugin
Shared memory for coding agents: messages in SQLite, old context compacted into a summary tree and MCP tools to search it.
- 60 ★ on the repository
- Last commit
- MIT
Extended access
Why this level
- Hooks read and write every session message into a local SQLite database.
- A local lcm daemon stays running and serves data to MCP clients.
Install
- Works in
In your terminal, with SkillFoxx CLI
npx skillfoxx add plugins/lcmDetects the agents on your machine, shows the access level and pins the version.
Other ways to install
Access and checks
How we reviewExtended accessThe tool runs code or makes network calls and only reads external data.
- Hooks read and write every session message into a local SQLite database.
- A local lcm daemon stays running and serves data to MCP clients.
This is third-party code. Review the repository files before installing.
What it does
lcm replaces sliding window forgetfulness with persistent memory. Every message goes into the project SQLite database and older context is compacted into a directed graph of summaries instead of being dropped. Durable decisions and findings are promoted into cross-session memory. Humans and agents use one backend and only the way of connecting differs. Claude Code has end-to-end integration through hooks and a plugin, Codex and Oh My Pi use connectors with native hooks, and VS Code has a skill. The agent gets the MCP tools `lcm_search`, `lcm_grep`, `lcm_expand`, `lcm_describe`, `lcm_store`, `lcm_stats` and `lcm_doctor`: search, expanding a summary into source messages, manual memory writes and diagnostics.
Who it is for. People running long projects in Claude Code or Codex who lose decisions and findings when the context window compacts or a session ends.
Good fit when
- A week later you need to find why a decision was made in the project.
- One long window has grown and you want to compact old content without loss.
- An agent must recall findings from past sessions instead of starting from scratch.
- Different clients, Claude Code and Codex, share project memory.
Not a fit when
- You need automatic work in VS Code: it has no restore or turn capture.
- You want to avoid a local daemon: lcm runs its own.
- The project is throwaway and cross-session memory is not needed.
Example request
Search project memory for why we dropped the Redis queue and expand the summary to the source messages.Limitations
Only Claude Code has full integration. In VS Code a skill teaches Copilot to call `lcm`, but there is no automatic restore or turn capture. For Codex, `lcm connectors install codex` installs the hooks while the MCP configuration in `.codex/config.toml` is still manual. Node.js 22 or newer is required. Messages and summaries sit in local SQLite databases, so restrict access for private material. The repository began as a fork of lossless-claw adapted for Claude Code, and the LCM model comes from the Voltropy paper.
How to disable. Disable the plugin in Claude Code and remove connectors with `lcm`. Uninstall the package with `npm uninstall -g @lossless-claude/lcm` and delete local databases separately.
FAQ
How do I install lcm for Claude Code?
Install the binary with `npm install -g @lossless-claude/lcm`, add the marketplace with `claude plugin marketplace add lossless-claude/lcm`, install the plugin and run `lcm install`.
How do I connect Codex?
`lcm connectors install codex` installs native lifecycle hooks. The MCP setup in `.codex/config.toml` must be added by hand.
What does `lcm_expand` do?
It expands a summary node into its source content by traversing the graph. That lets an agent check details the compaction removed from the short text.
How do I check the installation?
Call `lcm_doctor`: the tool diagnoses setup and reports stale stores and orphan summaries.
Where does the LCM idea come from?
The model and summary graph architecture originate from the Voltropy paper. The repository began as a fork of lossless-claw from Martian Engineering for Claude Code.
Discussion
No questions or reviews yet.
Related
PluginsCortex keeps decisions and project context between Claude Code and Codex sessions in a local database and shows what it recalled
Local memory layer: imports Claude Code, Codex and mem0 memory into SQLite and serves it back to agents over CLI and MCP.
Memory for agents: a Claude Code session resumes in Codex with the same decisions and open tasks.
Knowledge-graph memory for agents: Claude Code and Codex plugins, an MCP server and a Python library
An MCP server that preserves Claude Code context between sessions: decisions, checkpoints and a file cache kept in local SQLite.
hipocampus gives an agent file-based memory: a 3,000-token topic index loads each session and shows what came up before
Comparison with similar tools
Cards that share the main search query, and how they differ.
| Tool | Official | Authentication | Repository stars | Main difference |
|---|---|---|---|---|
| lcm (this card) | no | 60 | ||
| agent-memory | no | 4,315 | memory from Markdown files with a SQLite index; lcm compacts session history into a summary graph and expands it back to source messages | |
| MCP Memory Service | no | not required | 2,117 | a self-hosted memory with a knowledge graph and REST API; lcm relies on Claude Code hooks and a local project database |
README in short
The product stores messages in SQLite, compacts context into a summary graph, promotes durable facts into long-term memory and exposes MCP tools. Clients differ in integration depth while the memory is shared.