Dawnmere

MCP文档知识

提供方 未标注

文档知识 stdio · 本地进程 API Key 社区 / 第三方 Claude DesktopClaudeCursorVS Code
查看接入方式

Dawnmere 为 Claude Code、Codex 和 Cursor 在你的 Mac 上提供共享记忆。告诉 Claude Code 或 Codex 一项决策,其他工具就能回忆起来。免费,无需账号。

一句话选型结论

按资料字段整理

Dawnmere 属于文档知识类 MCP 服务器,stdio · 本地进程,API Key,可直接接入 Claude Desktop、Claude、Cursor 等,有可直接执行的安装命令。接入前先确认权限范围;涉及写入、删除或付款的操作,建议先在测试环境验证。

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

工具与能力

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

能力标签

支持客户端

适用场景

记忆

安装与配置

stdio · 本地进程 API Key
客户端在本机拉起子进程,数据不出本机
npx supermemory local

这条命令只是入口,具体启动参数请按官方文档补齐,不要直接照搬到别的服务器。

  1. 1
    准备运行环境

    stdio 服务在本地起进程,需要先装好 Node.js 等运行时,再按安装命令拉取依赖。

  2. 2
    安装服务

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

  3. 3
    写入客户端配置

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

  4. 4
    验证是否可用

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

典型使用场景

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

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

知识库读写

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

内容整理

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

选择建议

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

值得选的地方

  • 有现成的安装命令,不用自己找入口,照着跑就能起服务。
  • 已适配 Claude Desktop、Claude、Cursor,换客户端不用重新研究配置。

先想清楚的地方

  • stdio 方式要求本地装好运行时(如 Node.js),换机器要重新装一遍。
  • 使用前要准备好API Key对应的凭据,并按最小权限配置。
  • 资料没标注工具数量,实际能力要装好后确认。
  • 版本更新与行为细节以官方仓库为准。

更适合

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

不太适合

  • 完全不想在本地装环境的人。
  • 不方便管理密钥或第三方授权的人。
  • 需要厂商级 SLA 和技术支持的生产环境。

同类对比

6 个同类
同分类里挑最接近的几条,字段以各自详情页为准
MCP 服务器工具数传输方式部署方式安装命令最后核验
Dawnmere当前 未标注 stdio · 本地进程 本地部署 有 2026-11-20
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

服务器档案

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

详细介绍

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

English · 简体中文 · 日本語

Tell one AI. They all know.

One memory on your Mac, shared by Claude Code, Codex and Cursor.

dawnmere.app

curl -fsSL https://dawnmere.app/install | sh

Needs: a Mac with Apple silicon, macOS 14 or later, 1 GB of free disk space, and Node.js 18 or later. Free, no
account.

Status: early beta (0.2). MIT client, source-available engine (FSL, becomes MIT after two years).
Made by LF Labs.

What it does

