RCLL

Self-hosted shared memory for a team of AI agents. Storage + structure in one system.

RCLL — team memory for agent fleets. Built on Hindsight (github.com/vectorize-io/hindsight, MIT).

RCLL is a fork of vectorize-io/hindsight (MIT). It keeps Hindsight's storage engine and adds rooms — shared, isolated memory across a team of agents — plus a hierarchical depth model (L0–L3). The room/hall/layer taxonomy is prior art in the hierarchical-memory space; the implementation here is our own.

RCLL is recall with the vowels dropped — the one operation every agent in the fleet performs before it does anything else. The tool is literally called memory_recall; the product is named after the call.

---

How it works

┌──────────────────────────────────────────────────────┐
│                         RCLL                         │
│                                                      │
│  ┌─── Room: auth ───┐  ┌─── Room: pipeline ──┐       │
│  │ Hall: facts      │  │ Hall: decisions     │       │
│  │ Hall: procedures │  │ Hall: events        │       │
│  │ Hall: warnings   │  │ Hall: facts         │       │
│  │                  │  │                     │       │
│  │  L0 ████ always  │  │  L0 ████ always     │       │
│  │  L1 ███░ warm    │  │  L1 ███░ warm       │       │
│  │  L2 ██░░ cold    │  │  L2 ██░░ cold       │       │
│  │  L3 █░░░ archive │  │  L3 █░░░ archive    │       │
│  └──────────────────┘  └─────────────────────┘       │
│           │                      │                   │
│           └──── Tunnel ──────────┘                   │
│                (cross-bank bridge)                   │
│                                                      │
│  Closets: compressed summaries + source pointers     │
└──────────────────────┬───────────────────────────────┘
                       │
              Hindsight vector store
              (embeddings + semantic search)

Rooms — topic isolation. Auth, pipeline, infrastructure, schema — each topic in its own room. An agent searching for auth facts won't wade through 500 deploy memories.

Halls — knowledge typing within a room. Fact, event, decision, procedure, warning. The system knows what it's looking at before reading — like Content-Type for memory.

Layers L0–L3 — four priority tiers. L0 (core) is always loaded. L3 (archive) is deep-search only. Same idea as CPU cache hierarchy: L1 is fast and small, RAM is slow but holds everything.

Closets — AI-compressed summaries with source pointers. Deduplication at the knowledge level: 10 related facts → 1 paragraph + references.

Tunnels — cross-bank bridges between agents. Agent A discovers an insight — Agent B sees it through a tunnel without data duplication.

Comparison

	Hindsight (upstream)	RCLL
What it is	Long-term memory store	Storage + taxonomy hybrid
Storage	Vector store + embeddings	Vector store + embeddings
Memory structure	Flat (all memories equal)	Rooms → Halls → Layers + embeddings
Retrieval	Semantic search	Room-scoped semantic search
Classification	None	Keyword-based, <1ms, zero LLM cost
Priority tiers	All memories equal	L0–L3 (implemented)
Compression	None	Closets with source pointers
Multi-agent	Shared bank	Tunnels (cross-bank bridges)
MCP integration	API only	5 tools via MCP protocol
Setup	Docker	Docker (drop-in upgrade)

Quick start

git clone https://github.com/holetron-lab/rcll.git
cd rcll
cp .env.example .env
# edit .env with your config
docker compose -f docker-compose.rcll.yml up -d

API available at http://localhost:5100. Drop-in replacement for vanilla Hindsight — same API, same clients, new brain.

Embeddings

Ships with BAAI/bge-small-en-v1.5 (384-dim) — fast, CPU-friendly, baked into the image so first run needs no network download. It's English-optimized; recall quality on other languages degrades.

For multilingual memory (e.g. RU, multi-script), point it at a multilingual model:

HINDSIGHT_API_EMBEDDINGS_LOCAL_MODEL=BAAI/bge-m3   # 1024-dim, multilingual

Dimension is detected automatically. ⚠️ Switching models changes the vector dimension — do it on an empty memory store, or wipe + re-embed, since existing vectors can't be mixed across dimensions.

MCP Server

The mcp-server/ directory contains a standalone MCP server. Any MCP-compatible client (Claude Code, OpenClaw, Cursor, etc.) connects and gets structured long-term memory.

Tools

