# Second Brain on Cloudflare: One MCP Memory Layer for Claude, ChatGPT and Cursor

> Second Brain stores memories once in a Cloudflare Worker and serves them to every MCP-compatible AI tool. It is self-hosted, MIT licensed, and the desktop installer avoids the terminal entirely.

**rahilp/second-brain-cloudflare** — One memory layer, every AI tool. Store anything once — recall it in Claude, ChatGPT, Cursor, or any MCP client. Self-hosted on Cloudflare's free tier.

- Repository: https://github.com/rahilp/second-brain-cloudflare
- Website: https://www.thesecondbrain.dev
- Stars: 797 · Forks: 118
- Language: TypeScript
- License: MIT
- Published: 2026-09-10 · Updated: 2026-09-10 · Language: en
- Canonical page: https://hysenlabs.com/projects/rahilp-second-brain-cloudflare

## The problem: every AI client forgets you separately

Claude, ChatGPT, Cursor and Codex each keep their own context. A decision you explained in one tool has to be explained again in the next, because nothing carries over. Second Brain's README states the problem plainly: the tools you use "do not naturally share context", and you "end up repeating the same projects, decisions, and preferences in every app".

The project answers that with a single memory layer that every MCP-compatible client connects to. You store a memory once, in your own Cloudflare account, and any connected tool can recall it. That is a different shape from a note-taking app that happens to have an AI feature. Here the storage is the product, and the AI tools are clients.

Who it is for: people who already run several AI assistants and want them reading from one source, and small teams that want a shared layer without giving up private notes. The README also lists capture routes beyond MCP clients, including a CLI, a browser extension, Obsidian, Notion, calendars, email, iOS Shortcuts and a web dashboard.

## How the Worker, D1, Vectorize and KV fit together

Second Brain runs as a Cloudflare Worker. The README names four backing services: D1 for storage, Vectorize for vectors, Workers AI for embeddings, and KV. Every client talks to that Worker over REST or the Model Context Protocol.

The data flow has three stages. Capture writes a memory from any connected client. Organize then classifies it, checks for duplicates and contradictions, creates relationships, and indexes it for semantic search. Recall takes a natural-language question, retrieves relevant memories, follows connections, and returns source-backed context to the calling tool.

Recall is not keyword matching. The README says the system "retrieves the right context by meaning rather than exact wording", which is why a question phrased differently from the original save can still find the memory. The MCP surface exposes this through named tools rather than free-form endpoints: `remember`, `append`, `update`, `recall`, `list_recent`, `get`, `forget`, `set_status`, `link`, `unlink`, `connections`, `share`, and `get_prompt_capsule`. The last of these returns a deterministic, read-only projection intended for gateways that place stable context before a changing user prompt.

The degradation path is worth noting because it is documented rather than assumed. If Vectorize is unavailable, captures and keyword recall keep working, and the README states that memories remain usable while semantic indexing is restored. Keyword recall is also documented as working for Japanese, Chinese and other scripts written without spaces, and for full-width text.

## Installing Second Brain and saving your first memory

The README pushes the desktop app as the starting point: it builds the brain and connects your AI tools in about two minutes, with no terminal or Cloudflare setup. The download link points at the latest release, and the recent releases list includes `installer-v3.1.0` (Second Brain Desktop 3.1.0) plus earlier 3.0.0 and 1.4.1 installers.

If you prefer the repository path, the package scripts define the setup sequence. Create the D1 database first, then apply the schema. The migrate scripts use a local database by default; the remote variant passes `--remote`.

```bash
npm run db:create
npm run db:migrate
npm run db:migrate:remote
```

The Vectorize index is created separately, and the dimensions matter because they must match the embedding model. The script fixes both values.

```bash
npm run vectors:create
```

For local development, `npm run dev` starts `wrangler dev`. There is also a demo configuration on a separate port, which is useful if you want to look at the dashboard before wiring your own account.

```bash
npm run dev
npm run dev:demo
```

Once a brain exists, the CLI is the shortest path to a first real memory. The README gives this example, which stores a fact and then asks for it in different words.

```bash
brain remember --workspace company "We ship on Thursdays"
brain recall --workspace company "when do we ship?"
```

The `company` value is the wire value for the Shared team layer, not a display name. Without a `workspace` argument, captures follow the member and team defaults, while recall searches everything that person is allowed to see.

## Team Edition: one shared layer, and the limits of v3.0.0

Team Edition adds a Shared layer alongside each person's Personal workspace. The permission model is stated as a table in the README: Personal is readable and editable only by its owner; Shared is readable by everyone on the team but editable or deleted only by the author or an admin. Memories are private by default and enter Shared only when someone deliberately shares them.

Sharing moves one canonical memory rather than copying it. The author stays visible on the record, and only the author or an admin can edit, delete or un-share it. Admins manage members, access, capture defaults and integrations, and the README states they do not gain access to anyone's personal workspace. Existing v2 memories become the owner's private memories during upgrade, so nothing is exposed to a team automatically.

The constraint to plan around is scope. The README says each brain has one shared team in v3.0.0. Optional `team` parameters and a `list_teams` tool exist in the API and MCP layer so multi-team support can ship later without breaking changes, but the dashboard and admin flows do not create or switch between multiple teams yet. If your organisation needs several isolated shared layers today, this release does not provide them. The README is explicit that you can omit the `team` parameter, because the primary team is used automatically.

## Where the design shows strain

