Tags vs. Bubbles: Two Ways to Organize open-context Memory
In open-context's MCP memory, a tag is a free-form label stored on a single saved context, and a bubble is a named project workspace that groups many contexts together. Tags answer "what kind of note is this?" — a context can carry several at once. Bubbles answer "which project does this belong to?" — a context links to at most one. Both are optional, both ship as MCP tools Claude can call directly, and a single saved memory can use both at the same time.
Key takeaways
- Tags live on
ContextEntry.tagsas an array — overlapping, multi-attribute labels likeidea,backend, ortodo. - Bubbles are a separate
Bubblerecord with its ownidandname; a context links to one via an optionalbubbleId, never more than one. search_contextsandrecall_contextsearch across tags, content, and source text everywhere — they don't stay inside one bubble.get_bubbleis the scoped alternative: it returns only the contexts assigned to that one project.- A context needs neither — tags and
bubbleIdare both optional, so the simplest possiblesave_contextcall still works.
Two different questions about the same memory
open-context's MCP server gives Claude a real, persistent memory through six context tools and five bubble tools. The two systems exist because they answer different questions about the same saved note. A tag describes what a piece of context is — a preference, a decision, a fact about you. A bubble describes where it lives — which client, codebase, or area of your life it belongs to. Conflating the two forces an awkward choice: either stuff project names into tags and lose multi-attribute search, or create a tag hierarchy that tries to act like folders and fights the data model the whole way.
Tags: flat, overlapping labels on one entry
A tag is just a string in the tags array on a ContextEntry. There's no
separate tag registry — a tag exists the moment you save a context with it, and disappears the
moment nothing references it anymore.
How tags work under the hood
save_context and update_context both accept an optional tags
array. list_contexts can filter down to a single tag, and search_contexts
matches keywords against content, tags, and source together, requiring every search term to
match — the same case-insensitive substring search every one of open-context's 15 database
backends has to implement identically, per the
conformance suite that
governs them.
When a tag is the right tool
Reach for a tag when the attribute is one a context might share with items from totally different
projects. "Everything I've marked as a preference" or "everything tagged
security" cuts across bubbles by design — a security note about a client's API and a
security note about your home network both deserve the same tag, even though they'll never belong
to the same project.
Bubbles: named project workspaces that group many entries
A bubble is its own record — an id, a name, an optional
description, and a live contextCount — not an attribute hanging off a
context. A context entry points at one bubble through an optional bubbleId field, or
points at none.
How bubbles work under the hood
Claude can manage bubbles entirely on its own, mid-conversation:
| Tool | What it does |
|---|---|
create_bubble | Starts a new project workspace with a name and optional description. |
get_bubble | Fetches a bubble along with every context assigned to it. |
update_bubble / delete_bubble | Renames a bubble, or removes it (contexts are unassigned, not deleted, unless you pass deleteContexts: true). |
save_context and update_context take the same optional
bubbleId parameter tags use for tags, so "remember this for the Acme
project" can land a context directly inside the right bubble the moment it's saved.
When a bubble is the right tool
Reach for a bubble when you want one project's memory to be retrievable as a unit — everything
about a client engagement, a codebase, or a long-running personal project, fetched together with
get_bubble instead of reconstructed from a dozen separate searches. Bubbles are the
closer analog to Anthropic's own Claude Projects,
just one layer down, at the MCP memory level instead of the claude.ai conversation level.
Using both on the same context
Because tags and bubbleId are independent fields, nothing stops a single
saved context from using both. A note can carry the tags ["idea", "backend"] and
also belong to the "Acme Redesign" bubble — tags narrow it by attribute inside the project, the
bubble scopes it to the project in the first place. get_bubble returns the whole
project; a tag filter inside that result narrows further to one kind of note within it.
You don't have to pick one system up front, either. Both fields are optional on every context
tool, so the plainest possible save_context call — no tags, no bubble — still works
exactly as it did before bubbles existed. Add structure later, only where it earns its keep.
What the research says about flat labels vs. grouped folders
This isn't a new tradeoff — it's the same one studied for decades in personal file management. A controlled doctoral study out of Drexel University found that using tags alone and using folders alone produced similar file-organization time, re-finding time, and answer accuracy; combining both actually took longer to organize without improving how fast people found things again (Drexel University, doctoral dissertation on hierarchical folders and tags for file management). Bubbles are open-context's version of the folder — a single, mutually exclusive container — and tags are the faceted, overlapping label. Neither one reliably beats the other at "can I find this again," which is exactly why open-context doesn't force a choice: it offers both, and lets you use either, neither, or both depending on what you're actually trying to retrieve later.
Give Claude memory that's organized your way, not forced into one shape.
Get started with open-context →FAQ
What's the difference between a tag and a bubble in open-context?
A tag is a free-form label stored directly on a context entry's tags array, and one entry can carry several. A bubble is a separate named record — a project workspace — that a context links to through a single optional bubbleId field.
Can one saved context have both tags and a bubble?
Yes. Tags and bubbleId are independent fields on the same ContextEntry. A note can carry the tags ["idea", "backend"] and also belong to the "Acme Redesign" bubble at the same time.
Do I have to use bubbles or tags at all?
No. Both are optional. save_context works with no tags and no bubbleId, and behaves exactly as it did before bubbles existed — you can add either one later without migrating anything.
Does search_contexts search inside a specific bubble?
search_contexts and recall_context search across every saved context regardless of bubble. To scope a search to one project, call get_bubble with that bubble's ID, which returns only the contexts assigned to it.
Can Claude decide on its own whether to use a tag or a bubble?
Yes. Both are exposed as MCP tools, so Claude can call save_context with tags, create_bubble for a new project, or both in the same conversation based on what you ask it to remember.