Cairn Remembers

MCP文档知识

提供方 未标注

文档知识 未标注 未标注 社区 / 第三方 Claude DesktopClaudeCursorVS Code

本地记忆,供你的AI工具共享:跨会话延续的决策、笔记与修正。

一句话选型结论

按资料字段整理

Cairn Remembers 属于文档知识类 MCP 服务器,传输方式未标注,鉴权方式未标注,可直接接入 Claude Desktop、Claude、Cursor 等,没有现成安装命令,需按官方文档接入。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

分类文档知识 传输方式未标注 鉴权未标注 部署方式未标注
GitHub 星标 未标注 仓库热度,无公开仓库时显示未标注
工具数 未标注 暴露给模型的工具数量
资源 / 提示词 0 / 0 资源与提示词模板数量
维护方 社区 / 第三方 核验等级 仅资料核对

工具与能力

文档知识
数量来自来源目录的标注,具体工具清单以官方文档为准
工具数量未标注暴露给模型可调用的工具个数
资源数量0可读取的资源条目
提示词数量0内置提示词模板数量

能力标签

支持客户端

适用场景

记忆

安装与配置

未标注 未标注
上游未给出传输方式
  1. 1
    准备运行环境

    按官方文档确认运行环境(常见为 Node.js 或 Python),装好后再执行安装命令。

  2. 2
    安装服务

    复制上面的安装命令执行;命令里带占位符的位置,换成自己的密钥或路径。

  3. 3
    写入客户端配置

    在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,让新配置生效。

  4. 4
    验证是否可用

    连接成功后随便调一个只读工具,确认能返回结果,再接入正式流程。

典型使用场景

3 类
按分类与标签整理的常见用法,具体以官方文档为准
文档检索问答

在你的文档库里按问题找答案。

知识库读写

把新资料写进知识库,随用随取。

内容整理

把零散资料归纳成结构化笔记。

选择建议

选之前先看这几条
按条目字段给出的判断,不替你决定用不用

值得选的地方

  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • 没有现成安装命令,需要按官方文档自己填启动命令和参数。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

  • 需要在文档知识场景里让模型直接调用外部能力的人。
  • 已经在用 Claude Desktop、Claude 的用户,接入路径最短。
  • 想先快速试一下、能接受在本地或自有环境跑服务的人。

不太适合

  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Cairn Remembers当前 未标注 未标注 未标注 无 未标注
dify 未标注 stdio · 本地进程 本地部署 有 2026-04-11
open-webui 未标注 stdio · 本地进程 本地部署 有 2026-04-11
JeecgBoot 未标注 stdio · 本地进程 本地部署 有 2026-04-11
Cherry Studio 未标注 未标注 未标注 无 2026-05-17
mempalace 未标注 stdio · 本地进程 本地部署 有 2026-04-11

服务器档案

文档知识
字段来自项目仓库与公开索引,中文说明由本站标注
提供方未标注上游标注的维护方 未标注
分类文档知识本站按上游分类展示
连接方式未标注上游未给出传输方式
鉴权方式未标注远程服务建议用最小权限凭据
维护方社区 / 第三方核验等级 仅资料核对
包名 / 运行时未标注 · 未标注本地安装时用到的包标识与运行时
部署类型未标注上游给出的部署形态
最近核验未标注上游最后核验时间

详细介绍

13.9 KB
来自项目仓库与上游目录的原文,未做删改

Cairn

> Build knowledge. Leave signals. — Tools for modern explorers.

Local-first episodic memory for AI agents — and for you.

A cairn is a stack of stones that marks a trail. This one marks the trail of your
thinking: every decision, dead end, and reason becomes a node you — and any model —
can find again, across sessions and across model generations.

  • Local-first — everything lives in one SQLite file at ~/.cairn/. No cloud, no account, no telemetry.
  • Model-agnostic — any agent that runs a shell command or speaks MCP: Claude, GPT/Codex, Gemini, local models.
  • Append-only — memories are voided, never deleted. The record is the record.
  • Yours — Cairn sends nothing off your machine. Your chat still goes to whatever model you chose, exactly as it would without Cairn — use a local model and nothing leaves at all.

Two ways in:
- 🧑 A person setting this up? Keep reading — Quick start takes about 5 minutes. Every option and fix: QUICKSTART.md.
- 🤖 An AI agent installing Cairn for someone? → SETUP_FOR_AGENTS.md is written for you (install, consent, attribution).


See inside Cairn

Keep the decisions, reasons and unfinished work you want to return to. Cairn stores them in a local vault that you and your connected AI tools can read and add to. Each AI keeps its own memory and context. These demos show the optional dashboard for exploring the record.

