<div align="center">

<img src="https://clauderecall.com/wordmark-light.svg" alt="Claude Recall" width="400">

<br />
<br />

**Stop re-explaining your project to Claude every morning.**

Claude Recall indexes every Claude Code session you've ever run, surfaces what matters,<br />and pipes the right context back in with one command.

<br />

<img src="https://clauderecall.com/hero/brand-morph.gif" alt="Claude Recall, memory tree morphing into the wordmark" width="700">

<br />
<br />

[![npm](https://img.shields.io/npm/v/@clauderecallhq/cli?style=flat-square&color=f97316&labelColor=f97316&label=npm)](https://www.npmjs.com/package/@clauderecallhq/cli)
[![Downloads](https://img.shields.io/npm/dm/@clauderecallhq/cli?style=flat-square&color=f97316&labelColor=f97316&label=downloads)](https://www.npmjs.com/package/@clauderecallhq/cli)
[![License](https://img.shields.io/badge/license-proprietary-f97316?style=flat-square)](#license)

<br />

<sub>Your session content stays on your machine. No cloud. No account. Opt-in telemetry, off by default.</sub>

</div>

<br />

---

<br />

## The Problem

Claude Code is incredible until the conversation ends. Then you hit three walls:

<table>
<tr>
<td width="33%" valign="top">

### Context Amnesia

Every new `claude` invocation starts from zero. You re-explain the architecture, re-paste the key files, re-describe the bug you already fixed yesterday.

You built that context pyramid once. Now you're building it again.

</td>
<td width="33%" valign="top">

### Cost Blindness

Claude Code tells you nothing about spend after a session ends. Which session burned through tokens? Which project is quietly eating half your Anthropic bill?

You're guessing.

</td>
<td width="33%" valign="top">

### Session Sprawl

Claude Code scatters conversations into `~/.claude/projects/**/*.jsonl`. No titles. No search. No way to find the session where you finally got the auth flow right.

Dozens of projects. Hundreds of sessions. Zero discoverability.

</td>
</tr>
</table>

<br />

## The Fix

```bash
npm install -g @clauderecallhq/cli
recall start
recall open
```

That's it. Recall indexes every past and future Claude Code session into a searchable local database, gives you a beautiful web UI to explore them, and lets you pipe any session back into a new conversation:

```bash
# The moat: past session -> new conversation
recall context abc12345 | claude
```

Claude picks up where you left off instead of asking you to explain it again.

<br />

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/product-ui.png?v=hd3" alt="Claude Recall web UI — every Claude Code session you have ever run, with full transcripts, tool calls, threading, and search" width="900">

<sub>Every Claude Code session you have ever run. Searchable. Threaded. Re-injectable.</sub>

</div>

<br />

---

<br />

## Features

### Context Re-injection (the moat)

Pipe any past session straight into a new Claude Code conversation as condensed markdown. Claude picks up where you left off instead of asking you to re-explain it. **Nothing else in this category has it.**

```bash
recall context <id> | claude
recall context <id> --prelude "continue this" | claude
recall context <id> --since 2h | claude
```

### Threads

Group related sessions into a DAG you can see, rename, and walk. Drag-to-reparent in the graph view. Right-click rename. Bulk-generate coherent titles across an entire thread with one click.

```bash
recall thread list
recall thread create "auth-refactor"
recall thread add <thread> <session>
```

### Full-Text Search

FTS5 BM25 ranking across every message, every session, in milliseconds. Highlighted snippets, inline `#tag` filters, project + date scoping.

```bash
recall search "zod schema"
recall search "auth #auth-fix" -p Pest-Control
```

### On-Device Vector Search (Pro)

Local **768-dimension embeddings** via `bge-base-en-v1.5` ONNX. Three-lane RRF fusion (BM25 + summary + vectors) finds sessions by *meaning*, not keywords. Your code never leaves your laptop.

The embedder model (~110MB) is opt-in — install on demand with `recall semantic install`. Keeps `npm install -g` quick and avoids forcing the download on users who never touch vector search.

**One-click vectorization from the web UI.** Each project header has a `🧠 Vectorize` button. Click → pre-flight dialog shows scope (X of Y eligible sessions), three-✓ cost guarantees (free, on-device CPU only, no network), depth selector (Quick / Standard / Full / Custom chunks-per-session), and a **depth-aware ETA** computed server-side per cap level so Standard and Full give honest, different numbers. **Counters are per-repository:** the Queued, Throughput, and ETA tiles only count chunks from the project you opened the dialog from, with a separate small disclosure line surfacing how many chunks are queued from other projects ahead of yours (the worker drains FIFO globally). While running, the dialog flips to monitor mode with a live progress bar, ETA tick countdown, observed-throughput (drained-in-this-session) feeding the estimate, and visible **warm-up** (yellow) + **wind-down** (red) progress bars with timing context for the parts that have no deterministic ETA (embedder load is 5-60s by hardware; worker batch wind-down is 5-15s). **Three explicit confirmation states close every run:** green `✓ Vectorization complete — N chunks embedded in Xs` banner when the queue drains naturally, green `✓ Already vectorized — N{project} is already done` pre-flight callout (replacing the gray "Nothing to do" text) when there's nothing to vectorize, and the existing green `✓ Stopped — worker halted and queue cleared` badge for Stop. Stop itself is a **global kill switch** — clears every project's queue and halts the worker. The vector worker **does not auto-resume on daemon restart** by default; enable `semantic.autoResumeWorker: true` in `~/.recall/config.json` if you want background draining without a click. Free tier doesn't see the button — endpoint is Pro-gated.

**Anonymous install ping (opt-in, off by default).** On first run we ask once whether you want to send a single anonymous message per month so we can count real installs vs bots. No PII, no fingerprint, no cross-month linkage. Full payload at [clauderecall.com/telemetry](https://clauderecall.com/telemetry). Toggle any time with `recall telemetry on` / `off` / `view`.

```bash
recall similar <session-id>
recall semantic install                  # one-time model download (~110MB, on-device)
recall semantic reindex                  # vectorize on local CPU (idempotent, resumable)
recall semantic verify-spawn             # diagnostic — confirms claude CLI honors the no-persistence flag
```

**Two lanes.** Tier-2 (commands above — `install`, `reindex`, `verify-spawn`) is free, local, and never sends anything anywhere. Tier-1 (`recall semantic on / backfill / auto-extract`) shells out to your local `claude` CLI to summarize sessions and **costs plan tokens at ~30 sessions/min** — opt-in for users who want LLM-generated summaries on top of vectors. Default-off.

**Switching backends in place.** Pro users running an older ONNX-based vector index who upgrade to the llama.cpp backend can run `recall semantic migrate` to re-embed the existing corpus under the new backend. The command is resumable (SIGINT-safe), atomic at switchover, and retains a 30-day rollback window via `recall semantic rollback-migration`.

### Cost Analytics

Per-session and per-project token + dollar totals. Daily sparkline. Top-10 heaviest sessions. Know exactly where your Anthropic bill is going.

```bash
recall stats <id>
recall stats --project Tools --days 7
```

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/cost-analytics.gif?v=hd4" alt="Cost analytics dashboard — daily spend bars, top sessions ranked by cost, primary model breakdown" width="540">

<sub>Hover any day. Exact cost. Exact tokens.</sub>

</div>

### Git Correlation

Every session links to commits authored in its working directory during its time window. Reverse-map any commit back to the session that produced it.

```bash
recall correlate
recall blame <sha>
```

### Auto-Tagging

Let Claude label your sessions automatically. Two modes: **MCP mode** (zero-setup, runs through your existing Claude Code subscription at no extra cost) or **BYOK** (paste your own Anthropic API key). Off by default, fully opt-in.

### MCP Server (35 tools)

Expose Recall to Claude Desktop, Claude Code, or any MCP client as native tools. **13 read tools always on**, **22 write tools** opt-in with rate limiting and append-only audit logging.

```bash
recall mcp
recall mcp --allow-writes
```

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/mcp-server-demo.gif?v=hd3" alt="Claude calling Recall as native MCP tools — search and get_session executing live" width="900">

<sub>Claude searches your history, pulls context, and decides — no copy-paste.</sub>

</div>

### Collections, Tags and Notes

Hand-curated hierarchical collections that cut across projects. Flat tags. Markdown notes per session. Aliases. Pins. Cross-session diff. Every write is reversible: three-layer durability with plain-text mirrors on disk.

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/collections.gif?v=hd3" alt="Collections panel — Auth System, Database Migrations, React Refactor, API Design, Deployment Issues; drag a session card into a collection" width="540">

<sub>Drag-to-organize. Collections cut across projects.</sub>

</div>

### Web UI

Dark-mode three-pane layout. **Virtualized transcript** (10,000-message sessions open instantly). `Cmd+K` command palette. Cross-session diff. First-60-seconds onboarding tour. Export to markdown, HTML, or print-ready PDF.

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/tui-demo.gif?v=hd3" alt="Full-screen terminal UI — sessions list with live preview pane, slash-to-filter" width="900">

<sub>Or stay in the terminal. <code>recall tui</code> ships the same library as a full-screen terminal app — slash to filter, arrow keys to navigate, live preview.</sub>

</div>

### Rediscovery ("For you")

Three rotating cards in the left pane surface forgotten sessions worth revisiting: a 60+-day-old session that overlaps with what you've been working on, your top-cost session this week, and the session that authored your current `HEAD`.

```bash
recall digest
```

### IDE Extension

**VS Code, Cursor, Windsurf, VS Code Insiders.** Tag terminal tabs from inside your editor; terminal names sync to Recall so sessions get meaningful aliases with zero CLI ceremony, live as you rename tabs.

```bash
recall install-extension
```

<br />

<details>
<summary><strong>More: secrets redaction, memory health, audit log, keyboard shortcuts...</strong></summary>

<br />

- **Secrets redaction.** API keys, auth tokens, passwords, private-key blobs are detected by pattern and replaced with placeholders **before** text lands in the searchable index or any export. Original JSONLs untouched.
- **Memory health scores.** Every session gets a freshness score; surfaces stale data so you know when to re-run a backfill.
- **MCP audit log.** Every write tool call lands in `mcp_audit_events` with status (ok / error / rate_limited). Pure local, no telemetry.
- **First-60-seconds onboarding.** 3-step modal demos the moat (`recall context <id> | claude`) the moment you open the web UI.
- **Cmd+K command palette.** Jump to any session, action, or setting in one keystroke.
- **Multi-select sessions.** `Cmd+Click` toggle, `Shift+Click` range, right-click to copy IDs.
- **Three-layer durability.** Every write goes to SQLite + an append-only history column + a plain-text mirror on disk. Source JSONLs at `~/.claude/projects/` are strictly read-only.

#### Keyboard Shortcuts

| Key | Action |
|---|---|
| `/` | Focus search |
| `?` | Open Command Center |
| `Cmd+K` / `Ctrl+K` | Command palette |
| `Esc` | Close / clear / dismiss |
| `n` / `p` | Next / previous search match |
| `c` | New collection |
| `Cmd+Shift+A` | Add session to collection |
| `Cmd+Enter` | Save note |

</details>

<br />

---

<br />

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/vs-obsidian.gif?v=hd4" alt="Side-by-side: Obsidian vault on the left, Claude Recall TUI on the right showing 247 sessions across 8 projects with live preview" width="900">

<sub>People sometimes ask if this is "Obsidian for Claude Code." It is not. A general note-taking app cannot watch your filesystem for new sessions, index JSONLs into FTS5 + vector search, expose those sessions as MCP tools, or pipe a session back into Claude with one command. Claude Recall is built specifically for the loop you actually run.</sub>

</div>

<br />

## Quick Start

### Install

```bash
npm install -g @clauderecallhq/cli
```

### Start

```bash
# Start the background daemon (file watcher + local HTTP server)
recall start

# Open the web UI
recall open
```

The daemon watches `~/.claude/projects/` for new and changed session files, indexes them into a local SQLite database at `~/.recall/db.sqlite`, and serves the web UI on a random `127.0.0.1` port.

### Browse

Two interactive surfaces, both work without the daemon (they read SQLite directly):

```bash
recall                    # smart welcome dashboard with status + slash command palette
recall tui                # full terminal UI: arrow-key browse, live search, preview pane
```

`recall` (no args) prints a branded splash with version / daemon / sessions / license status and drops into a slash-aware prompt; type `/` to browse 60+ commands grouped by purpose (Setup, Browse, Pipe to Claude, Threads, Inference, Analytics, Daemon, Diagnostics, Integrations, Sharing, Feedback, Pro).

`recall tui` mounts a full-screen terminal app modeled on `lazygit` and `k9s`. Arrow keys to navigate, `/` to filter, `enter` to view the full transcript, `o` to open the selected session in the browser, `q` to quit.

### Explore

```bash
recall projects           # list projects with session counts
recall list               # 30 most-recent sessions
recall list -p Tools      # filter by project
recall show <id>          # pretty-printed transcript
recall search "auth bug"  # full-text search
```

### The Moat

```bash
# Pipe a past session into a new Claude Code conversation
recall context abc12345 | claude

# With a custom instruction
recall context abc12345 --prelude "continue where we left off" | claude

# Just the last 2 hours
recall context abc12345 --since 2h | claude
```

<br />

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/product-demo.gif?v=hd3" alt="Pipe past session context back into Claude with one command" width="720">

<sub>Claude resumes with full prior context. One command. No re-explaining.</sub>

</div>

### How Claude Recall integrates with Claude Code

Don't think of Claude Recall as a *separate* tool you context-switch to. It's **Claude Code's memory layer**: you reach it from inside any session through four surfaces, in increasing power:

**1. Bash tool: always available, zero setup.**

Inside any Claude Code conversation, just say *"run `recall search auth bug`"* (or any other recall command). The Bash tool executes it; output lands in the conversation. Works the moment you `npm install -g @clauderecallhq/cli`. No config.

**2. Slash commands (skills): one-tap workflows.**

When Claude Recall is installed as a Claude Code plugin, typing `/` in Claude Code surfaces ready-made workflows:

| Slash command | What it does |
|---|---|
| `/claude-recall:recall <query>` | Search past sessions and pull relevant ones in as context |
| `/claude-recall:context <id>` | Load one specific session's full transcript |
| `/claude-recall:neighborhood <id>` | Bundle parents + children + citations + similar |
| `/claude-recall:tag <id> <tag>` | Tag a session for later retrieval |
| `/claude-recall:alias <id> <name>` | Rename a session |
| `/claude-recall:threads-sync` | Capture currently active terminals into a thread |
| `/claude-recall:thread-scan` | Auto-detect threads across historical sessions |
| `/claude-recall:setup` | Verify installation and MCP connection |

**3. MCP server: the model calls Recall directly.**

The most powerful surface. With `recall mcp` registered as an MCP server in Claude Code, the model itself decides when to call Recall mid-conversation. Ask *"have I solved this auth bug before?"* and Claude calls `search` autonomously, gets results, and uses them. Ask *"pull yesterday's context"* and it calls `context_for_session`. No commands, no slash menu, pure intent.

**4. Piping into a fresh `claude`: start tomorrow with yesterday's context.**

The cross-session continuation pattern, run from your shell:

```bash
recall neighborhood abc12345 | claude   # bundle related sessions, start fresh chat
recall context abc12345 | claude        # one specific session, start fresh chat
```

Use case: you finish work Monday night, restart Tuesday morning with a clean Claude Code window, and want it to know what happened yesterday without re-explaining.

### MCP Server

Point any MCP client at Recall and the model calls it as native tools:

```json
{
  "mcpServers": {
    "recall": {
      "command": "claude-recall-mcp"
    }
  }
}
```

<details>
<summary><strong>Available MCP tools (35 total)</strong></summary>

<br />

**Read tools (13, always available):**

| Tool | Purpose |
|---|---|
| `list_projects` | Every indexed project with session/message counts |
| `list_sessions` | Recent sessions; filters: project, tag, date range |
| `list_tags` | Tag cloud with counts, most popular first |
| `search` | Full-text search with `#tag` support; BM25 + optional vector fusion |
| `find_similar_sessions` | Semantic similarity via vector embeddings (Pro) |
| `semantic_status` | Health snapshot: model, worker, queue depth (Pro) |
| `get_session` | Full transcript (accepts 8+ char id prefix) |
| `context_for_session` | Condensed markdown export, ready to inject |
| `recall_neighborhood` | Bundle parents/children/citations/similar as one budget-bounded markdown blob |
| `doctor` | Read-only health snapshot: db size, WAL, FTS5 fragmentation, integrity check |
| `thread_list` | All threads, newest first; can exclude archived |
| `thread_get` | Full thread detail with every session edge |
| `thread_for_session` | Non-archived threads referencing a session |

**Write tools (22, opt-in via `--allow-writes`):**

| Tool | Purpose |
|---|---|
| `list_sessions_to_tag` | Surface untagged sessions for review (auto-tag flow) |
| `apply_tags` | Add tags to a session (merge-mode, never deletes) |
| `add_tag` / `remove_tag` | Tag management; removals logged in append-only log |
| `set_alias` | Human-friendly session name; previous alias archived |
| `append_note` | Add markdown to session note; separated by `---` |
| `create_collection` | New collection; optional parent, icon, color |
| `add_session_to_collection` | Idempotent collection membership |
| `remove_session_from_collection` | Remove session; logged in append-only log |
| `thread_create` | Create thread, optionally seed with origin session |
| `thread_add_session` | Attach session; role=origin or child |
| `thread_set_parent` | Change parent within thread; null clears parent |
| `thread_remove_session` | Detach session from thread |
| `thread_rename` | Change thread display name |
| `thread_close` / `thread_reopen` | Mark thread as closed or reopen |
| `thread_archive` | Soft-delete thread; hidden by default |
| `thread_merge` | Move all edges from source to dest, delete source |
| `thread_split` | Peel sessions into new thread |
| `sync_active_sessions` | Capture every Claude Code terminal currently open in a repo into one thread, so parallel sessions stay organized |
| `generate_thread_titles` | Generate coherent titles for sessions in thread DAG |
| `optimize` | WAL checkpoint, FTS5 segment merge, planner stats refresh; optional VACUUM |

All writes are rate-limited (default 60/min), zod-validated, and audited to `~/.recall/audit/`.

</details>

<br />

---

<br />

## How It Works

```text
~/.claude/projects/**/*.jsonl   <-- Claude Code session files (read-only to Recall)
        |
        v  chokidar file watcher
~/.recall/db.sqlite             <-- indexed database (FTS5 + sqlite-vec 768d)
        |
        +-- background embedding worker (idle-aware, transactional)
        +-- git correlator (read-only 'git log' scoped to session cwd)
        +-- semantic / auto-tag scanner (opt-in, off by default)
        |
  +-----+-----+
  |           |
  CLI         HTTP server (Hono, 127.0.0.1 only)
  |           |
  recall ...  Web UI (React + Tailwind SPA, Vite-bundled)
              MCP server (stdio, 35 tools, opt-in writes)
```

### Data stays local

| Path | What |
|---|---|
| `~/.recall/db.sqlite` | Indexed database (projects, sessions, messages, FTS5, vectors, aliases, notes, tags, collections, threads, semantic summaries, commit links, usage rollups, audit logs) |
| `~/.recall/aliases.json` | Plain-text mirror of every alias with full edit history |
| `~/.recall/notes/<session>.md` | One markdown file per session note |
| `~/.recall/tags.json` | Current tag state + append-only event log |
| `~/.recall/collections.json` | Current tree state + append-only event log |
| `~/.recall/semantic/<id>.json` | Per-session summary + keywords (semantic mode) |
| `~/.recall/license.jwt` | Activated Pro license (offline-validatable, dead-man clause) |

<br />

---

<br />

## Privacy & Security

<div align="center">

<img src="https://cdn.clauderecall.com/marketing/privacy-trust.gif?v=hd4" alt="Local-first design — daemon binds to 127.0.0.1, session content stays on your machine" width="640">

</div>

<br />

Claude Recall is **local-first by design**, not as an afterthought.

- **The daemon binds to `127.0.0.1` only.** Never `0.0.0.0`, never a public interface.
- **No session content is uploaded — ever.** The daemon, file watcher, indexer, and web UI never transmit your session data. Search, context re-injection, and the web UI are fully local.
- **No cloud. No account.** Your data lives at `~/.recall/` and nowhere else.
- **Source sessions are never modified.** Claude Code's JSONL files at `~/.claude/projects/` are strictly read-only to Recall.
- **Never-delete-data invariant.** Every write enforces three independent durability layers: SQLite with history columns, plain-text mirror on disk, and source JSONLs untouched. Renaming, clearing, or removing anything is always additive; the prior value is archived, never destroyed.

The daemon's full outbound network surface — metadata only, never session content:

| Trigger | Endpoint | What it sends | What it gets | Automatic? |
|---|---|---|---|---|
| `recall activate <key>` | `clauderecall.com` | License key only | A signed JWT for offline validation | No — only when you activate |
| Pro license revocation check | `clauderecall.com` | Anonymous license fingerprint | OK / revoked status | Yes — daily, after activation |
| `recall semantic install` | `huggingface.co` | Nothing about you | The `bge-base-en-v1.5` ONNX model | No — only when you opt in to vector search |
| Anonymous install ping | `clauderecall.com` | One anonymous nonce, no PII, no fingerprint, no cross-month linkage | Nothing | Yes — once a month, only after `recall telemetry on` (off by default) |

Activate is required for Pro features. Telemetry is opt-in. Without activation and without telemetry, the daemon's automatic outbound surface is zero — Recall is fully air-gapped for indexing, search, and context re-injection. Full telemetry disclosure: [clauderecall.com/telemetry](https://clauderecall.com/telemetry).

<br />

---

<br />

## Full CLI Reference

<details>
<summary><strong>Click to expand</strong></summary>

<br />

```bash
# Surfaces
recall                    # smart welcome dashboard + slash command palette (no args)
recall tui                # interactive terminal UI for browsing and search

# Lifecycle
recall start              # start daemon (watcher + local HTTP)
recall stop               # stop daemon
recall open               # open web UI (starts daemon if needed)
recall status             # db + daemon health

# Indexing
recall index              # scan for new/changed session files
recall index --force      # reindex everything

# Explore
recall projects           # list projects with session counts
recall list               # 30 most-recent sessions
recall list -p Tools      # filter by project substring
recall list -n 100        # higher limit

# Read
recall show <id>          # pretty transcript, auto-paged
recall show <id> --raw    # raw JSONL
recall show <id> --no-pager

# Search
recall search "zod schema"
recall search "auth" -p Pest-Control
recall search bug -n 50

# Context re-injection
recall context <id>                              # condensed markdown
recall context <id> | pbcopy                     # to clipboard (macOS)
recall context <id> | claude                     # into new Claude session
recall context <id> --full                       # full transcript
recall context <id> --since 2h                   # last 2 hours only
recall context <id> --prelude "continue this"    # prepend instruction
recall context <id> --subagents                  # include subagent messages

# Stats
recall stats <id>              # tokens + dollars for one session
recall stats --project Tools   # per-project rollup
recall stats --days 7          # 7-day overview
recall stats --backfill        # one-shot usage backfill

# Git correlation
recall correlate               # link sessions to commits
recall blame <sha>             # commit -> session reverse lookup

# Semantic / vector search (Pro)
# Embedder model is opt-in — `npm install` does NOT auto-download it.
recall semantic install        # download on-device embedding model (~110MB)
recall semantic status         # model + backfill progress + auto-extract state
recall semantic reindex        # re-embed everything
recall semantic migrate        # re-embed existing corpus under a different backend (Pro)
recall semantic rollback-migration --force  # restore prior corpus within 30-day window
recall semantic prune-rollback --force      # drop backup table early
recall semantic auto-extract on  # daemon nibbles un-extracted sessions through Claude (Pro)
recall similar <id>            # cosine kNN over session chunks

# Threads
recall thread list             # all threads, newest first
recall thread create <name>    # new thread
recall thread add <t> <s>      # attach session to thread

# Rediscovery
recall digest                  # today's "For you" picks
recall digest --json           # machine-readable

# MCP server
recall mcp                     # stdio, read-only
recall mcp --allow-writes      # opt-in write tools

# Pro license
recall activate <key>          # one-time activation, offline forever
recall activate RECALL7DAY     # CLI-direct 7-day trial — prompts for email, no browser
recall trial RECALL7DAY        # same, alternative entry point
recall license                 # show license status

# IDE extension
recall install-extension       # auto-install for VS Code / Cursor / Windsurf

# Maintenance
recall health                  # memory health scores per project
recall paste                   # archive clipboard content into Recall (opt-in)
recall audit-secrets           # scan index for residual secrets
```

</details>

<br />

---

<br />

## Tech Stack

| Layer | Technology |
|---|---|
| CLI + daemon | TypeScript (strict), Node 22+, ESM |
| HTTP server | Hono + @hono/node-server |
| Database | better-sqlite3 with FTS5 full-text search |
| Vector store | sqlite-vec (768d, on-device) |
| Embeddings | @huggingface/transformers (`bge-base-en-v1.5` ONNX) |
| File watcher | chokidar |
| CLI parsing | commander |
| MCP server | @modelcontextprotocol/sdk (stdio) |
| Validation | zod |
| Auth | jose (offline-validatable signed JWT licenses) |
| Web UI | Vite 8 + React 19 + Tailwind CSS |
| Data fetching | @tanstack/react-query |
| Virtualization | @tanstack/react-virtual |
| Markdown | marked + highlight.js + DOMPurify |

<br />

---

<br />

## Supported Platforms

Claude Recall is a Node.js CLI with a few native dependencies (`better-sqlite3`, `sqlite-vec`, and the optional `@huggingface/transformers` for semantic search). npm picks the right prebuilt binary for your platform automatically; no compile toolchain required.

| Platform | Tier | Status |
|---|---|---|
| **macOS** arm64 (Apple Silicon, M1+) | Tier 1 | Tested in pre-publish smoke test |
| **macOS** x64 (Intel) | Tier 1 | Tested in pre-publish smoke test |
| **Linux** x64 (glibc, kernel 4.x+) | Tier 1 | Tested on every CI run (Node 22, 24) |
| **Linux** arm64 (glibc) | Tier 2 | Best-effort. Native deps ship arm64 prebuilds; report issues if you hit one |
| **Windows** x64 (Windows 10+) | Tier 1 | Tested in pre-publish smoke test |
| Windows arm64 / Linux musl (Alpine) / 32-bit | Unsupported | Native deps lack reliable prebuilds; install will be rejected |

**Node:** 22 LTS or 24 LTS. Node 20 and earlier are unsupported (declared in `engines.node`).

**Semantic search is optional.** The on-device embedder is the only feature that loads the native ONNX runtime. The model (~110MB) is opt-in — install on demand with `recall semantic install`. Core CLI features (search, list, context, daemon, MCP) work on every supported platform regardless of whether the embedder is installed. If the embedder fails to load on your platform, you get a clear error pointing here, and the rest of Claude Recall keeps working.

<br />

---

<br />

## Distribution

Claude Recall ships on every surface a developer already works in.

| Surface | Identity | Install |
|---|---|---|
| **npm** (CLI + MCP) | [`@clauderecallhq/cli`](https://www.npmjs.com/package/@clauderecallhq/cli) | `npm i -g @clauderecallhq/cli` |
| **VS Code Marketplace** | [`clauderecallhq.clauderecall-vscode`](https://marketplace.visualstudio.com/items?itemName=clauderecallhq.clauderecall-vscode) | Search "Claude Recall" in Extensions |
| **MCP Registry** | [`com.clauderecall/recall`](https://registry.modelcontextprotocol.io/v0/servers?search=clauderecall) | Auto-discovered by MCP clients |
| **Claude Code Plugin Hub** | `claude-recall` | `/plugin install claude-recall` in Claude Code |
| **Website** | [clauderecall.com](https://clauderecall.com) |   |

The npm package ships **the CLI and the MCP server**. The VS Code extension is a thin companion that talks to the local daemon over `127.0.0.1`. The MCP Registry and Claude Code Plugin Hub both point back to the npm package: one source of truth, one update pipeline.

<br />

---

<br />

## Pricing

One tier is free forever. One tier is a **one-time** purchase that works offline for life, even if we disappear. One tier is a conversation.

### Free

**$0.** Forever. No signup. No credit card.

- Full indexing of every `~/.claude/projects/` JSON-L
- CLI: `list`, `show`, `projects`, `status`
- Web UI: browse projects, read transcripts, copy code
- Three-layer durability

```bash
npm install -g @clauderecallhq/cli
```

### Pro (daily driver)

**$29.69 one-time** through May 2026 (Founder pricing). **$49.69 one-time** from June 2026 (standard). Pay once. Offline forever. Lifetime updates. Dead-man clause included. Never a subscription.

- Full-text search (FTS5 BM25)
- On-device semantic vector search (768d, RRF fusion)
- `recall context` re-injection, **the moat**
- MCP server (Claude Desktop / Claude Code native tools)
- VS Code / Cursor / Windsurf extension
- Aliases, tags, markdown notes, pins, date filters, cross-session diff
- Export: clean markdown, self-contained dark-mode HTML, print-ready
- Virtualized transcript (10k+ message sessions open instantly)
- Auto-tagging (API-key + MCP modes)
- Secrets redaction (client-side scrub of keys, tokens, passwords pre-index)
- **Every future personal-use feature.** One price, lifetime updates.

[**Buy Pro for $29.69 (Founder pricing through May)**](https://clauderecall.com/pricing)

### Enterprise

**Contact us.** Built for 50+ developer organizations.

- Shared session library with end-to-end encrypted team sync
- Team-wide tag conventions
- Local audit log (compliance-grade, not surveillance)
- SSO + per-project access control
- Priority support, named engineer
- Optional on-prem deployment

[hello@clauderecall.com](mailto:hello@clauderecall.com)

<br />

### How it compares to what you already pay

| Tool | Price |
|---|---|
| **Claude Recall** | **$29.69 one-time** through May 2026, **$49.69 one-time** from June |
| Claude Code | $20 / mo |
| Cursor | $20 / mo |
| Raycast Pro | $8 to $16 / mo |
| GitHub Copilot | $10 / mo |

<sub>Prices as of May 2026.</sub>

<br />

### The dead-man clause

Your Pro license validates against our server exactly once, at activation. After that, Recall works **offline forever**. If `clauderecall.com` ever disappears, every existing license stays valid; we'll publish the validation secret if we ever shut down, so you're never stranded.

Full pricing FAQ: **[clauderecall.com/pricing](https://clauderecall.com/pricing)**

<br />

---

<br />

## Roadmap

- [x] CLI, daemon, web UI, full-text search
- [x] Context re-injection (the moat)
- [x] Aliases, notes, tags, pins
- [x] Cross-session diff
- [x] VS Code / Cursor / Windsurf extension
- [x] MCP server (read-only)
- [x] Collections (hierarchical, cross-project)
- [x] Auto-tagging (MCP + BYOK modes)
- [x] Cost / token analytics
- [x] Git correlation
- [x] Cmd+K command palette
- [x] Bidirectional MCP write tools (rate-limited + audited)
- [x] First-60-seconds onboarding
- [x] Rediscovery surface ("For you" cards)
- [x] **On-device vector search** (768d ONNX embeddings, RRF fusion)
- [x] **Threads.** DAG view, drag-to-reparent, bulk title generation
- [x] **Pro license + dead-man clause** (offline-validatable JWT)
- [x] Memory health scores
- [x] Claude Code plugin manifest
- [ ] Public launch at clauderecall.com
- [ ] Team features (E2E-encrypted sync, SSO, audit log)
- [ ] Enterprise tier (on-prem, named-engineer support)

<br />

---

<br />

## License

Proprietary. Free tier is free forever for personal use. Pro is a one-time purchase with offline-validatable JWT and a dead-man clause: if `clauderecall.com` ever shuts down, every existing license stays valid and the validation secret will be published so you're never stranded. Full terms at [clauderecall.com/terms](https://clauderecall.com/terms).

<br />

---

<br />

<div align="center">

<img src="https://clauderecall.com/mark-scrollback-dark.svg" alt="Claude Recall" width="48">

<br />
<br />

**Claude Recall.** The memory layer for the agent you're steering.

[Website](https://clauderecall.com) · [Install](https://www.npmjs.com/package/@clauderecallhq/cli) · [Issues](https://gitlab.com/clauderecallhq/clauderecallhq/-/issues)

<br />

<sub>Built by <a href="https://gitlab.com/clauderecallhq">@clauderecallhq</a></sub>

</div>
