rembric*/ˈrem.brɪk/*—comes from remember + fabric: a woven memory layer beneath your agents .  It packages one brain, one dashboard and one audit trail in a single process .  Rembric is a persistent, self‑hosted memory system for AI coding agents that lets you own your context, audit what is remembered, and build long‑term knowledge across sessions.

Why I built it

AI coding agents are most useful when they understand the architecture and history of your project: the recurring decisions, preferences and trade‑offs that shape your code.  But that context is often scattered across chats, notes and fragile memory systems.  Existing tools rely on cloud services or opaque storage, making it hard to see what the agent knows or to carry that knowledge between sessions.

Rembric began as an experiment in making memory explicit and durable.  I wanted a way for agents to search relevant context, surface potential conflicts, and remember resolutions without sending data to third‑party servers.  The result is a local‑first memory server with an operator dashboard, append‑only storage and a simple HTTP API.

What Rembric does

Rembric provides self‑hosted memory, session management and a dashboard for AI coding agents .  It runs as a single Docker container or Node process backed by a SQLite database , so all of your data lives on your machine or server.  Multiple agents can share the same memory; sessions and projects keep their scope isolated .  Every save is append‑only and reversible , so you get a complete audit trail and never lose information.

Under the hood, Rembric embeds its own multilingual semantic model and uses full‑text search to surface similar memories.  At save time it can show potential conflicts for the agent to resolve; aged pending conflicts resurface until judged .  A deterministic consolidation sweep handles decay and orphaning without relying on cron jobs or external LLM calls .

A built‑in dashboard exposes every memory, session, prompt and judgment.  It is server‑rendered HTML using HTMX—no JavaScript framework, no telemetry—and requires only a single admin token for auth .  From the dashboard you can explore memories with filters and full‑text search, inspect session histories, see pending judgments, trigger consolidation runs and manage projects and tokens .

Installation and quickstart

The easiest way to get started is with the one‑line installer.  It downloads the appropriate Docker image, generates an admin token and installs/update/removes the plugins for your agent :

curl -fsSL https://raw.githubusercontent.com/susomejias/rembric/main/install.sh | sh

When the installer runs, pick Server → install to generate your REMBRIC_ADMIN_TOKEN, and if Docker is present it will run docker compose up -d for you .  Then pick Plugins to install the plugin for your agent.  You can pin a specific release with --ref=<tag> .

The canonical distribution is Docker: the image bundles Node 22, the native modules (better‑sqlite3, sqlite‑vec, onnxruntime‑node) and the embedding model.  It runs on linux/amd64 and linux/arm64 and only needs about 1 GB of RAM (2 GB recommended) .  Rembric exposes two endpoints: the memory API at http://<host>:8787/mcp and the dashboard at http://<host>:8787/dashboard .  If you’d rather read the script first, you can download it and inspect it before running it .

For a manual setup, fetch the docker-compose.yml and .env.example files yourself and bring up the container with Docker Compose .  On remote hosts the compose file publishes port 8787 so your agent can reach it over LAN or Tailscale; do not expose it directly to the public internet and always protect the bearer token .  You can also override the compose file to bind the port to 127.0.0.1 for local‑only deployments .

Configuration and requirements

Rembric is configured entirely via environment variables in the .env file.  At minimum you must set REMBRIC_ADMIN_TOKEN to control access to the dashboard and API .  You can adjust the bind address (REMBRIC_HOST), port (REMBRIC_PORT), data directory (REMBRIC_DATA_DIR), log level (LOG_LEVEL) and other options such as rate limiting and session expiration  .

Hardware requirements are modest: the container needs only ~1 GB of RAM (2 GB recommended) and about 300 MB of disk space for the embedded semantic model .  Because the embedder runs in process, Rembric does not call external services or require API keys .

Architecture and principles

The architecture is intentionally simple: a single Node process exposes both the memory API and the dashboard .  Agents connect via HTTP(S) using a bearer token; each project lives in its own scope .

Four invariants guide the design :

  1. Append‑only storage – rows are never deleted and content is never updated.  Lifecycle changes happen through status flips and replacement links, and every consolidation operation is reversible .
  2. Project scoping – every memory is global or attached to a project.  Consolidation and relations never cross project boundaries .
  3. Convergent topics via topic_key – when an agent saves new content for the same topic key in a given project, the previously active row is automatically superseded atomically .
  4. Fresh‑context judgment – conflict candidates surface at save time for the agent to judge; aged pending conflicts resurface until they are resolved .  A deterministic sweep handles decay and orphaning, independent of LLMs or cron jobs .

These principles ensure that memory stays consistent, auditable and easy to reason about even as agents evolve.

Who it’s for

Rembric is built for developers experimenting with AI‑assisted coding workflows.  If you want your agents to build long‑term context without relying on external services, or you care about owning your data and inspecting what the AI knows, Rembric is for you.  It supports any agent that speaks MCP or HTTP: official plugins exist for Claude Code, Codex CLI, Hermes, opencode and others .  ChatGPT can connect via a custom MCP connector over OAuth 2.1 .

It’s also suitable for teams who need shared memory across multiple agents but want strict project boundaries and an audit trail.  The dashboard makes day‑to‑day operations easy: mint and revoke tokens, create or archive projects, explore memories, review pending judgments and run maintenance purges .

Conclusion

Persistent memory turns AI coding tools from session‑bound helpers into long‑term collaborators.  Rembric weaves that memory layer into your workflow with a self‑hosted server, explicit design principles and a transparent dashboard.  Whether you’re building complex systems, experimenting with multiple agents or simply want to own your data, give Rembric a try.

Learn more and contribute on GitHub: https://github.com/susomejias/rembric⁠