Every AI on your machine, one memory.

Star us ❤️ →   ·  🌐 ctxd  ·  📖 Docs  ·  📦 Releases

ctxd is a single-binary daemon that gives every MCP-aware AI tool on your machine — Claude Desktop, Claude Code, Codex — one shared memory. Append-only event log, capability tokens, federation, embedded dashboard. One command sets it up.

brew install keeprlabs/tap/ctxd
ctxd onboard

That's it. ctxd onboard installs ctxd as a background service, configures Claude Desktop / Claude Code / Codex over MCP, mints scoped capability tokens per app, and seeds a baseline /me/** so a fresh AI conversation starts with non-empty context. Two minutes, idempotent, fully reversible with ctxd offboard.

The pitch in one paragraph

Every AI agent starts each session with amnesia. Context is scattered across Gmail, Slack, GitHub, Notion, and chat windows. None of those tools share a view, and your AI re-derives state from scratch every time. ctxd is the place that context lives. Write once over MCP or HTTP, query from any agent, prove what was written via Ed25519 signatures, replicate to peer nodes you trust. Not a vector DB, not an agent framework, not a knowledge graph — a substrate the rest of those things plug into.

Why this is different

Quickstart

# 1. Install
brew install keeprlabs/tap/ctxd

# 2. One-time setup (installs the daemon as a service,
#    configures Claude Desktop / Code / Codex)
ctxd onboard

# 3. Use any of your AI tools — they all share the same memory now.
#    Or write directly via the CLI:
ctxd write --subject /work/notes/standup --type ctx.note \
  --data '{"content":"Ship auth by Friday"}'
ctxd read --subject /work --recursive

ctxd onboard is idempotent — re-running it updates configs and re-mints caps without losing data. Use ctxd offboard to fully reverse the install (restore client configs from snapshot, stop the service, optionally --purge the DB). Full walkthrough: docs/onboarding.md.

You now have eight MCP tools wired to your context: ctx_write, ctx_read, ctx_subjects, ctx_search, ctx_subscribe, ctx_entities, ctx_related, ctx_timeline.

Want your inbox and pull requests in here too? The Gmail and GitHub adapters are shipped as separate binaries you run alongside the daemon. See docs/adapters/running.md for the build + launchd / systemd-user recipe.

Foreground / advanced

If you'd rather run ctxd in a terminal tab without installing a service:

ctxd serve                   # HTTP admin :7777, MCP on stdio

Wire Claude Desktop / Code / Codex by hand with the snippets in docs/onboarding.md.

Watch what your agents are writing

ctxd dashboard

Opens an embedded web UI at http://127.0.0.1:7777/. Watch events stream in live via SSE, browse the subject tree, search the log, see which capability wrote what. Read-only by default — writes still go through MCP, the wire protocol, or the CLI. Localhost-only with DNS-rebinding defenses (host-header check, CSP, X-Frame-Options).

The dashboard ships in the daemon, not as a separate process. If ctxd serve is already running, just point your browser at http://127.0.0.1:7777/. See docs/dashboard.md for the security model and what each view shows.

Architecture

The event log is append-only. Views (KV, FTS, vector, graph, temporal) are derived from it and rebuildable from it. Federation is event replay across signed cursors. Capabilities gate every write at the surface layer, before anything touches the store. See docs/architecture.md for the full picture, or the animated landing page for the diagram in motion.

What's in the box

Build a client

The three first-party SDKs all wrap the same HTTP admin + wire protocol surface. Each pins to the same docs/api/ contract.

The Rust SDK is the source of truth; the Python and TypeScript packages mirror it. All three run the same MessagePack hex fixtures and JSON Schema corpus the daemon runs.

use ctxd_client::CtxdClient;
let client = CtxdClient::connect("http://127.0.0.1:7777").await?
    .with_wire("127.0.0.1:7778").await?;
let id = client.write("/work/notes", "ctx.note", json!({"hi": "there"})).await?;

Install

Homebrew (macOS, Linux)

brew install keeprlabs/tap/ctxd

curl | sh

curl -fsSL https://github.com/keeprlabs/ctxd/releases/latest/download/install.sh | sh

Auto-detects OS + arch, verifies the published sha256, drops the binary in the first writable directory on $PATH. Override with CTXD_INSTALL_DIR=... (set it on the sh side of the pipe).

From source

git clone https://github.com/keeprlabs/ctxd && cd ctxd
cargo build --release
# add --features storage-postgres,storage-duckdb-object for the heavier backends

Pre-built tarballs for macOS arm64/x86_64 and Linux x86_64/aarch64 are attached to every release.

Going further

Development

cargo test --workspace                       # ~425 tests (default features)
cargo test --workspace --all-features        # adds postgres + duckdb suites
cargo clippy --workspace --all-targets -- -D warnings
cargo fmt --all --check

CI runs the Postgres conformance suite against a postgres:16 service container. The full matrix lives in .github/workflows/ci.yml.

Contributing

Bugs, features, and adapter PRs all welcome.

• File issues at github.com/keeprlabs/ctxd/issues.
• For new adapters, start with docs/adapter-guide.md — the trait is stable.
• Open PRs against main. CI must be green; clippy and cargo fmt --check are gates.
• We aim to triage every PR within a few days.

Star history

If ctxd is useful to you, a star is the single most useful signal you can send. It tells us this approach matters, helps other developers find the project, and shapes what we prioritize next.

License

Apache-2.0. All of it.