Skip to main content
Glama
LewenW

memory-bridge

by LewenW
OverviewSchemaRelated ServersScoreDiscussions
Python
Local

memory-bridge

Cross-project memory sharing for Claude Code and Cowork. Stop teaching Claude the same thing twice.

Claude's memory is project-isolated. Teach it "use pnpm" in project A, repeat yourself in project B. memory-bridge adds a shared layer — namespaces — between global and project scope. Solves #36561 and #39195.

Global      ~/.claude/CLAUDE.md                      (Claude native)
Namespace   ~/.claude/shared-memory/<ns>/*.md         (memory-bridge)
Project     ~/.claude/projects/<proj>/memory/*.md     (Claude native)

Install

Claude Code (one command)

claude mcp add memory-bridge -- uvx claude-memory-bridge

Done. No clone, no config files. Requires uv (curl -LsSf https://astral.sh/uv/install.sh | sh).

Cowork Desktop

Add to your config file (Settings > Developer > Edit Config):

{
  "mcpServers": {
    "memory-bridge": {
      "command": "uvx",
      "args": ["claude-memory-bridge"]
    }
  }
}

Requires uv. Then restart Cowork.

Manual install (advanced)

git clone https://github.com/LewenW/claude-memory-bridge.git
cd claude-memory-bridge
pip install -e .
python scripts/install.py

Related MCP server: Central Brain

Tools

Tool

What it does

search_memories

Search across all projects and shared namespaces

promote_memory

Move a memory from project to shared namespace

sync_memory

Copy a memory to specific projects

list_shared_memories

Browse namespace contents

manage_namespaces

Create, delete, subscribe, unsubscribe

get_memory_health

Find duplicates, stale entries, broken indexes

Quick start

In a Claude Code or Cowork session:

# Create a namespace
"Create a shared namespace called 'frontend' for React conventions"

# Share knowledge
"Promote 'Use pnpm, not npm' to the frontend namespace"

# Subscribe a project
"Subscribe my dashboard project to the frontend namespace"

# Search across everything
"Search memories for pnpm"

Client compatibility

Client

Auto

Manual

Claude Code (CLI)

Yes

Yes

Cowork — Code mode

Yes

Yes

Cowork — Cowork mode

:(

Yes — mention "memory-bridge" or tool name

Cowork mode loads the MCP tools but doesn't inject server instructions, so Claude won't use them unprompted. Workaround: say "use search_memories" or mention "memory-bridge". This will work automatically once Cowork supports MCP instructions.

How it works

  • Reads/writes Claude's native ~/.claude/projects/*/memory/*.md directly — no database

  • Shared memories in ~/.claude/shared-memory/<namespace>/

  • registry.json tracks namespace subscriptions

  • Word-boundary TF-IDF search scoring

  • Trigram Jaccard similarity for duplicate detection (threshold 0.45)

Uninstall

claude mcp remove memory-bridge    # Claude Code

Or remove the memory-bridge entry from your Cowork config file.

Project structure

src/memory_bridge/
├── server.py              MCP server, 6 tools
├── config.py              Paths + constants
├── models.py              Dataclasses
├── store/
│   ├── base.py            MemoryStore interface
│   └── filesystem.py      File I/O + keyword search
└── engine/
    ├── retriever.py       Cross-project search
    ├── promoter.py        Project → namespace promotion
    ├── namespace_manager.py   Namespace CRUD
    └── health_analyzer.py     Dedup + staleness + index audit

License

MIT

Available Tools

6 tools
get_memory_healthA

Analyze saved memory health across all projects and sessions. Reports duplicates, stale memories, index integrity, and actionable suggestions.

Args: fix_indexes: If true, rebuild all MEMORY.md indexes from actual files on disk.

ParametersJSON Schema
NameRequiredDescriptionDefault
fix_indexesNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the burden of disclosing behavior. It explains the effect of fix_indexes (rebuilding indexes), indicating a potentially destructive action. However, it does not mention other aspects like return format or permissions, though the output schema likely covers that.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is exceptionally concise, with two sentences for purpose and one for parameter details. Information is front-loaded and every word adds value, making it efficient for an AI agent to parse.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness5/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the simple single-boolean-parameter tool and presence of an output schema, the description is complete. It explains purpose, reports, and parameter behavior, adequately covering the agent's needs.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters5/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The parameter fix_indexes has no schema description (0% coverage), but the description adds clear semantic meaning: 'If true, rebuild all MEMORY.md indexes from actual files on disk.' This goes beyond the schema's type and default, telling the agent exactly what invoking the parameter does.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool analyzes saved memory health across all projects and sessions, listing specific outputs like duplicates, stale memories, index integrity, and suggestions. This distinguishes it from sibling tools such as list_shared_memories or search_memories, which focus on listing or searching rather than analysis.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description does not provide explicit guidance on when to use this tool versus alternatives, nor does it mention prerequisites or when not to use it. The purpose is implied but lacks direct instructions for an AI agent.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list_shared_memoriesA

List memories saved across sessions in shared namespaces. If namespace is omitted, shows all namespaces and their summaries.

Args: namespace: A specific namespace to list memories from.

ParametersJSON Schema
NameRequiredDescriptionDefault
namespaceNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.8/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must fully disclose behavioral traits. It indicates a read operation (list) and default summaries, but lacks explicit statements about non-destructive nature, error handling, or rate limits. This is insufficient for a tool with no annotation support.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is two sentences plus an Args section, all front-loaded with the core purpose. Every sentence adds distinct value with no redundancy or extraneous information.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's low complexity (1 parameter, simple list), the description covers the main functionality and default behavior. The presence of an output schema reduces the need to document return values. However, it omits handling of missing namespaces or empty results, which slightly reduces completeness.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

With 0% schema description coverage, the description compensates by explaining the namespace parameter's meaning and default behavior. It adds value beyond the schema by clarifying that omitting namespace shows all namespaces with summaries, which is not in the schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool lists memories saved across sessions in shared namespaces, with a specific verb and resource. It distinguishes from siblings like search_memories by defaulting to showing all namespaces when namespace is omitted, making its unique behavior explicit.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explains the default behavior when namespace is omitted, providing implicit usage guidance. However, it does not explicitly state when to use this tool versus alternatives like search_memories, nor does it provide exclusion criteria.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

manage_namespacesA

Create, delete, subscribe, unsubscribe, or list namespaces.

Args: action: "create" | "delete" | "subscribe" | "unsubscribe" | "list" namespace: Namespace name (required for all except "list"). description: Description (for "create"). project: Project name or id (for "subscribe" / "unsubscribe"). tags: Comma-separated tags (for "create").

ParametersJSON Schema
NameRequiredDescriptionDefault
actionYes
namespaceNo
descriptionNo
projectNo
tagsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.6/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description must disclose behavioral traits. It only lists what actions do without mentioning side effects, idempotency, authentication requirements, error behavior, or other important traits. This is insufficient for a tool performing mutations and queries.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a clear list of actions and their parameter requirements. It is front-loaded with the purpose and each sentence adds value. Minor redundancy in the 'Args' block could be tightened.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (5 parameters, 5 actions) and lack of annotations, the description covers the action-parameter mappings adequately. An output schema exists, so return values need not be described. However, behavioral context (e.g., errors, side effects) is missing, making it incomplete for an agent to use safely.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It explains which parameters are needed for each action (e.g., namespace required except for list, description/tags for create, project for subscribe/unsubscribe). This adds meaning beyond the schema, but does not cover parameter formats or constraints.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description explicitly lists the actions (create, delete, subscribe, unsubscribe, list) and the resource (namespaces), providing a specific verb+resource combination that clearly distinguishes from sibling tools (which are memory-related).

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description specifies which parameters are required for each action, giving clear guidance on how to invoke the tool for different purposes. However, it does not explicitly state when not to use it or mention alternatives, though siblings are unrelated.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

promote_memoryA

Save a memory to a shared namespace so it persists across sessions and multiple projects can access it. Use when the user teaches you something that applies beyond the current project.

Args: content: The memory content to promote. target_namespace: Namespace to promote into (created if missing). source_project: Original project (name or id). title: Title for the shared memory. description: One-line description. memory_type: user / feedback / project / reference. tags: Comma-separated tags. source_memory_id: If promoting an existing memory, its id. remove_source: Remove the original after promotion.

ParametersJSON Schema
NameRequiredDescriptionDefault
contentYes
target_namespaceYes
source_projectNo
titleNo
descriptionNo
memory_typeNo
tagsNo
source_memory_idNo
remove_sourceNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations provided, so description carries full burden. It discloses key behaviors like namespace creation and source removal, but lacks details on idempotency, overwriting, permissions, or error handling. Adequate but not exhaustive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with a front-loaded purpose sentence followed by a clear parameter list. No wasted words, though the list could be formatted for even quicker scanning.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 9 parameters and no schema descriptions or annotations, the description covers main purpose and parameter meanings but omits edge cases and return details. Output schema exists but not shown. Fairly complete for the complexity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, but the description includes a docstring with parameter names and brief explanations (e.g., 'Comma-separated tags,' 'Removed original after promotion'). This adds meaning beyond the bare schema, though descriptions could be more detailed.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states it saves a memory to a shared namespace for cross-session and cross-project access, using specific verbs and resource. It distinguishes itself from siblings like list_shared_memories and search_memories.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description explicitly says 'Use when the user teaches you something that applies beyond the current project,' providing clear context. It lacks explicit when-not-to-use or alternative tools, but the guidance is sufficient.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

search_memoriesA

Search memories saved in previous sessions, across all projects and shared namespaces. Use this when the user asks if you remember something, references past conversations, or when you want to check for existing knowledge before a task.

Args: query: Keywords to search for. scope: "all" | "shared" | "project" | a namespace name. project: Limit to a specific project (name or id). limit: Max results (default 10).

ParametersJSON Schema
NameRequiredDescriptionDefault
queryYes
scopeNoall
projectNo
limitNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A4.2/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description should disclose behavioral traits. It mentions cross-project/namespace search but does not discuss safety, rate limits, or return format. Given the output schema exists, this is sufficient but not comprehensive.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise with a clear main sentence, usage guidance, and a well-structured Args list. Every sentence adds value with no redundancy.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given 4 parameters and an output schema, the description covers purpose, usage, and parameter meanings. It lacks behavioral details like ordering or pagination, but overall is adequate for the tool's simplicity.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

The description provides detailed explanations for each parameter, including scope options and limit default, compensating for 0% schema coverage. It adds meaning beyond the raw schema.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool searches memories across projects and namespaces. It distinguishes from sibling tools like list_shared_memories or promote_memory by focusing on searching rather than listing or modifying.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines4/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description provides explicit guidance when to use the tool: when the user asks about remembering something or to check existing knowledge. However, it does not mention when not to use or suggest alternative tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

sync_memoryA

Copy a memory to one or more specific projects so they can use it in future sessions.

Args: content: The memory content. target_projects: Comma-separated list of project names or ids. title: Memory title. description: One-line description. memory_type: user / feedback / project / reference. tags: Comma-separated tags.

ParametersJSON Schema
NameRequiredDescriptionDefault
contentYes
target_projectsYes
titleNo
descriptionNo
memory_typeNo
tagsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.5/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations exist, so the description carries full burden. It states it copies a memory but omits details on idempotency, overwrite behavior, permissions, or side effects, leaving agent uncertain about execution impact.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is concise: one sentence explaining the action followed by a bulleted parameter list. No extraneous content.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness3/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With 6 parameters, no annotations, and output schema present, the description covers the action and parameter meanings but lacks usage context, error behavior, and return value hints. Adequate but not complete.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0% but the description provides meaningful parameter information (e.g., target_projects format, memory_type values). This compensates for the schema gaps, though some parameters like tags could be more precise.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool copies a memory to specific projects for future use. It uses a specific verb 'Copy' and resource 'memory', distinguishing it from siblings like search_memories or promote_memory.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

No guidance on when to use this tool versus alternatives such as promote_memory or list_shared_memories. It does not provide when-not-to-use or prerequisites.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 6 tool updatesv0.1.1
    • First observedget_memory_health
    • First observedlist_shared_memories
    • First observedmanage_namespaces
    • First observedpromote_memory
    • First observedsearch_memories
    • First observedsync_memory
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

A4/5.0
Disambiguation5/5

Each tool targets a distinct operation: health analysis, listing shared memories, namespace management, promotion to shared, searching, and syncing to projects. No two tools have overlapping purposes.

Naming Consistency5/5

All tools use consistent snake_case verb_noun pattern (get_, list_, manage_, promote_, search_, sync_), making them predictable and easy to distinguish.

Tool Count5/5

Six tools cover the core memory management tasks without unnecessary duplication. The count feels well-scoped for a memory bridge server.

Completeness4/5

The set covers health checks, listing, namespace management, promotion, search, and syncing. Missing direct memory deletion or retrieval by ID, but the core workflow of saving and sharing memories is complete.

Maintenance

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/LewenW/claude-memory-bridge'

If you have feedback or need assistance with the MCP directory API, please join our Discord server