Open Source · MIT Licensed · Alpha

Your agents forget everything.
NotDory doesn't.

NotDory is durable, self-hosted memory for AI agents. Decisions, conventions, and hard-won lessons survive from one session to the next, so your agents pick up where they left off, spend fewer tokens rediscovering your world, and get to outcomes faster.

Get Started View on GitHub
claude — my-repo (day 2) 
$ claude
# SessionStart hook: NotDory loads this project's memory before the first turn
scope      my-repo (42 memories, 6 categories)
recent     filesystem-layout · build-and-test · commit-rules · auth-decision

> pick up the auth refactor where we left off

notdory · memory_search "auth refactor"
  auth-decision   "Sessions move to bearer tokens; cookie path removed after v2"
  auth-progress   "Routes migrated; middleware + tests remaining"

# No re-scan of the repo. No re-asking. Straight back to work.
96% Tasks Solved With Memory
17% Without It
5 Agent Harnesses
32 MCP Tools
3 Storage Backends
Why NotDory

Most AI agents are Dory.

Dory, the lovable blue tang from Finding Nemo, forgets everything a few seconds after it happens. She's charming, she means well, and she'll introduce herself to you again tomorrow. Sound like any agents you know?

Every session starts from zero

A new session greets your codebase like it has never seen it before: re-reading the same files, re-learning the same conventions, re-asking the same questions.

Tokens burned on rediscovery

The dominant cost in agentic work is re-acquiring context. You pay for the same repository scan, the same file reads, and the same reasoning every single day.

The same mistakes, again

You corrected it yesterday. You told it how you like commits written. It tried the approach that doesn't work. Today, it does all of that again.

Knowledge trapped in one tool

What one agent learned stays locked inside one chat history. Switch harnesses, switch machines, or hand off to a teammate, and the context is gone.

NotDory is not Dory.

It gives your agents a memory that sticks, so they:

Remember

Decisions, conventions, facts, and "we tried that, it didn't work" survive across sessions, harnesses, and projects.

Pick up where they left off

Session start hands the agent its project's context, categories, and recent memories before the first turn.

Use fewer tokens

Recalling a note is far cheaper than re-scanning a repository to rediscover it. Write once, recall cheaply forever after.

Get to outcomes faster

Less rediscovery, more doing. The agent starts on the actual problem instead of rebuilding its understanding of your world.

Stop repeating mistakes

A correction or preference is saved once and honored from then on. Superseded decisions rank behind the ones that replaced them.

Share what they learn

What Claude Code learns, Codex, Cursor, Gemini CLI, and Mux can recall. One memory, every harness, every teammate.

Measured, not promised

Claude Code ran 24 tasks whose answers lived only in project memory, with every built-in tool disabled.

With NotDory
96%
No memory
17%

Task completion, 23 of 24 versus 4 of 24. Methodology and every other number are in the benchmark results.

How It Works

Memory the agent manages itself.

Agents read and write structured memory over MCP. The model decides what to remember and recalls it on demand, while you manage everything through a REST API and a web dashboard.

Your agents
Claude Code · Codex · Cursor · Gemini CLI · Mux
You
Dashboard · REST API · OpenAPI
MCP & REST
NotDory
Scopes, categories, memories, and policies · hybrid search · reranking · tenants & RBAC
per-scope storage
RecallDB
Semantic + keyword hybrid search
Verbex
Lexical search, no embeddings
Filesystem
Git-trackable markdown

Scopes

A project, a book, or "global". Session start matches the project by its git remote or folder name, and creates the scope on first use.

Categories

Buckets with usage instructions the model reads before writing, so it knows how to use a memory space, not just that it exists.

Memories

Atomic notes with tags, links, provenance, and salience. A new memory can supersede an old one, and near-duplicates are flagged on write.

Policies

Cross-cutting rules, like a house writing style or your commit conventions, that apply everywhere and are surfaced to the agent proactively.

Features

The right context, proactively.

Structured memory, not a blob of nearest-neighbor chunks.

One-step session start

One session_start call returns the project's scope, protocol, categories, instructions, and recent memories. The Claude Code hook does it before the first turn.

Hybrid search + reranking

Semantic and keyword retrieval fused into one ranking, with an optional cross-encoder reranker. nDCG@10 of 0.81–0.91 on memory datasets, up to 0.97 reranked.

Pluggable storage per scope

