Session Memory Pipeline

Every time you start a new Claude Code session, Claude has no memory of what happened before. Your CLAUDE.md provides static instructions, but it doesn't know what you worked on yesterday, what decisions you made, or what's left unfinished. You're constantly re-explaining context.

The typical workaround is to manually paste notes or dump entire conversation logs into the next session. This is noisy, burns tokens on irrelevant context, and doesn't scale.

What you actually want is a pipeline that automatically captures the important parts of each session, stores them in a searchable format, and loads relevant context when you start the next one.

The pipeline has three layers: automatic context injection via hooks, semantic search over all past transcripts via session-rag, and lifecycle skills that load context at session start and capture knowledge at session end.

session-rag is an MCP server that indexes Claude Code JSONL transcripts directly into a Milvus Lite vector database with a SQLite FTS5 keyword sidecar, providing hybrid semantic + keyword search across all past sessions. It works natively with the JSONL format Claude Code already writes, indexes in real-time via a file watcher, and supports date range filtering for historical queries.

How it works

session-rag runs as an HTTP MCP server on port 7102. It watches ~/.claude/projects/ for new JSONL transcript files, chunks and embeds them using EmbeddingGemma-300M (optimized for Apple Silicon), and stores vectors in a local Milvus Lite database at ~/.session-rag/. A parallel SQLite FTS5 index provides keyword search. Results from both engines are merged using Reciprocal Rank Fusion (RRF) for the best of both worlds.

MCP tools

Usage examples

# Search across all sessions with date filtering
search_all_sessions("what was the decision about auth middleware",
    date_from="2026-03-01", date_to="2026-03-15")

# Search within the current session
search_session("how did we fix the build error")

# Get full context around a search hit
get_turns(session_id="abc123", turn_index=42, context=3)

# Check index health
get_session_stats()

# Clean up old session data
cleanup_sessions(max_age_days=90)

The real power comes from wiring the pipeline into your session lifecycle. Three skills handle this: /start for quick resumes, /prime for full boots, and /wrap at session end.

/start — Quick Resume

/start is the lightweight alternative to /prime. Use it for same-day work or resuming after a short break. Claude:

1. Queries session-rag for recent session context
2. Searches mem0 for project memories
3. Checks git state and open issues
4. Presents a quick briefing — no indexing, no health checks

   Use /start when you're continuing the same thread of work.
   Use /prime when you've been away for days or switching projects.

/prime — Full Session Boot

When you start a session and type /prime, Claude:

1. Queries session-rag for recent session context
2. Searches mem0 for recent memories about this project
3. Checks git status, open PRs, and unfinished issues
4. Verifies code indexes are fresh (vector DB + graph DB)
5. Gathers full project status
6. Presents a unified startup briefing:

   "Last session you were working on STAK-498 (price scraper bug).
    PR #903 was merged. Tasks 4-5 are still open. The poller was
    redeployed to both Portainer and Fly.io. Code indexes are fresh."

/wrap — Session End

When you're done and type /wrap, Claude runs the retrospective inline (no separate /retro step) and saves everything to mem0:

1. Checks for uncommitted changes, open PRs, in-progress tasks
2. Asks what to do with any loose ends (commit? stash? discard?)
3. Runs retrospective inline — captures prescriptive lessons
   (what to do differently, not just what happened)
4. Saves retro lessons + curated session summary to mem0
5. Cleans up merged worktree branches
6. Prints a session recap with shipped/pending/next-session summary

   Note: /wrap saves to mem0 only. session-rag indexes the raw JSONL
   transcript automatically — no digest step needed.

There are multiple valid approaches to solving the session memory problem. Here's how the lifecycle approach compares to other strategies.

These approaches are complementary. You could run both — use lifecycle skills for day-to-day session management and a universal indexer for periodic deep analysis of your conversation corpus.

1. Set up session-rag

Clone the session-rag fork and run it as an HTTP MCP server. It indexes your Claude Code JSONL transcripts into a local Milvus Lite vector database with FTS5 hybrid search. The file watcher picks up new sessions automatically — no cron jobs or manual indexing needed.

git clone https://github.com/lbruton/claude-code-session-rag.git
cd claude-code-session-rag
pip install -r requirements.txt
python http_server.py  # runs on port 7102

2. Set up mem0

mem0 provides cloud-hosted cross-session memory with automatic fact decomposition. Sign up at mem0.ai and add it as an MCP server in your Claude Code config. Together with session-rag, these form the two authoritative session context sources.

3. Add to MCP config

{
  "mcpServers": {
    "session-rag": {
      "type": "http",
      "url": "http://localhost:7102/mcp"
    },
    "mem0": {
      "command": "npx",
      "args": ["-y", "@mem0/mcp"],
      "env": { "MEM0_API_KEY": "your-key-here" }
    }
  }
}

4. Create the skills

mkdir -p ~/.claude/skills/start
mkdir -p ~/.claude/skills/prime
mkdir -p ~/.claude/skills/wrap
# Create SKILL.md in each directory with the lifecycle logic

5. Try it

# Start a new Claude Code session
claude

# Quick resume (same-day work or short breaks)
> /start

# Or full boot (days away, new project)
> /prime

# ... do your work ...

# Capture everything before closing
> /wrap