You tell Claude Code or Codex something worth keeping ("remember that we deploy on Fridays"). Dawnmere saves it
once, on your Mac. Ask the other one in similar words and it brings it up, and a new Cursor chat in that project
shows it for the next day (the 5 newest notes). Switch from Claude Code to Codex when you hit a limit, and Codex can recall that you
deploy on Fridays and use pnpm.```mermaid
flowchart LR
CC[Claude Code] <--> C
CX[Codex] <--> C
CU[Cursor] <--> C
C["dawnmere-connector<br/>(MCP, one per app)"] <--> D[("Dawnmere on your Mac<br/>one SQLite file, local search")]


How each app saves and recalls:

| App | Recalls | Saves |
| --- | --- | --- |
| **Claude Code** | into each prompt, and at the start of a session | on its own after a session goes quiet (if you chose a model), when you type &quot;remember that ...&quot;, or when the model calls `remember` |
| **Codex** | into each prompt | when you type &quot;remember that ...&quot;, or when the model calls `remember` |
| **Cursor** | at the start of each chat | when the model calls `remember` |

What you type (&quot;remember that ...&quot;) reaches every app once the reply finishes (from Codex, at your next prompt there).
A note a model saves with `remember` on its own is found by searching, and reaches other apps&#x27; prompts only after you confirm it (`dawnmere held`).
Notes about your own health, family, money or legal matters stay personal.

Every app also gets four tools through MCP: `recall`, `remember`, `forget` and `access_status`.

## Why Dawnmere

- **One memory, not one per app.** The apps share a single store, so a fact saved from Claude Code is the same
  fact Cursor recalls.
- **Stored only on your Mac.** The memory is one SQLite file in your Library folder. Search runs on your Mac with
  small local models. There is no account, and no memory, prompt or file of yours is ever sent to LF Labs: only
  anonymous usage counts, once a day, which you can see and turn off (TELEMETRY.md).
- **Your own model does the reading.** Automatic saving uses your Claude plan through Claude Code, or your own
  Anthropic API key. You can also run with no model at all.
- **Each app sees what you allow.** Cursor starts with work notes only, and a new app sees work notes only.
  Claude Code&#x27;s and Claude Desktop&#x27;s memory tools, and any app that only names itself, see work notes only for now.
  Claude Code&#x27;s automatic recall in your prompts still sees everything. Widening an app&#x27;s access needs you at a
  Terminal: run `dawnmere access cursor everything`, type the app&#x27;s name back and click Allow in a macOS dialog.
  Asking for it in a chat only gets you that command.
- **Saved text is screened.** Text that looks like an API key or token is refused. An app&#x27;s save that would run
  downloaded code, delete files, keep something from you or tries to override your assistant&#x27;s instructions is refused. Notes
  an app saves on its own are kept for search, labelled, and reach other apps&#x27; prompts only after you confirm them
  (`dawnmere held`). Recalled notes reach the app labelled &quot;notes, not
  instructions&quot;.
- **Setup can be undone.** It asks before changing anything, backs up every file it touches, can show its plan with
  `--dry-run`, and `dawnmere uninstall` puts the files back.

## How it compares

Sharing one memory between coding agents is not new: claude-mem and Supermemory do it too, and both cover more
agents than Dawnmere. The main difference is where the memory is kept. As each project&#x27;s own docs describe it on
8 November 2026:

| | Where the memory is kept | Shared by Claude Code, Codex and Cursor |
| --- | --- | --- |
| **Dawnmere** | one SQLite file on your Mac; search runs on your Mac | yes, by default; each app sees what you allow |
| claude-mem | `~/.claude-mem` on your machine | supports all three and more; other agents&#x27; memories at session start are opt-in |
| Supermemory | hosted by default, or on your machine with `npx supermemory local` (the two do not share memories) | yes, plus OpenCode and others |
| Mem0 MCP | hosted by Mem0, with a Mem0 account; nothing runs on your machine | yes, through that account |
| Built-in memory | CLAUDE.md and auto memory in your projects and home folder; AGENTS.md in your repos | CLAUDE.md and auto memory are Claude Code&#x27;s own; AGENTS.md is read by Codex, Cursor and (when a repo has no CLAUDE.md) Claude Code, but holds instructions you write, not what the apps learn |

If you use only one agent, its built-in memory may be all you need. Dawnmere starts from it: setup can import the
notes Claude Code already keeps.

**Why not CLAUDE.md or AGENTS.md?** Use them for rules you write on purpose; Dawnmere doesn&#x27;t replace them. Dawnmere
is for the things you say in passing and don&#x27;t want to copy into three files. Recall is selective, so an app gets
the memories that match the prompt, not the whole file every time.

## Install```bash
curl -fsSL https://dawnmere.app/install | sh

Prefer Homebrew?```bash
brew install lf-labs-inc/tap/dawnmere
dawnmere setup


Homebrew brings Node.js with it. Update with `brew upgrade lf-labs-inc/tap/dawnmere`, then run `dawnmere setup`
again. To remove it, run `dawnmere uninstall` before `brew uninstall dawnmere`.

In Claude Code? Two commands, then `/dawnmere:setup`. This route needs git: on a Mac without Apple&#x27;s Command Line
Tools, run `xcode-select --install` first, or use the install line above.```text
/plugin marketplace add LF-Labs-Inc/dawnmere
/plugin install dawnmere@dawnmere

Then run /dawnmere:setup in Claude Code. It runs the install line above (you approve each command), then has you
run dawnmere setup in a Terminal window, or runs it with the defaults if you say so. Until then, each new Claude Code
session says Dawnmere isn't set up yet, and nothing else happens.

That address serves install.sh from the latest
GitHub release. The script:

  1. stops unless this is a Mac with Apple silicon and macOS 14 or later;
  2. downloads uv 0.12.5 if you do not have a recent one, and the dawnmere and
    engine packages from the release;
  3. checks those files against sha256 values written into the script, and installs nothing if one differs;
  4. has uv install them with Python 3.12 and the engine's Python packages from PyPI, each pinned to an exact version
    and checked against its sha256;
  5. adds one marked line to ~/.zprofile so new Terminal windows find dawnmere, unless they already do, and says so;
  6. starts dawnmere setup, which asks before it changes anything.