RecallDB for semantic search, Verbex for lexical search, or plain files that travel inside the repo and get reviewed in pull requests. Choose per scope.

Editable agent onboarding

The server instructions and every tool description are editable in the dashboard. Changes reach connected agents without a restart.

Multi-tenant with RBAC

Tenants, users, and credentials with fine-grained permissions. Agents connect with a least-privilege access key; the secret key never leaves your machine.

Observable out of the box

Metrics, traces, and logs wired into Prometheus, Tempo, Loki, and pre-built Grafana dashboards. Every request is recorded in request history.

Agents

Bring your own harness.

NotDory speaks MCP, so any MCP-capable agent can use it. Ready-made installers for macOS, Linux, and Windows write the config for you, back up the existing file, and leave everything else intact.

# Registers NotDory at user scope and installs the SessionStart hook
$ sh scripts/macos/install-claude.sh <accessKey>

# Or wire it up by hand
$ claude mcp add --transport http notdory http://127.0.0.1:8720/mcp \
    --header "x-access-key: <accessKey>"

# Tools appear as mcp__notdory__session_start, mcp__notdory__memory_search, ...
$ sh scripts/macos/install-codex.sh <accessKey>

# Writes ~/.codex/config.json
{
  "mcpServers": {
    "notdory": {
      "type": "http",
      "url": "http://127.0.0.1:8720/mcp",
      "headers": { "x-access-key": "<accessKey>" }
    }
  }
}
$ sh scripts/macos/install-cursor.sh <accessKey>

# Writes ~/.cursor/mcp.json (or .cursor/mcp.json per project)
{
  "mcpServers": {
    "notdory": {
      "url": "http://127.0.0.1:8720/mcp",
      "headers": { "x-access-key": "<accessKey>" }
    }
  }
}
$ sh scripts/macos/install-gemini.sh <accessKey>

# Writes ~/.gemini/settings.json (or .gemini/settings.json per project)
{
  "mcpServers": {
    "notdory": {
      "httpUrl": "http://127.0.0.1:8720/mcp",
      "headers": { "x-access-key": "<accessKey>" }
    }
  }
}
$ sh scripts/macos/install-mux.sh <accessKey>

# Appends to ~/.mux/mcp-servers.json
{
  "servers": [
    {
      "name": "notdory",
      "transport": "http",
      "url": "http://127.0.0.1:8720",
      "mcpPath": "/mcp",
      "auth": { "type": "bearer", "bearerToken": "<accessKey>" }
    }
  ]
}

On Linux use scripts/linux/; on Windows, scripts\windows\install-*.bat. Matching remove-* scripts undo the change. Restart the client afterwards.

Use Cases

Domain-agnostic by design.

Anywhere an agent should know tomorrow what it learned today.

Coding agents

Repository layout, conventions, what a function does, and why a decision was made, so a fresh session doesn't re-scan the tree.

Writing

A house style, character and world facts, and continuity across a long document or a whole series.

Email & calendar

Preferences, recurring participants, and standing instructions your assistant should never need to be told twice.

Team knowledge

A shared tenant so multiple agents, and the people working alongside them, draw on the same memory.

Quick Start

Up and remembering in minutes.

Self-hosted with Docker Compose. One clone, one command.

1

Clone & launch

$ git clone https://github.com/jchristn/NotDory.git
$ cd NotDory/docker
$ cp .env.example .env
$ docker compose up -d --build

The API server, MCP server, dashboard, RecallDB, Postgres with pgvector, and the Prometheus, Tempo, Loki, and Grafana stack all come up together. Add --profile rerank (or rerank-gpu) for a cross-encoder reranker.

2

Connect your agent

$ sh scripts/macos/install-claude.sh

Pick the installer for your harness and OS (see Agents). With no access key it uses the local-dev default, notdorydefaultkey. Restart the client.

3

Just keep working

Your agent calls session_start, searches memory before answering or changing code, and saves decisions, facts, preferences, and corrections as it goes. Tomorrow, it remembers.

Local endpoints & default credentials

Dashboard 127.0.0.1:8701
MCP 127.0.0.1:8720/mcp
Admin login admin@notdory.local
Password notdoryadmin

Change the defaults before any shared deployment. NotDory is alpha: APIs and schemas will change between 0.1.x builds.

Just keep swimming. And keep remembering.

Give your agents a memory that outlasts the session. Open source, MIT licensed, and self-hosted.

Get Started on GitHub Read the Docs