HubProjectsConnections

Pick up unfinished work.Keep related work together.Explore linked memories.

Explore all five demos and descriptions.

  • Hub — 9 seconds
  • Projects — 18 seconds
  • Index — 6 seconds
  • Live Feed — 14 seconds
  • Connections — 8 seconds

Recorded in a local installation. Private text uses examples; controls and source attribution are retained. The filmed installation has not been verified against every control in release 0.3.3. Demo descriptions and recording notes.

Contents

  • Quick start
  • Wire up your AI
  • What you get
  • Advanced install
  • Multiple accounts
  • What to back up
  • Common commands
  • License

Quick start

> Two places, never mixed up:
> 🖥️ Your terminal (PowerShell / Terminal) — every command on this page runs here, on your computer. Wiring is always a terminal command or a config-file edit — an AI can run those terminal steps for you (that's the fastest path below), but wiring is never something you paste into the chat box.
> 💬 The AI chat — where memory shows up, and where you test the wiring by asking the AI to use it.

Fastest — let your AI do it

Open Claude Code, Codex, or Cursor and paste:

> Install and set up Cairn for me from https://github.com/CairnRemembers/cairn

Your AI runs the terminal steps and asks before switching memory on — one yes/no per
AI on your machine, default No. Nothing records without your yes. (Using Codex?
There's one extra paste after that — see Wire up your AI.)

Or do it yourself

1 — Install 🖥️ (installs software only — records nothing, the vault starts empty)

> ⚠️ Installing [all] on Linux / WSL? Run
> pip install torch --index-url https://download.pytorch.org/whl/cpu first, or pip
> pulls a multi-GB CUDA torch stack you don't need. Windows and macOS torch wheels are
> already CPU-only.```bash
pip install cairn-remembers # base install
pip install "cairn-remembers[all]" # + embedder + dashboard


#### From source

Still the richer path — the installer handles the CPU-torch step for you:

**Get the code** 🖥️```bash
git clone https://github.com/CairnRemembers/cairn
cd cairn

Run the installer 🖥️```bash

Windows: .\install.ps1 (blocked? powershell -ExecutionPolicy Bypass -File .\install.ps1)

macOS/Linux: ./install.sh

The installer finds Python 3.11+, installs everything (first run downloads PyTorch — the
lean CPU build on Linux/Windows, a few minutes), and checks itself.

**2 — Wire up your AI.** This is where memory actually turns on, and **each AI needs
different wiring** — a `y` in setup finishes the job for Claude Code, but *not* for
Codex or Claude Desktop. Find your AI below and follow it to its ✅.

---

## Wire up your AI

Cairn has **two separate wires**, and knowing the difference prevents every common surprise:

- **Capture** — your chats get *remembered* automatically (writes to the vault).
- **Tools** — the AI can *search and note* your vault from inside the chat (reads + on-demand writes).

Some AIs need one wire, some need both. Don't stop at the first ✓ — follow your AI to its ✅ line.

### Claude Code — one command
🖥️ In the terminal:```bash
python -X utf8 -m cairn setup        # answer y for Claude Code

That wires capture: every new Claude Code chat auto-orients (you'll see the
banner), records as you work, and compiles when it ends. Machine-wide, one-time,
reversible (cairn disconnect --global). Prefer one project only? Run cairn connect
inside that repo instead (global and per-project are mutually exclusive — doctor flags it).

✅ Done when: a new chat opens with a "CAIRN — inherited context" banner,
and 🖥️ python -X utf8 -m cairn doctor shows ✓ capture.

Optional — native tools: Claude Code can already read the vault by running cairn
commands in its shell. For native cairn_* tools instead, register the MCP server
user-wide, pointing at the Python that can import cairn (a bare python that can't
is the #1 failure — prove the path first, QUICKSTART §6a):```bash
claude mcp add --scope user cairn -- <full-path-to-python> -X utf8 -m cairn mcp

💬 Proof: ask the chat to *&quot;call cairn_orient&quot;*. *(`doctor` can&#x27;t see this wire — the ask is the test.)*

### OpenAI Codex — three pieces, each does a different job
1. **Capture** 🖥️ — `python -X utf8 -m cairn setup` → `y` for Codex (= `codex-hook install`).
   Captures turns live as Codex fires `notify` (deduped by turn id). For a comprehensive
   sweep of everything on disk, run 🖥️ `python -X utf8 -m cairn import codex-sessions --apply` anytime.
2. **Tools** 📄 — add to `~/.codex/config.toml`, then fully restart Codex
   (full §6 walk-through):```toml
[mcp_servers.cairn]
command = &quot;&lt;full-path-to-python&gt;&quot;
args = [&quot;-X&quot;, &quot;utf8&quot;, &quot;-m&quot;, &quot;cairn&quot;, &quot;mcp&quot;]
startup_timeout_sec = 30
tool_timeout_sec = 120
default_tools_approval_mode = &quot;approve&quot;
  1. Habit 📄 — create ~/.codex/AGENTS.md and paste the memory protocol from
    QUICKSTART §6c so Codex orients, fetches,
    and notes unprompted. (Needs piece 2 — the protocol calls those tools.)

✅ Done when: 🖥️ python -X utf8 -m cairn codex-hook status prints INSTALLED,
and 💬 a Codex chat answers "call cairn_orient" with a digest (with piece 3, its first
reply starts [cairn: oriented — N]).
⚠️ Honest note: cairn doctor structurally detects Codex MCP registration (the
[mcp_servers.cairn] block), but it does not prove the server launches or that the notify
hook captures — the checks above are the real proof of those.

Claude Desktop / Cursor — one paste

📄 Add to claude_desktop_config.json (or Cursor's MCP settings), then restart the app:```json
{
"mcpServers": {
"cairn": { "command": "python", "args": ["-X", "utf8", "-m", "cairn", "mcp"] }
}
}

That&#x27;s the **tools** wire — search, fetch, wander, note from inside the chat. These
surfaces have **no ambient capture**; what you ask the AI to `cairn_note` is what lands.
*(If the app can&#x27;t find Python, use the full path of the Python that installed Cairn.)*

✅ **Done when:** `doctor` shows **✓ MCP — registered in Claude Desktop config**
(Desktop), or 💬 the *&quot;call cairn_orient&quot;* smoke test answers (Cursor).

---

**Applies to every AI above:**
- **Wiring is one-time.** New chats just remember — you never activate per chat. `orient` *reads* memory; it never switches anything on. Scope varies by wire: Claude Code hooks are machine-wide (or one project via `cairn connect`); Desktop/Cursor and Codex live in each app&#x27;s own config, per account.
- **Only NEW chats pick up new wiring** — finish wiring, then open a fresh chat. (Long-lived MCP clients re-read the tools only on a full restart.)
- **Privacy controls:** skip one chat — `CAIRN_CAPTURE=0` in that shell (PowerShell `$env:CAIRN_CAPTURE=&quot;0&quot;` · cmd `set CAIRN_CAPTURE=0` · bash `export CAIRN_CAPTURE=0`) · pause everywhere: `cairn capture off` / `on` · secrets scrubbed before write (append-only, fail-closed).
- **Undo:** `cairn disconnect [--global]` · `cairn codex-hook uninstall` · re-run `cairn setup` to review.

---

## What you get

- **One vault, every model.** Any agent that speaks MCP or can run `cairn` reads and writes the same memory — so one agent builds on what another wrote, even across rival vendors.
- **Keep your place across a usage cap.** Hit a limit on one model, continue on another, and point it at where you left off — the trail is in the vault, not in one model&#x27;s context.
- **Captured as you work** — decisions, dead ends, tool calls, and turns become searchable nodes, from the moment you wire it.
- **Nothing worth keeping disappears.** Every captured turn stores its complete text: search results are gists — an index — `cairn read ` prints any node in full, and MCP `cairn_read` pulls it whole with a raised `max_chars`.
- **A local maintenance pass you run** — `cairn sleep`, nightly by habit or on your own scheduler (it doesn&#x27;t schedule itself): embed → consolidate → prune → rebuild the graph → compile, all on your machine. One exception to &quot;no network&quot;: the very first embed downloads the ~80 MB model, once.
- **A map of your thinking** — the dashboard galaxy (`cairn dashboard` → http://127.0.0.1:7331), plus a human-readable Hub / Book / Index.
- **Backfill** — distill old conversations into sharp, connected `claim` nodes.

---

## Advanced install

Manual install, lighter builds, and venvs

**By hand** (what the installer runs):```bash
# Linux / WSL: install the CPU-only PyTorch first, or pip pulls a ~4.6 GB CUDA
# stack you don&#x27;t need. (Want a GPU build? Install your torch first, then run the
# line below — it&#x27;s preserved.) macOS: skip this line — its default wheel is CPU/MPS.
pip install torch --index-url https://download.pytorch.org/whl/cpu

pip install -e &quot;.[all]&quot;      # package + embedder + dashboard

Lighter builds:```bash
pip install -e ".[embeddings]" # no dashboard
pip install -e ".[dashboard]" # no embedder

Base install is stdlib + `numpy`. Extras add the embedder (`sentence-transformers` — the ~80 MB model downloads once, on first use) and the dashboard (`fastapi` + `uvicorn`).

**PEP-668 &quot;externally-managed-environment&quot;** (Ubuntu/Debian/Homebrew/WSL): install into a venv first —```bash
python3 -m venv .venv &amp;&amp; source .venv/bin/activate &amp;&amp; ./install.sh

Multiple accounts

One login per AI? Skip this — it just works. Each AI signs in with its own
account, and Cairn files that AI's work under its own galaxy automatically —
Claude and GPT never mix, with zero setup.

Read on only if you run two accounts of the same AI (two Claude logins, two
ChatGPT/Codex logins — say, personal and company). Galaxies are keyed to each
login's stable id and never merge — but with two same-AI logins on one machine,
Cairn can't always prove which one is active. The rule that keeps it clean:

> Declare, don't detect: set CAIRN_ACCOUNT per account, up front.```bash

Claude Code — launch each account with its label:

export CAIRN_ACCOUNT=work && claude # bash/zsh (or set it in that profile)

PowerShell: $env:CAIRN_ACCOUNT="work"; claude

Codex — put it in that account's ~/.codex/config.toml:

[mcp_servers.cairn] env = { CAIRN_ACCOUNT = "work" }

Importing old history? Always pass the flag:

cairn import <export> --source=claude --account=work


Name and manage them anytime:```bash
cairn account                          # list galaxies + node counts
cairn account rename &lt;key&gt; &quot;Company&quot;   # display label only — never merges or deletes
cairn account doctor                   # read-only check — prints the exact fix command per mismatch
cairn account fix-session &lt;session-id&gt; &lt;slug&gt;   # re-file ONE named session (backed up, then locked)
cairn account fix-session &lt;slug&gt;                # same, for the current session only

Honest limits — so you're never surprised:
- Claude Desktop proves the active account per session automatically. Claude Code CLI and Codex can't — they follow the machine's current login file, so an account switch mid-stream can label sessions with the previous account, silently. CAIRN_ACCOUNT is the guarantee; detection is not.
- account doctor verifies what's provable (Claude Desktop sessions); it can't audit pure-CLI or Codex history.
- Append-only applies here too: renames change display labels only; nothing merges, nothing deletes.


What to back up

One folder: your vault at ~/.cairn/ (that's cairn.db — your actual memories). Back that up. Everything else is replaceable — the code lives here on GitHub, and reinstalling never touches your vault.


Common commands

orient · note · fetch · wander · query · read (any node in full) · dashboard · doctor · setup · connect / disconnect / capture · account · backfill · sleep (the maintenance cycle — you run it) · edges · book · import

Full reference with every option: QUICKSTART.md.


License

Free for personal and non-commercial use under the Business Source License 1.1 — read it, run it, modify it, self-host it. Commercial or business use requires a commercial license — email licensing@cairnremembers.com. Source-available (not OSI "open source"); each release converts to the permissive MIT License on the Change Date in its LICENSE.

Patent pending — a U.S. provisional patent application covering Cairn's core mechanisms was filed 2026-07-07. Cairn Remembers™ is a trademark of James Wescott Maitland IV.


Knowledge is a trail, not a destination.

常见问题

6 问
答案由本站依据条目字段整理,不引用上游原文
Cairn Remembers 怎么安装?

资料没有给出安装命令,请到官方仓库或文档按说明接入;这类条目多数是生态应用,或尚未发布可安装包。

Cairn Remembers 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式未标注,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Cairn Remembers 收费吗?

本站不代收费用,也没有标注具体价格。是否收费取决于服务本身和背后的接口额度,正式使用前按官方说明确认。

Cairn Remembers 需要 API Key 吗?

资料没有标注鉴权方式,是否需要密钥取决于服务本身,接入前按官方文档确认。

Cairn Remembers 支持哪些客户端?

资料标注支持 Claude Desktop、Claude、Cursor、VS Code、Gemini CLI、Codex;其他客户端只要能配置 MCP Server,也能用同样的命令或地址接入。

Cairn Remembers 能提供哪些能力?

资料显示能力标签包括 记忆。具体工具清单以官方文档为准。

热门专题

按标签挑服务器
全部专题 →

服务器信息以作者仓库与官方文档为准;分类、传输方式与鉴权方式的中文说明为中文整理,最近核验 未标注。