> ## Documentation Index
> Fetch the complete documentation index at: https://docs.linksee.app/llms.txt
> Use this file to discover all available pages before exploring further.

# Introduction

> A local-first memory layer for coding agents — tied to a product map that catches when your README, docs, and code drift apart.

## What is Linksee Memory?

Linksee Memory is a **local-first MCP server** that gives every AI agent on your machine persistent, structured memory — and ties that memory to a **product map**, so it can also catch when your README, docs, and code quietly drift apart.

Sessions end. Agents forget. You're juggling several projects, and so is your agent. Linksee Memory fixes the forgetting — then uses the same memory + map to catch drift, with file:line evidence.

<CardGroup cols={2}>
  <Card title="Cross-agent" icon="link">
    Claude Code, Cursor, Windsurf, OpenAI Codex, Gemini CLI — one memory, all agents.
  </Card>

  <Card title="Product map" icon="map">
    `where_am_i` + the `linksee-memory map` CLI locate any file on your map and report its blast radius.
  </Card>

  <Card title="Drift detection" icon="radar">
    Reconcile what you decided against the actual code — convergence / divergence with evidence.
  </Card>

  <Card title="Local-first" icon="hard-drive">
    No cloud. No account. No network calls. One SQLite file on your machine.
  </Card>
</CardGroup>

## Quick Start

One command sets up the MCP server, the skill, and the auto-capture hook:

```bash theme={null}
npx -y linksee-memory setup
```

Restart your agent. Done. (Prefer manual config? See [Installation](/installation).)

<Tip>
  Works with **any MCP-compatible client** — Claude Desktop, Claude Code, Cursor, Windsurf, Cline, and more.
</Tip>

## Key Features

* **11 MCP tools** — memory (`remember`, `recall`, `read_smart`), drift (`drift_status`, `declare_anchor`, `check_decision`, `resolve_drift`, `flag_proposals`, `resolve_proposal`, `dream`), and **`where_am_i`** — locate the current file on your product map + its blast radius.
* **`linksee-memory map` CLI** — `where` · `affects` · `explain` · `status` · `next` · `reconcile` · `inspect --json` · `blueprint`. A `map.yaml` (git source of truth) describes how value reaches your user; the reconciler checks it against your code. Bilingual via `--lang ja`.
* **6-layer structured memory** — goal / context / emotion / implementation / caveat / learning, with an Ebbinghaus forgetting curve (caveats and goals protected forever).
* **AST-aware token-saving reads** — `read_smart` returns only changed chunks (50–99% fewer tokens on re-reads).
* **Local-first & bilingual** — one SQLite file, no network, full Japanese + English (trigram FTS5).

## How It Works

1. **During a session**, the agent calls `remember` to store decisions, caveats, and context.
2. **On the next session**, `recall` retrieves relevant memories ranked by relevance, heat, and importance.
3. **Across the product**, a `map.yaml` records how those decisions reach the user; `reconcile` checks the map against the actual code and flags drift with file:line evidence.
4. **Anytime**, `where_am_i` tells the agent where it is on the map and what else a change would touch.

## System Requirements

* Node.js 20+
* Any MCP-compatible client
* \~10 MB disk space for the SQLite database

## Next Steps

<CardGroup cols={2}>
  <Card title="Installation" icon="download" href="/installation">
    Detailed setup for every MCP client
  </Card>

  <Card title="Quick Start" icon="rocket" href="/quickstart">
    Your first remember → recall flow in 2 minutes
  </Card>

  <Card title="Product map & drift" icon="map" href="/concepts/product-map">
    where\_am\_i, the map CLI, and how drift detection works
  </Card>

  <Card title="Memory Layers" icon="layer-group" href="/concepts/memory-layers">
    Understand the 6-layer structure
  </Card>
</CardGroup>