Tool	Description
memory_retain	Save a memory with automatic room/hall classification
memory_recall	Scoped semantic search with room/hall/layer filters
memory_reflect	Deep reasoning — synthesize facts, find patterns, answer with citations
memory_compress	Create closet summaries from accumulated facts
memory_bridge	Cross-bank tunnels between related memories

Setup

cd mcp-server
npm install
RCLL_URL=http://localhost:5100 node server.js

Claude Code config

Add to ~/.claude/mcp.json:

{
  "mcpServers": {
    "rcll": {
      "command": "node",
      "args": ["/path/to/mcp-server/server.js"],
      "env": {
        "RCLL_URL": "http://localhost:5100",
        "RCLL_BANK": "my-agent-bank"
      }
    }
  }
}

Upgrading from the old package name? HINDSIGHT_URL and the legacy bank variable are still read as a fallback, so an existing config keeps working — it just prints a deprecation notice on start.

See mcp-server/README.md for full docs and environment variables.

API changes from upstream

The base /retain and /recall endpoints are fully backward-compatible. New parameters are optional.

New parameters

Endpoint	Parameter	Type	Description
/retain	room	string	Topic room (auto-classified if omitted)
/retain	hall	string	Knowledge type (auto-classified if omitted)
/retain	layer	int	Priority 0-3 (default: 2)
/recall	room	string	Filter recall to a specific room
/recall	hall	string	Filter recall to a specific hall
/recall	max_layer	int	Maximum layer depth to search

New endpoints

Method	Endpoint	Description
POST	/bridge	Create a cross-bank memory bridge
GET	/tunnels	List existing tunnels
POST	/tunnels	Create a tunnel between banks
GET	/closets	List compressed memory summaries
POST	/closets	Compress L3 memories into a closet

Room/Hall taxonomy

Rooms (topics)

auth · pipeline · infrastructure · deployment · schema · api · ui · tax · hr · legal · compliance · monitoring · agent · general

Halls (knowledge types)

warning · decision · procedure · event · preference · discovery · fact

Layers

Layer	Name	Behavior
L0	Critical	Always recalled
L1	Important	Recalled by default
L2	Normal	Standard (default for new memories)
L3	Archive	Deep search only, compressed into closets

Auto-classification

RCLL includes a keyword-based classifier (room_hall_classifier.py) that assigns room and hall automatically when not provided. No LLM call — classification is instant and free.

Extensible: add keywords to ROOM_KEYWORDS / HALL_KEYWORDS dictionaries.

Examples

Store a memory

curl -X POST http://localhost:5100/retain \
  -H "Content-Type: application/json" \
  -d '{
    "bank": "project-alpha",
    "text": "Never restart PROD PM2 without confirming DEV works first.",
    "room": "deployment",
    "hall": "warning",
    "layer": 0
  }'

Scoped recall

curl -X POST http://localhost:5100/recall \
  -H "Content-Type: application/json" \
  -d '{
    "bank": "project-alpha",
    "query": "deployment safety rules",
    "room": "deployment",
    "hall": "warning",
    "max_layer": 1
  }'

Cross-bank bridge

curl -X POST http://localhost:5100/bridge \
  -H "Content-Type: application/json" \
  -d '{
    "source_bank": "project-alpha",
    "target_bank": "project-beta",
    "room": "infrastructure",
    "hall": "procedure"
  }'

What we changed

A taxonomy layer over Hindsight's vector store, plus a standalone MCP server.

Key additions:

• room_hall_classifier.py — keyword-based taxonomy engine (new)
• aa1_add_room_hall_to_memory_units.py — DB migration: flat → hierarchical, adds room/hall + layer column (new)
• mcp-server/ — standalone MCP server with 5 tools (new)
• Storage layer — room/hall/layer metadata on every write
• Retrieval — room-scoped search with hall filtering
• Compression — closet generation with source linking
• Tunnels — cross-bank memory sharing protocol

Full architectural spec: RCLL.md

Upstream compatibility

This fork tracks vectorize-io/hindsight as upstream. To pull updates:

git remote add upstream https://github.com/vectorize-io/hindsight.git
git fetch upstream
git merge upstream/main

All changes are additive — existing Hindsight behavior is preserved.

Credits

• Hindsight by vectorize-io — the memory storage engine
• Holetron — fork maintainers, MCP server, integration

License

MIT — same as upstream Hindsight. See LICENSE.