Recollect

Self-hosted AI memory and MCP coordination for coding agents.
Keep context across repositories, tools and coding sessions.

Quickstart · Connect your agent · Features · Documentation · Issues

Recollect gives Codex and Claude Code persistent memory for engineering work.
Bring repository knowledge, documents, decisions, runbooks and supported agent
sessions into one place, so the next session can pick up where the last left off.
Run it on your own machine or a private server, and inspect the same knowledge in
a desktop web UI.

It combines long-term agent memory, knowledge graphs and hybrid search with a
Model Context Protocol (MCP) coordinator. Memories stay connected to their
sources, repository revisions and environments. You control what is captured,
what can be sent to a model and which tools an agent may use.

Early project: intended for individuals and trusted internal teams.
The initial product scope has local test evidence; the desktop redesign has
acceptance work still in progress.

When to use Recollect

• Continue work across sessions. Keep decisions, investigations, fixes and
  handovers available to the next coding agent.
• Understand a workspace across repositories. Connect code and configuration
  relationships with documentation, revision history and environment knowledge.
• Share context with a team. Organize knowledge in access-controlled Brains
  and give agents separately authorized tools for the work they need to do.

Run locally

Install Docker with Compose and Python 3.11+, then run:

git clone https://github.com/MikeK184/Recollect.git
cd Recollect
./scripts/stack.sh up --build

Open http://127.0.0.1:8787. The first run generates login credentials in the
ignored .env file: use RECOLLECT_OWNER_USERNAME and RECOLLECT_OWNER_PASSWORD.
The script builds the application and starts the complete recollect Compose
group: PostgreSQL, Neo4j, UI/API and worker, with a one-shot migration first.

./scripts/stack.sh stop         # Stop everything; keep all data
./scripts/stack.sh up           # Start again
./scripts/stack.sh status       # Show service state
./scripts/stack.sh logs         # Follow API and worker logs
./scripts/stack.sh up --build   # Rebuild after code or UI changes

The root compose.yaml also supports standard docker compose
commands. Use ./scripts/docker.sh compose if your Docker installation needs the
repository's CLI wrapper. stop keeps containers and data; down removes the
containers/network and keeps data. Do not add --volumes when retaining data.

For native development, stop the Compose stack, install Rust/Cargo and Node.js/npm,
then run ./scripts/dev.sh. It runs only the databases in Docker and starts the
API and worker in the terminal. Stop it with Ctrl+C before returning to Compose.

Learning and semantic search require an OPENAI_API_KEY in .env and an enabled
Brain model policy. Model requests are billed by the provider. Browser-created
Brains include the managed autonomous preset. Existing Brains keep their policy
until Enable autonomous memory is selected; API creation defaults remain
disabled unless managed setup is requested.

For Docker installation and shared HTTPS access, see the
installation guide.

Connect your coding agent

Open Connections → Coding agents for Codex or Claude Code. Copy the standard
HTTP MCP configuration and create a revocable access token; ordinary memory
tools need no companion. The optional native companion adds supported session
capture and local workspace discovery. Native MCP OAuth login and a published
plugin are not available yet.

The connection guide covers host configuration and a real tool-call check.
Session capture depends on the supported host's hooks and your Brain's policies.

For reproducible quality evidence, see the public retrieval benchmark
and its measured results and limits.

What it does

How the pieces fit together

A Brain holds the knowledge and access rules for a person, team or project.
Collections, repository snapshots and permitted session captures provide evidence.
Memory processing derives claims and relationships; hybrid retrieval selects
relevant context for the coding agent or UI, retaining links to that evidence.

PostgreSQL owns canonical records and policy state, pgvector supports semantic
retrieval, and Neo4j/GDS supports graph traversal and analytics. Rust powers the
API, workers and native companion; React provides the desktop UI. The same stack
runs locally or on a private server.

Recollect owns its Rust core. Cognee and
other memory systems inform the design; Cognee is not a required runtime.

Documentation

Project status

The first planned product scope is implemented and locally tested. The desktop
redesign is under active acceptance; mobile views are deferred.
The evaluation report
records measured results, failures and limits. Local validation is not a
production capacity or deployment guarantee.

Contributing

Issues and focused pull requests are welcome. Include relevant tests for behavior
changes and run ./scripts/validate.sh for the documentation checks. See
AGENTS.md for repository conventions and the development guide for
product tests.

License

Licensed under Apache-2.0.