open-context open-context
October 19, 2026 · 6 min read

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.tags as an array — overlapping, multi-attribute labels like idea, backend, or todo.
  • Bubbles are a separate Bubble record with its own id and name; a context links to one via an optional bubbleId, never more than one.
  • search_contexts and recall_context search across tags, content, and source text everywhere — they don't stay inside one bubble.
  • get_bubble is the scoped alternative: it returns only the contexts assigned to that one project.
  • A context needs neither — tags and bubbleId are both optional, so the simplest possible save_context call 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:

ToolWhat it does
create_bubbleStarts a new project workspace with a name and optional description.
get_bubbleFetches a bubble along with every context assigned to it.
update_bubble / delete_bubbleRenames 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.