sessionmem

85.6% fewer tokens. Every session starts knowing your codebase. Stored entirely on your machine.

New session. Claude starts fresh.

WITHOUT sessionmem:
  You explain the stack. The JWT bug from last week.
  The Stripe migration that's halfway done. The billing code to stay away from.
  Same questions. Different day.

WITH sessionmem:
  [warning] JWT blacklist must be checked before issuing new tokens. Fixed PR #47.
  [decision] Stripe migration ~50% done. Do NOT use /lib/billing-v1.
  [fact] Stack: TypeScript, Next.js, Postgres.

  Claude: "Looks like you're mid-Stripe migration. Where do you want to pick up?"

sessionmem is an MCP server that watches your coding sessions and stores what actually mattered -- decisions, warnings, things that would bite you if Claude forgot them. At the start of each new session it injects the relevant bits automatically. Works with Claude Code, Cursor, Cline, Codex, Windsurf, and anything that speaks MCP.

Everything stays on your machine. No account, no cloud, no data leaving your computer unless you explicitly turn that on.

Quickstart

No programming experience needed. You just need a terminal (Command Prompt, Terminal, or PowerShell) and Node.js installed.

1. Install sessionmem

npm install -g sessionmem

2. Register it with your AI tool

Run this inside the project folder you're working on, with your AI tool (Claude Code, Cursor, etc.) configured:

sessionmem install

This does three things:

• Tells your AI tool's MCP host about sessionmem so it can be launched automatically.
• Creates a config file at ~/.sessionmem/config.json with safe, privacy-respecting defaults, but only if one doesn't already exist.
• Injects instructions into ~/.claude/CLAUDE.md so Claude Code knows about sessionmem's tools and uses them proactively (idempotent, so safe to re-run).

3. Start using your AI tool as normal

sessionmem run

(Most of the time you won't run this yourself. Your AI tool's host starts it automatically once it's registered.)

That's it. From here:

• sessionmem watches your sessions in the background.
• At the end of each session, it writes down a short summary of what mattered.
• At the start of your next session, it quietly reminds your assistant of the relevant bits.

You can verify everything is working with:

sessionmem ping

Table of Contents

• What problem does this solve?
• How is sessionmem different?
• Benchmark results
• How it works (in plain English)
• CLI command reference
• Privacy, secrets, and your data
• Memory rot: keeping memory accurate over time
• Team mode (optional)
• Cloud summarization (optional, off by default)
• Supported tools
• Further documentation
• Troubleshooting
• FAQ
• Contributing
• License

What problem does this solve?

If you've used an AI coding assistant for more than a day, you've probably hit this:

You spend twenty minutes explaining your project's setup, the libraries you use, a tricky bug you already fixed, and a decision you made about how authentication should work. The assistant nods along, helps you out... and then in your next session, it has forgotten all of it. You explain everything again.

This happens because most AI assistants only "know" what's inside the current conversation. Once that conversation ends, the context is gone.

sessionmem fixes this by sitting quietly between your assistant and your project:

1. While you work, it captures what happens in the session.
2. When the session ends, it summarizes the important parts (decisions made, warnings, useful facts) into short, durable notes.
3. The next time you start a session, it reminds the assistant of the most relevant notes, automatically, in a small amount of text.

You don't run any of these steps yourself. Once installed, it just works in the background.

How is sessionmem different?

There are other "memory for Claude" projects out there (for example, tools like claude-mem and similar community projects). Here's what sets sessionmem apart:

In short: sessionmem is the boring, local, "just a SQLite file" option: easy to inspect, back up, and delete, with no lock-in to any one vendor's AI tool.

Benchmark results

These numbers come from npm run benchmark (scripts/benchmark.mjs), which runs the real production retrieval and injection code over a fixed, synthetic set of test data with no network calls. The results are fully reproducible. See docs/benchmark.md for the full report and how to regenerate it.

Token savings

~85.6% reduction in tokens compared to carrying full session history.

In practice: instead of re-reading (or re-explaining) about 1,600 tokens of past context every session, the assistant gets a 230-token summary of just the things that matter: decisions, warnings, and key facts.

Retrieval accuracy

100% hit-rate: every one of the 10 test queries successfully retrieved the memory it was supposed to.

Precision of 33.3% is expected here: each query retrieves the top 3 candidate memories, and only one of those three is the "expected" match for a given test query. The other two are still relevant context for the agent, just not the one being scored. The important number is recall/hit-rate: the right memory is never missed.

These benchmarks are deterministic and reproducible. Run them yourself:

npm run build      # benchmark imports the compiled code from dist/
npm run benchmark  # regenerates docs/benchmark.md

How it works (in plain English)

        ┌──────────────────────────────────────────────┐
        │                  Your AI tool                 │
        │   (Claude Code, Cursor, Codex, Cline, ...)    │
        └───────────────────────┬──────────────────────┘
                                 │
                     ┌───────────▼───────────┐        ┌──────────────┐
                     │   sessionmem adapter   │        │ sessionmem   │
                     │ (translates for your   │        │     CLI      │
                     │   specific AI tool)    │        │ (you type    │
                     └───────────┬───────────┘        │  commands)   │
                                 │                     └──────┬───────┘
                                 ▼                            │
                     ┌──────────────────────────────────────────────┐
                     │              sessionmem core engine           │
                     │  watches sessions · writes summaries ·        │
                     │  finds relevant memories · trims to fit       │
                     └───────────────────────┬──────────────────────┘
                                              │
                                              ▼
                     ┌──────────────────────────────────────────────┐
                     │         One SQLite file on your computer      │
                     │     ~/.sessionmem/memories.db                 │
                     └──────────────────────────────────────────────┘