August 23, 2026 · 6 min read

Organize Claude's MCP Memory by Project With Bubbles

Q: Do I have to create bubbles to use open-context's MCP memory?

No. bubbleId is optional on every context entry. save_context and recall_context work exactly as before if you never create a bubble — bubbles are an opt-in way to organize memory once you have enough of it that a flat list gets hard to search.

Q: Does deleting a bubble delete my saved contexts?

No, not by default. delete_bubble unassigns the contexts inside it — they remain in your store with bubbleId cleared. Pass deleteContexts: true to delete the bubble's contexts along with it.

Q: Can Claude create and manage bubbles on its own?

Yes. The MCP server exposes create_bubble, list_bubbles, get_bubble, update_bubble, and delete_bubble as tools, so Claude Code or Claude Desktop can organize your memory into project workspaces mid-conversation without you touching the web UI.

A bubble in open-context is a named project workspace that groups related MCP context entries together — one bubble per client, codebase, or area of your life — so Claude recalls memory scoped to the project you're actually working on instead of searching everything you've ever saved. You create bubbles from the web UI, the REST API, or Claude itself, since bubble management ships as five MCP tools.

Key takeaways

Bubbles are project workspaces for open-context's MCP context store — a way to group saved memories instead of keeping one flat, growing list.
Claude can create and manage bubbles directly with the create_bubble, list_bubbles, get_bubble, update_bubble, and delete_bubble MCP tools, mid-conversation.
save_context and update_context both accept an optional bubbleId, so a memory can be scoped to a project the moment it's saved.
Deleting a bubble unassigns its contexts by default — nothing is lost unless you explicitly pass deleteContexts: true.
Bubbles are opt-in and stored in whichever backend you use, from the default JSON file to any of open-context's 15 supported databases, and travel with db migrate.

One memory pool gets messy fast

open-context's MCP server gives Claude a real memory: save_context to store something, recall_context or search_contexts to pull it back up in a future conversation. That works well for the first few dozen entries. Past that, a flat list of memories starts to blur together — a note about a client's API conventions sits next to a reminder about your home network setup, and a keyword search for "config" returns both.

Bubbles exist to fix that without changing how saving and recalling context works. Every context entry already carries an optional source and a list of tags; a bubble is a third, higher-level grouping — a project the entry belongs to, not just a keyword attached to it.

What a bubble actually is

A bubble is a small record: an id, a name, an optional description, a live contextCount, and timestamps. Each context entry gets an optional bubbleId field linking it to one bubble. Nothing is required — a context entry with no bubbleId behaves exactly as it always did, which is why bubbles are opt-in rather than a breaking change to how the MCP store works.

Creating and using bubbles

From the web UI

The dashboard has a dedicated Bubbles page at /bubbles in the sidebar nav. Create a bubble with a name and optional description, then assign existing contexts to it or view everything already grouped inside — the same page other tools in the UI, like the Preferences editor and Conversations viewer, are built around.

From Claude, via MCP tools

Because bubble management is exposed as MCP tools, Claude can organize your memory on its own, without you opening the UI:

Tool	What it does
`create_bubble`	Create a new project workspace with a name and optional description.
`list_bubbles`	List every bubble and how many contexts each one holds.
`get_bubble`	Fetch a bubble along with all of its contexts.
`update_bubble`	Rename a bubble or change its description.
`delete_bubble`	Delete a bubble; unassigns its contexts unless `deleteContexts` is set.

save_context and update_context both take an optional bubbleId parameter too, so a memory can be scoped to a project the moment Claude saves it — say "remember this for the Acme project" and, once you've told Claude which bubble is Acme, it can pass that ID straight through.

Via the REST API

The same operations are available over HTTP, which is what the web UI itself calls:

GET    /api/bubbles              # list bubbles with context counts
POST   /api/bubbles              # create a bubble
GET    /api/bubbles/:id          # get a bubble
GET    /api/bubbles/:id/contexts # list a bubble's contexts
PUT    /api/bubbles/:id          # rename / re-describe a bubble
DELETE /api/bubbles/:id          # delete a bubble

Bubbles vs. Claude Projects

Anthropic's own Claude Projects feature does something related on claude.ai itself: it groups chat history and uploaded documents into a shared 200K-token context window. Bubbles operate one layer below that, at the MCP memory level, and solve a different problem. Claude Projects organizes conversations and files inside claude.ai; Bubbles organizes the persistent memories Claude saves and recalls across Claude Code, Claude Desktop, and any other MCP client — including ones that have no concept of a "project" at all. The two are complementary: you can still use Claude Projects for document context on claude.ai while your MCP memory, grouped into bubbles, follows you into Claude Code sessions that Projects doesn't reach.

Deleting a bubble doesn't delete your memory — unless you ask

Grouping memory by project only feels safe if reorganizing it isn't destructive. delete_bubble defaults to unassigning contexts, not deleting them: the bubble disappears, and every context that pointed at it just has its bubbleId cleared, going back to the flat, ungrouped list. If you genuinely want the contexts gone too — a finished, throwaway project, for example — pass deleteContexts: true and both the bubble and its contents are removed together.

Give Claude project-scoped memory in a few minutes.

Get started with open-context →

FAQ

What is a "bubble" in open-context?

A bubble is a named project workspace in open-context's MCP context store. It groups related saved memories together — for example one bubble per client, codebase, or area of your life — so Claude can recall context scoped to a specific project instead of everything you've ever saved.

Do I have to create bubbles to use open-context's MCP memory?

No. bubbleId is optional on every context entry. save_context and recall_context work exactly as before if you never create a bubble — bubbles are an opt-in way to organize memory once you have enough of it that a flat list gets hard to search.

Does deleting a bubble delete my saved contexts?

No, not by default. delete_bubble unassigns the contexts inside it — they remain in your store with bubbleId cleared. Pass deleteContexts: true to delete the bubble's contexts along with it.

Can Claude create and manage bubbles on its own?

Yes. The MCP server exposes create_bubble, list_bubbles, get_bubble, update_bubble, and delete_bubble as tools, so Claude Code or Claude Desktop can organize your memory into project workspaces mid-conversation without you touching the web UI.

Do bubbles work with every open-context database backend?

Yes. Bubbles are stored alongside context entries in whichever backend you use — the default JSON file or any of the 15 supported databases — and are included when you run opencontext db migrate to move to a different backend.