Without a terminal to ask in (in a script, say), the installer installs the programs but does not run setup, so none
of your apps is changed. Afterwards run dawnmere setup in a Terminal window, or dawnmere setup --yes to take the
defaults.

Read the installer first```bash

curl -fsSL https://dawnmere.app/install -o install.sh
less install.sh
sh install.sh


The `install.sh` in this repo is the template: it refuses to run until a release fills in the version and checksums.

Your apps do not depend on your PATH: the hooks setup writes call Dawnmere by its full path. `dawnmere uninstall`
takes the installer&#x27;s `~/.zprofile` line out again.

**Updating:** `dawnmere update`, which checks each file against the release&#x27;s `SHA256SUMS`. Running the install line
again also works.

## What setup does

`dawnmere setup` first shows what it will do and asks you to continue. Then it asks what your AI apps should call
you, whether to use your Claude plan for background reading (or an Anthropic API key, kept in your Keychain), whether
Cursor may see your personal notes (no, unless you say yes), and whether to import the notes Claude Code already keeps
in `~/.claude/projects/*/memory` now and trust them as yours (one macOS dialog asks; if you don&#x27;t, they are kept for
search until you confirm them).

Then it shows each step as it runs:

| Step | What happens |
| --- | --- |
| Claude Code | checks that `claude` is there and logged in |
| Search models | downloads the search models (about 310 MB) and checks each file&#x27;s size and sha256 |
| Memory service | starts a background service (a LaunchAgent) that keeps search fast |
| Your apps | connects Claude Code, Codex, Cursor and the other apps listed below, if they are installed |
| Your notes | imports your Claude Code notes |
| Self-check | saves a test memory, finds it the way Codex and Cursor would, then deletes it |

It ends with &quot;Dawnmere is on.&quot; Every file setup changes is copied first, next to it
(`.lflabs-backup-`), and recorded so `dawnmere uninstall` can put it back. You can run setup again at any
time, for example to add a model later.

- `dawnmere setup --dry-run` prints every change it would make and makes none.
- `dawnmere setup --backend none` runs without a model: recall and remember work, automatic saving is off.

## Your apps

- **Claude Code** (2.1.301 or later): setup installs the `dawnmere` plugin from this repo, at the release you
  installed, which adds the tools and four hooks. If the plugin cannot be installed (for example, git is missing), it adds the same tools with
  `claude mcp add` and the hooks to `~/.claude/settings.json`.
- **Codex**: adds `[mcp_servers.dawnmere]` to `~/.codex/config.toml` and a prompt hook to `~/.codex/hooks.json`.
  Type `/hooks` once in Codex to trust the hook.
- **Cursor**: adds `dawnmere` to `~/.cursor/mcp.json` and a session-start hook to `~/.cursor/hooks.json`, then
  restart Cursor. Cursor sees work notes only until you run `dawnmere access cursor everything`;
  `dawnmere access cursor work` takes that back. After widening, its memory tools see everything, but the notes
  shown at the start of a chat stay work notes only. The same holds for Codex: its prompts keep getting work notes
  only.
- **Windsurf, Gemini CLI, VS Code (Copilot), Qwen Code, Kimi Code, Qoder CLI, iFlow CLI and Cline CLI**: when setup
  finds one, it adds `dawnmere` to its MCP file (`~/.codeium/windsurf/mcp_config.json`,
  `~/.gemini/settings.json`, `~/Library/Application Support/Code/User/mcp.json`, `~/.qwen/settings.json`,
  `~/.kimi-code/mcp.json`, `~/.qoder/settings.json`, `~/.iflow/settings.json`,
  `~/.cline/data/settings/cline_mcp_settings.json`); restart the app. They get the tools and no hook, so they recall
  when they call the tool, and they see work notes only.
- **Claude Desktop and other MCP apps**: setup does not connect them. For Claude Desktop, open
  `dawnmere-connector.mcpb` from the latest release, or add
  this to `~/Library/Application Support/Claude/claude_desktop_config.json`:```json
  {
    &quot;mcpServers&quot;: {
      &quot;dawnmere&quot;: {
        &quot;command&quot;: &quot;npx&quot;,
        &quot;args&quot;: [&quot;-y&quot;, &quot;dawnmere-connector@0.1.2&quot;]
      }
    }
  }
  ```

  The connector&#x27;s README has the lines for Windsurf, Gemini CLI and others.

Before 0.1.10 the entry and the plugin were called `lflabs-memory` (plugin `lflabs-memory@lflabs`). Setup, the install
line and `dawnmere update` rename them to `dawnmere` in every app, so none lists memory twice; `dawnmere uninstall`
removes either name.

## Commands

| Command | What it does |
| --- | --- |
| `dawnmere setup` | connect your apps to one memory on this Mac |
| `dawnmere doctor` | check that everything works, Node.js included, one line per check, with what to do about each problem |
| `dawnmere export` | save your memory to `~/Downloads/dawnmere-export-.json` (`--format md` for Markdown) |
| `dawnmere import FILE` | add the memories from an export file, skipping any already there; they count as app saves until you confirm them in one macOS dialog |
| `dawnmere access APP [LEVEL]` | show what an app may see, or change it: `everything`, `work` or `nothing` (`nothing-personal` works like `work`; only Cursor and Codex can be widened from here) |
| `dawnmere update` | install the newest release, checked against its checksums |
| `dawnmere uninstall` | remove everything setup added |
| `dawnmere held` | app saves kept out of your prompts until you confirm them, with the line that confirms each |
| `dawnmere trust -- ID...` | make memories your own words, after you click Allow in a macOS dialog |
| `dawnmere search QUERY` | search your memory |
| `dawnmere add TEXT` | save one memory; a macOS dialog asks whether these are your own words, and until you click Allow it is held like an app save (`dawnmere held`) |
| `dawnmere forget ID` | delete a memory for good |
| `dawnmere restore ID` | bring back a memory an app forgot in the last day |

`dawnmere doctor --report` prints counts only (no memory text, names or paths), so it is safe to paste into an issue.

## Forgetting

When you forget a memory yourself (type &quot;forget memory 12&quot; in Claude Code or Codex, or run `dawnmere forget 12`
in Terminal), its text, search entries, older versions and the facts drawn from it are deleted from the memory file
and its backups when the reply finishes (typed in Codex, at your next prompt there). It cannot be brought back. If background reading is on, the words are kept for up to 24 hours so the
background job can find other notes that mention them, then erased. When an app calls `forget` on its own, the memory
is hidden at once and deleted for good after 24 hours; until then `dawnmere restore 12` brings it back, with everything that forget hid. An
app&#x27;s forget never takes your own copies of the note: they stay, and the reply names them. A
fingerprint with no words stays, so the same thing is not saved again from an old chat. `dawnmere uninstall` can also
delete the whole memory (it asks first).

Claude Code also keeps its own memory files (under `~/.claude/projects/`). Dawnmere never deletes them itself: when
a forgotten note came from one, the reply names the file and says to delete it there too. In Claude Code, Claude
usually does that for you; from another app or Terminal, remove it yourself.

## What leaves your Mac

Your memory is never uploaded to us, and no memory, prompt or file of yours is sent to LF Labs. What leaves your Mac:

- **Usage counts** (on for a new install; an install from before 0.2.0 is asked first): at most once a day, to LF
  Labs, a random id that changes every month, your versions, which AI apps are connected and a few counts as ranges.
  Never what a memory, prompt or file says. `dawnmere telemetry show` prints it, `dawnmere telemetry off` stops it
  (TELEMETRY.md).
- **Background reading**, if you chose a model, sends your own provider (your Claude plan through Claude Code, or the
  Anthropic API with your key) your Claude Code conversations, after every 6 of your messages and when a session goes
  quiet, with up to 8 related memories, which can include ones saved from Codex or Cursor. With
  `dawnmere setup --codex-sessions`, it also reads Codex&#x27;s own session files (`~/.codex/sessions`) and sends those
  conversations the same way; with that setting off, typing a handoff phrase such as &quot;hand off&quot; in Codex still sends
  that Codex conversation. It also sends memories
  waiting to be filed, a prompt not in English typed in Claude Code or Codex (to search it in English), and for up to 24 hours the
  words of something you forgot. Once a week, and once soon after setup, it also sends memories that say nearly the
  same thing, memories that read as out of date and dated status notes, each with a few related memories, to merge,
  rewrite or retire them. At most 200 calls a day in all; with no model, none of this is sent.
- **GitHub**: releases and updates, and, if GitHub&#x27;s `gh` is installed and logged in, the open pull requests of the
  repo you are working in and the state of its recent ones. They are for the short &quot;Where you left off&quot; block at the
  start of a new chat (open pull requests and what waits on you, running jobs, uncommitted work and the last session&#x27;s
  notes), which goes into that app&#x27;s prompt. Logging out of `gh` stops the GitHub part.
- **Downloads**: uv, Python and the engine&#x27;s Python packages (from GitHub and PyPI); the search models and the Claude
  Code plugin (from this repo&#x27;s releases and repo); the connector (from npm: downloaded once, and npm is checked when an app starts it). `dawnmere update`
  asks GitHub for the newest release.
- **Setup&#x27;s check of your model**: one short test call to Claude Code or the Anthropic API.
- **The install line**: dawnmere.app counts each fetch of the install script (the tool that fetched it, the referring
  site and the country; no IP address is kept), then sends it on to GitHub. The site&#x27;s own counting is on its
  privacy page.

Each app decides for itself what it sends to its own model, including what it recalls from memory.

## Uninstall```bash
dawnmere uninstall

It stops and removes the background service, takes memory out of Claude Code, Codex and Cursor (putting each file
back as it was, or removing only the Dawnmere entries if you changed the file since), removes the API key from your
Keychain, and removes the dawnmere and engine programs. It always asks before deleting your memory, which cannot be
brought back; say no, or use --keep-data, to keep it. It deletes the backups setup made. If a file could not be put
back as it was, its copy from before setup stays next to it and uninstall lists it. It also takes out the
~/.zprofile line the installer added. uv and the Python it downloaded stay on your Mac; uninstall prints how to
remove them.

Who makes it, and the LF Labs names

Dawnmere is made by LF Labs (the LF-Labs-Inc organization on GitHub). Inside, the
programs use the LF Labs name, so these are all Dawnmere:

What Where
your memory, settings and models ~/Library/Application Support/LF Labs/Memory/ (only you can read it)
the service's log ~/Library/Logs/LF Labs/memory.log
the background service ~/Library/LaunchAgents/com.lflabs.memory.plist
the programs ~/.local/share/uv/tools/lflabs-memory-cli/, linked as ~/.local/bin/dawnmere and lflabs-memory (the engine's command, which the hooks run)
an Anthropic API key, if you gave one your login Keychain, as "LF Labs Memory"

Limits

  • Mac only, Apple silicon, macOS 14 or later. The engine's ONNX runtime has no Intel Mac build, and there is no
    Linux or Windows version.
  • One Mac. There is no sync between machines and no team memory.
  • Chinese and Japanese recall matches words. A note saved in Chinese or Japanese reaches your prompts when you ask
    with some of the same words. A question worded differently is often missed; your app can still search for it. With
    a model set up, a Chinese or Japanese question is also searched in English, one small model call each. A typed save
    needs "remember that ..." (in Chinese "记住:...", in Japanese "覚えておいて:..."). Other languages are found much
    less reliably for now.
  • Saving is strongest from Claude Code. In Codex, say "remember that ..."; in Cursor, the model has to call
    remember. Codex's own session files are read only if you run dawnmere setup --codex-sessions, or for one
    conversation when you type a handoff phrase in it.
  • Screening is automatic and can miss things. Review what your apps save with dawnmere export.
  • Early beta. Releases are cut by hand and come often; read the
    release notes before updating.

License

The installer, the dawnmere command, the Claude Code plugin and the connector in this repo are MIT
(LICENSE). The engine is source-available under the
Functional Source License 1.1, MIT future license
(FSL-1.1-MIT): each version becomes MIT two years after its release. The search models keep their own licenses
(dawnmere doctor --licenses, and THIRD_PARTY.md).

Related

memory-bench is an open benchmark for assistant memory, built by the
same people. It scores Dawnmere's released versions by the share of cases answered right, with every leak rate shown
beside it; the maintainers' other row there is a related system, and the benchmark says so.

Found a bug? Open an issue with the output of
dawnmere doctor --report. Security problems go to SECURITY.md.

常见问题

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

在客户端按下面的安装命令接入:npx supermemory local。装完在客户端配置里引用同一个包或端点。

Dawnmere 怎么在 Claude Desktop、Claude、Cursor 里配置?

它的传输方式是stdio · 本地进程,在客户端的 MCP 配置里填好启动命令和参数,保存后完全退出客户端再打开,配置才会生效。

Dawnmere 收费吗?

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

Dawnmere 需要 API Key 吗?

资料标注需要API Key认证,使用前准备好对应凭据,并按最小权限配置。

Dawnmere 支持哪些客户端?

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

Dawnmere 能提供哪些能力?

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

Dawnmere 需要什么运行环境?

属于本地进程,需要在本机装好运行环境。

Dawnmere 是本地还是远程?

它是本地进程(stdio),由客户端在本机拉起。传输方式为stdio · 本地进程。

热门专题

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

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