Server data from the Official MCP Registry
Durable shared memory for AI agents: search, write and correct facts, with per-client policy.
About
Durable shared memory for AI agents: search, write and correct facts, with per-client policy.
Remote endpoints: streamable-http: https://mcp.lumberroom.cloud/mcp
Security Report
Valid MCP server (1 strong, 1 medium validity signals). No known CVEs in dependencies. Imported from the Official MCP Registry.
Endpoint verified · Requires authentication · 1 issue found
Security scores are indicators to help you make informed decisions, not guarantees. Always review permissions before connecting any MCP server.
Permissions Found in Source Code
Found by scanning the linked source code. This listing connects to a hosted endpoint, so none of this runs on your machine: it describes what the server software does where it is hosted.
How to Connect
Remote Plugin
No local installation needed. Your AI client connects to the remote endpoint directly.
Add this to your MCP configuration to connect:
{
"mcpServers": {
"cloud-lumberroom-lumberroom": {
"url": "https://mcp.lumberroom.cloud/mcp"
}
}
}Documentation
View on GitHubFrom the project's GitHub README.
Lumberroom
One memory that every AI tool you use can read from and write to, with you deciding what each one is allowed to see.
More videos: Lumberroom playlist · lumberroom.cloud/videos
You run seven AI surfaces. Each keeps its own memory. None of them share. You re-explain your setup to ChatGPT, then again to Claude, then again to your coding agent, and when you correct one of them the others never find out. Lumberroom holds the facts once, on infrastructure you own, and every tool reads from the same place.
Three layers, doing three different jobs:
- Memory remembers. Fuzzy semantic recall. Commodity, kept deliberately thin and swappable.
- Registry knows. Exact structured facts with a canonical key and provenance. A memory holds
"Dana mentioned her box runs Ubuntu"; the registry holds
machines.desktop.os = Ubuntu 26.04, confirmed by you, on a date, superseding an older value. - Policy decides. Which tool sees which facts. The layer that makes it safe to store anything worth storing.
The value is in the second and third. Full thesis: docs/prd/system-prd.md.
Claude Code, Hermes, OpenWebUI, lumberroom CLI ──── static bearer token ────┐
│
Claude.ai, Cowork, mobile, ChatGPT ── OAuth 2.1 + PKCE ───────────────┤
▼
Caddy (auto-TLS) ──▶ lumberroom (Rust: axum + rmcp)
│
▼
Postgres 16 + pgvector (127.0.0.1)
One Rust binary, a Postgres database with pgvector, and two clients that talk to them. Ten MCP tools
behind four capabilities, mounted at /mcp. A built-in OAuth 2.1 authorization server for the
surfaces that need a browser, with static bearer tokens honoured beside it whatever AUTH_MODE says.
Envelope encryption for private, client-side encryption for sealed. A console at /console for
the decisions a person has to make.
Install the server
git clone https://github.com/lumberroom/lumberroom.git && cd lumberroom
sudo ./deploy/install.sh
That is token mode on loopback: the server binds 127.0.0.1:8787, opens no public port, and prints
the command to run on your Mac. The client token is the first "token" field in the .env the
installer writes (mode 600) in the clone. Add --domain and --auth-mode oauth when a
browser has to reach it. The installer pulls
ghcr.io/lumberroom/lumberroom-server:0.6.0 and falls back to building from this tree when the
pull fails; --build-local skips the pull. It pins a version rather than tracking latest, because
a memory store that upgrades itself while you sleep is not a feature.
Watch the self-host walkthrough: youtu.be/Km7CcmcsS2w.
Moved: the engine used to publish as ghcr.io/the-cybersapien/lumberroom-server. That image stays
public, frozen at 0.4.0, and takes no new versions; pull ghcr.io/lumberroom/lumberroom-server
instead.
Install the client
The client runs on the machine holding your transcripts and your credentials, and talks to a server you host. Four ways in, in the order most people want them.
brew install lumberroom/lumberroom/lumberroom
Installed from the old the-cybersapien/lumberroom tap? The next brew update follows the move and
renames the tap. Homebrew stops trusting a tap whose owner changed, so run
brew trust lumberroom/lumberroom once, or brew upgrade refuses the formula.
cargo install lumberroom
A binary, with no package manager. Four targets, macOS and Linux on arm64 and x86_64:
tag=v0.6.0; target=aarch64-apple-darwin # or x86_64-apple-darwin,
# aarch64-unknown-linux-musl, x86_64-unknown-linux-musl
base=https://github.com/lumberroom/lumberroom/releases/download/$tag
curl -fsSLO "$base/lumberroom-${tag#v}-$target.tar.gz"
curl -fsSL "$base/SHA256SUMS" | grep "$target.tar.gz" | shasum -a 256 -c -
tar -xzf "lumberroom-${tag#v}-$target.tar.gz" && install -m 755 lumberroom ~/.local/bin/
Check the archive before you run what came out of it. Every release carries one SHA256SUMS over
every asset, written by the job that collected them all.
On a machine where apt or dnf is how software arrives, the release also carries a .deb and an
.rpm per architecture. Both hold the musl binary, statically linked, so neither declares a runtime
dependency:
sudo dpkg -i lumberroom_0.6.0-1_amd64.deb # or lumberroom_0.6.0-1_arm64.deb
sudo rpm -i lumberroom-0.6.0-1.x86_64.rpm # or lumberroom-0.6.0-1.aarch64.rpm
Then point it at your server:
lumberroom doctor
doctor reports the endpoint, whether your credential is accepted, and which tools it opens. It is
the first command to run and the one to run when something is wrong.
To wire a Mac into Claude Code, which installs the MCP server, the session hook and the CLAUDE.md rule in one pass:
LUMBERROOM_TOKEN=<token> ./client/wire-mac.sh --url http://127.0.0.1:8787
For Hermes Agent, lumberroom-hermes is a memory
provider: recall on every turn and the engine's own tools for writes. It uses lumberroom.cloud unless
base_url names your own engine, which runs the same code.
Then prove the loop, which states a fact in one session and recovers it in a fresh one:
LUMBERROOM_URL=http://127.0.0.1:8787 LUMBERROOM_TOKEN=<token> ./scripts/done-when-test.sh
Back up secrets/lumberroom-kek somewhere this box does not hold. Losing it makes every private row
unreadable, in the database and in every backup.
Where to go next
| docs/faq.md | The questions people actually ask: deploying, granting a client, keys, refusals |
| docs/managing.md | Running a live store: approving a client, changing what it may reach, the two queues |
| DEPLOY.md | The runbook: both deploy paths, the KEK, backups, troubleshooting |
| deploy/oauth.md | The OAuth production path, per surface, with the consent screen |
| docs/permissions.md | Every grant field, both axes, and which tools each capability opens |
| docs/connect-claude-code.md | Wiring Claude Code on a Mac, end to end |
| docs/connect-claude-ai.md | The memory rules for claude.ai, Cowork and other connector clients: instructions to paste, or a skill |
| docs/architecture.md | The ports-and-adapters shape and where each part lives |
| docs/decisions/ | Why each part is shaped the way it is, one record per choice |
| docs/traps.md | Findings that cost real time, and what to do instead |
| VERIFY.md | The gates: what each checks, how to run it, what a pass looks like |
| docs/benchmarks.md | Every retrieval figure, with the run that produced it |
| CONTRIBUTING.md | Building, testing, and what a pull request needs |
| docs/README.md | The full index: PRDs, phase specs, research, design |
The ten tools
Every tool sits behind one grant, and src/mcp/capability.rs holds the single table that decides
which. tools/list filters on it, so a model never sees a tool its credential cannot call, and the
service checks the grant again on the call. Signatures are additive: they have gained arguments and
never lost one.
| Grant | Tools |
|---|---|
| Open to every authenticated client | context_bootstrap, memory_search, memory_write, registry_get, alias_list |
mayDelete | memory_forget |
mayReadHistory | memory_history, registry_history |
registryWrite | registry_set, alias_set |
Namespace and sensitivity still apply inside every call. Full signatures and what each one does: docs/permissions.md.
possible_conflicts is what makes a correction stick. When a write lands close to an existing fact
but not close enough to collapse into it, the server returns the neighbours it refused to merge, and
the model calls memory_write again with supersedes. The store cannot tell a correction from a
restatement; the model in the conversation is the only party that can.
Namespaces and sensitivity
user:mefacts about you and how you workproject:<slug>facts scoped to one codebaseglobalfacts true everywhere: infrastructure, conventions, credential locationspersonal:*andcredentials:*classify aboveopenby default
A grant pairs a namespace glob with a sensitivity ceiling, on each of the read and write axes.
{"namespace": "project:*", "max": "private"} grants every project namespace up to private. Two
patterns matching one namespace resolve to the more generous ceiling.
The three levels are three different mechanisms:
openis stored in the clear, indexed lexically and semantically.privateis encrypted at rest under a per-row key and drops out of the lexical index (decision 0005).sealedarrives encrypted by the client. The server holds no key for it and cannot read it under any circumstance.
What private does not protect, stated here rather than buried in a research file. The embedding
stays plaintext, because there is no ANN index over ciphertext and an unsearchable level would push
everything worth protecting back into open. Published inversion work recovers most of a short text
from its embedding: Morris et al. report 92% exact recovery of 32-token inputs with black-box query
access, a 2025 reproduction confirms it, and later work drops the need for the victim's model. Those
are figures from the literature, not measurements on this system. The claim lumberroom makes is narrow
and it is the one to hold it to: private protects the verbatim text of a row from whoever holds the
database, and leaks its gist. It protects nothing against the live server, which decrypts to answer a
search. Evidence:
docs/research/encryption-and-sensitivity.md §1.
Operating it
lumberroom help is the authoritative list. One client, the Rust one, shipped as a release
binary and on the Homebrew tap.
lumberroom doctor # connectivity, auth, readiness, tool list
lumberroom clients # registered OAuth clients, how each registered, consent state
lumberroom search "how do we deploy"
lumberroom write "..." --namespace user:me --tags preference
lumberroom review [--source conflict,stale,proposal] [--limit N] [--days N] [--min-similarity X] [--json]
lumberroom review --dates # undated facts whose own text names a day
lumberroom review --registry # registry entries due for review, non-canonical keys
lumberroom review --dismissed # lists the dismissed-pair ledger
lumberroom review --undismiss <a>,<b> # removes one pair from the ledger
lumberroom registry get|set|alias ...
lumberroom stats [--hours 168] [--by-client]
lumberroom export --obsidian ~/vault
lumberroom seal <key> --namespace credentials:aws
lumberroom tools
The lumberroom Rust CLI (crates/lumberroom) carries the archive commands:
lumberroom archive export ~/store.lumber --passphrase-stdin
lumberroom archive import ~/store.lumber --passphrase-stdin --dry-run
The console at /console carries the decisions a person has to make: what each client may reach, the
ingest queue, the cleanup queue, aliases, and writing or correcting a fact by hand. It runs only in
oauth mode, because it checks the owner password. docs/managing.md is the guide.
lumberroom stats answers the question that matters: how often does a model call these tools on its
own? Every call writes a row, refused ones included, and unprompted separates the model deciding
from you or the hook forcing it.
Health endpoints: /healthz needs no credentials, /readyz reports the embedder and checks the
schema dimension against the configured one, /statsz needs a token, and /admin/whoami answers
what the credential you present resolves to from the code path that enforces it.
Development
cp .env.example .env # then set POSTGRES_PASSWORD
docker compose up -d db # Postgres 16 + pgvector on 127.0.0.1:5432
docker build -t lumberroom-builder -f Dockerfile.builder . # again after any change to
# Dockerfile.builder or scripts/lib/builder-entrypoint.sh
./scripts/cargo.sh test -j 1
-j 1 is not optional: linking the lib-test and integration binaries at the same time gets the
linker OOM-killed in the container, and it reads as a compile error rather than a memory limit. The
suite runs against a real Postgres in its own database with the hash embedder. Under cargo.sh a
missing or broken database fails the run. Plain cargo test with none reachable skips and counts
the skip as passed; set LUMBERROOM_TEST_REQUIRE_DB=1 to make that fail.
CONTRIBUTING.md carries the rest, and docs/traps.md carries what
has already cost time.
One rule carries the architecture: domain and services never import from adapters. A service asks
a MemoryRepository for rows and does not know Postgres exists, which is what makes a second storage
implementation possible. See docs/architecture.md.
What is not built yet
The OAuth wire protocol has a gate and the browser and mobile clients that depend on it have none, which is the largest gap. Beyond that:
- 0.97 is still a guess. Only the lower similarity band has a measurement behind it.
DEDUPE_THRESHOLDwas picked rather than calibrated, anddocs/specs/phase-4-quality.md§2 is the procedure that would settle it. A numeric guard is what makes being wrong about it survivable. - Sealed items have no bulk listing.
lumberroom sealandunsealwork one key at a time, and nothing enumerates what is stored. - RFC 8707 audience binding is not enforced on the opaque token path. The token endpoint records the resource a client asked for and validation reads it without comparing it.
- Client registration has no rate limit. Registration is open by design and a registered client holds nothing until the owner consents, so the cost is rows that nothing purges.
- A grant change leaves no audit row. The console and the consent screen both overwrite the grant in place, so there is no record that a client used to hold less.
- KEK rotation and escrow.
KEK_IDis written on every row so a rotation is distinguishable from data loss, and nothing rewraps.
Which gates cover what, and which are still open: VERIFY.md.
Layout
docs/ PRDs, phase specs, decisions, research, design
src/domain/ types, errors, namespace rules, policy, canonical keys, tripwire. No I/O
src/ports/ one file per port: memory, registry, tool_calls, sealed, oauth, embedder
src/services/ bootstrap, search, write, forget, review, export, registry, recall
src/crypto/ the KEK provider trait and the per-row envelope
src/authserver/ the built-in OAuth 2.1 server: routes, consent pages, sessions, login limiter
src/adapters/ postgres (the only module with SQL), embedding, auth
src/mcp/ tool registration and descriptions; the tool list is per credential
src/http/ axum routes, the admin surface, the well-known documents; MCP mounts at /mcp
src/console/ the console at /console: reading, write, registry, aliases, queues, clients
migrations/ SQL, applied at boot by sqlx
tests/ integration suite, against a real database
crates/lumberroom/ the client: the CLI, the session hook, transcript ingestion, the cleanup daemon
client/ wire-mac.sh, the SessionStart hook, the OpenWebUI filter, the eval fixture
deploy/ install.sh, Caddyfile, backup.sh, oauth.md, Oracle and Logto notes
scripts/ cargo.sh, lumberroom.sh, the acceptance gates and the eval harness
Licence
Apache-2.0. The full text is in LICENSE, and THIRD-PARTY-NOTICES.md lists the third-party components this project depends on and the terms they come under.
Reviews
No reviews yet
Be the first to review this server!
More Developer Tools MCP Servers
Rea
Freeby Morluto · Developer Tools
Reverse engineer anything from your terminal or agent with one CLI and MCP server.
Paperclip
Freeby Paperclipai · Developer Tools
Trending hip-hop artist momentum scores across four cultural dimensions.
Scrapling
Freeby D4Vinci · Developer Tools
Web scraping with stealth HTTP, real browsers, and Cloudflare bypass. CSS selectors supported.
Git
Freeby Modelcontextprotocol · Developer Tools
Read, search, and manipulate Git repositories programmatically
Toleno
Freeby Toleno · Developer Tools
Toleno Network MCP Server — Manage your Toleno mining account with Claude AI using natural language.
MCP Marketplace
Freeby mcp-marketplace · Developer Tools
Search and install MCP servers from inside your AI client.