Language coverage is the clearest limitation. The README states that the shipped embedding models read English best, and that the desktop app's Settings can switch a brain to a multilingual reading. Keyword recall covers non-spaced scripts, but semantic recall quality is a separate matter from keyword matching, and the README does not publish per-language retrieval figures. If most of your memories are not in English, treat the multilingual setting as something to evaluate yourself rather than a solved problem.

The Cloudflare dependency is structural, not incidental. Storage, vectors, embeddings and credentials all live in your Cloudflare account, which is the point of the self-hosting claim, but it also means the deployment is bound to Cloudflare's service set and its free-tier limits. The README does not document what happens when a free-tier quota is exhausted, and it does not document rollback for a failed deploy, so those are questions to answer before you put real memories in.

The README is also thin on the classification and duplicate-detection logic. It says the system classifies memories, checks for duplicates and contradictions, and creates relationships, but it does not explain the rules behind those decisions. That matters if you plan to trust the shared layer with anything consequential, because you cannot audit a behaviour that is not described.

## Second Brain against plain Obsidian notes

The closest comparison is not another MCP server. It is the Obsidian vault you already keep. The repository ships an Obsidian plugin among its integrations, so the two are not mutually exclusive, but the difference in approach is real.

An Obsidian vault is a folder of files. Search is local, retrieval is lexical or plugin-driven, and no external AI tool can read it unless something bridges the gap. Second Brain inverts that: the memory lives in a Worker, retrieval happens by meaning through Vectorize, and every MCP-compatible client reads the same store. Capture routes include Obsidian, so a vault can feed the brain rather than replace it.

The trade-off runs the other way too. A vault is portable, readable without any service, and unaffected by a provider outage. Second Brain's memories, vectors and credentials live in your Cloudflare account, and the README does not describe an export format in the detail you would need to plan a migration. The dashboard does offer export, but the README does not specify what the exported file contains. If exit cost matters to you, test the export before you accumulate a year of memories.

## Maintenance cost and the MIT licence

The repository is not archived, and the last push was on 2026-09-10. The release cadence visible in the recent releases list is tight: `installer-v3.0.0` on 2026-09-06, then `installer-v3.1.0` on 2026-09-07, one day later. Earlier, `installer-v1.4.1` landed on 2026-08-23. Frequent installer releases mean the desktop app is the part moving fastest.

Upgrade cost depends on which path you took. Desktop users follow installer releases. Worker users run the deploy scripts, and the release tooling distinguishes the Worker from the app: `npm run deploy:worker`, `npm run deploy:app`, `npm run deploy:all`, and `npm run deploy:tag`. There is a `predeploy` guard script and a `check:scope` script, so the project gates deployment rather than pushing straight to production. Schema changes go through `db/schema.sql`, applied with the migrate scripts, and the v2 to v3 upgrade is documented as converting existing memories into the owner's private memories.

The licence is MIT. That permits commercial use, modification and redistribution, and it means you carry no copyleft obligation back to the project. What MIT does not do is give you any warranty or support commitment, and it does not cover Cloudflare's own terms, which govern the account your memories sit in. Self-hosting here means running someone else's code on your own bill, so read the Cloudflare pricing pages for Workers, D1, Vectorize and Workers AI alongside the licence.

## Conclusion

Adopt it if you already pay for or use Cloudflare and want one memory store shared by several AI clients under your own account, and start with the desktop installer rather than the Worker deploy path. Do not adopt it if you need multi-team isolation today, since v3.0.0 supports one shared team per brain, or if your notes are mostly non-English, because the shipped embedding models read English best. Before committing, run `npm run db:migrate:remote` against a throwaway D1 database and confirm the schema applies cleanly, then verify that your Vectorize index was created with 384 dimensions and cosine metric, which is what the package scripts specify.

## FAQ

### Is Second Brain AI free?

The project itself is MIT licensed and the README describes it as self-hosted on Cloudflare's free tier. Your costs are whatever Cloudflare charges for Workers, D1, Vectorize and Workers AI usage beyond the free allowances, which the README does not quantify.

### What is a second brain for AI?

In this project it is a persistent memory store that multiple AI clients read from. The README frames it as one memory system for Claude, ChatGPT, Cursor, Codex and other tools that otherwise do not share context, with recall by meaning rather than exact wording.

### Which AI tools can connect to second-brain-cloudflare?

Any MCP-compatible client, according to the README, which names Claude, ChatGPT, Cursor and Codex. Capture is also possible through the CLI, browser extension, Obsidian, Notion, calendars, email, iOS Shortcuts and the web dashboard.

### How do I install second-brain-cloudflare without a terminal?

Use the desktop installer. The README says it builds your Second Brain and connects your AI tools in about two minutes with no terminal or Cloudflare setup required, and the download link points at the latest release.

### Does second-brain-cloudflare support more than one shared team?

Not in v3.0.0. The README states each brain has one shared team, and that optional team parameters plus a list_teams tool exist so multi-team support can ship later without breaking changes.

## Sources

- [License: MIT](https://github.com/rahilp/second-brain-cloudflare/blob/main/LICENSE)
- [Project website](https://www.thesecondbrain.dev)
- [rahilp/second-brain-cloudflare on GitHub](https://github.com/rahilp/second-brain-cloudflare)
- [README](https://github.com/rahilp/second-brain-cloudflare/blob/main/README.md)
- [Releases](https://github.com/rahilp/second-brain-cloudflare/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/rahilp-second-brain-cloudflare