Постоянная память для Claude Code: self-hosted настройка, которая переживает сессии

Начните отсюда: встроенная память Claude Code

У Claude Code два слоя встроенной памяти, и для соло-разработчика на одной машине их часто достаточно.

CLAUDE.md (пишете вы). Markdown-файл в проекте (или ~/.claude/CLAUDE.md для глобальных правил), загружаемый в каждую сессию. Здесь живут ваши инструкции: стиль кода, конвенции коммитов, команды для запуска. Вы его ведёте; он едет с репозиторием через git.

Авто-память (пишет Claude). С конца 2025 года Claude Code ведёт и собственный блокнот. По ходу работы он сохраняет команды сборки, находки при отладке и заметки об архитектуре в ~/.claude/projects/<encoded-path>/memory/MEMORY.md и подставляет этот файл в системный промпт в начале каждой сессии. MEMORY.md остаётся кратким индексом до 200 строк (это порог загрузки на старте); когда заметок накапливается много, Claude выносит детали в тематические файлы вроде debugging.md рядом. Включена по умолчанию; команда /memory открывает просмотр и переключатель. Правила можно привязать к путям через .claude/rules/*.md.

Назовём прямо, чего встроенная память не делает — именно этот пробел закрывают инструменты ниже:

• Она локальна для машины. Авто-память лежит под ~/.claude/ на одном компьютере и не попадает в git. Пересели на другой ноутбук — накопленные заметки агента с вами не поедут.
• Она не общая с командой. Встроенного способа для Claude коллеги прочитать то, что узнал ваш, нет.
• Она best-effort. В собственной документации Anthropic отмечено, что строгого соблюдения записанного не гарантируется; Claude сам решает, что стоит сохранить, и может перечитать неидеально.
• Она не масштабируется поиском. MEMORY.md загружается целиком до порога, а не запрашивается; за парой сотен строк хвост в контексте не гарантирован.

Если вы работаете в одиночку на одной машине, включите авто-память, держите конвенции в CLAUDE.md, и, возможно, больше ничего не нужно. Локальные плагины вроде MemPalace (MIT, на устройстве, запрос порядка миллисекунды) или claude-mem (AGPL-3.0, хуки плюс SQLite/FTS5) добавляют поиск сверху, оставаясь одномашинными.

Когда встроенной памяти мало

Идите дальше встроенной памяти, когда верно одно из:

• память должна ездить с вами по машинам (десктоп, ноутбук, CI);
• команда должна делить одну память, которую читает агент;
• нужна память долговечная и версионируемая, проверяемая как документы и восстановимая;
• нужна память и запрашиваемая по MCP, и просматриваемая как сайт.

Вот где self-hosted сервер оправдывает себя. Остаток гайда настраивает trip2g ровно под это: память как markdown-заметки на сервере, который вы контролируете, общая между машинами и коллегами, читаемая агентом по MCP.

Варианты вкратце

Честная ниша trip2g — в отличии последней строки: не «ещё одна локальная память», а память общая и публикуемая. Для одной машины авто-память или локальный плагин часто правильнее и дешевле, и эта уступка настоящая.

Что понадобится

• Docker локально
• Node.js (для memcli)
• Python 3 (для stdio-адаптера; только стандартная библиотека, без pip)
• установленный Claude Code

Шаг 1. Поднимите сервер памяти

Одна команда из чекаута trip2g (memcli лежит в репозитории уже собранным):

git clone https://github.com/trip2g/trip2g
node trip2g/cli/memcli/dist/memcli.js up --folder ./memory-vault

Дождитесь:

memory live — web: http://localhost:24081  read/write .md in ./memory-vault

Команда запустила сервер trip2g в Docker, выпустила административный API-ключ и включила вотчер синхронизации: любой .md-файл в ./memory-vault индексируется и находится поиском за ~500 мс. Секреты создаются один раз и переиспользуются, так что up идемпотентен.

Контрольная точка: откройте http://localhost:24081 в браузере. Вы должны увидеть (пока пустой) сайт вашей будущей памяти.

Шаг 2. Создайте токен доступа

MCP-адаптер аутентифицируется персональным токеном:

1. Откройте http://localhost:24081, войдите, перейдите в User → Tokens.
2. Нажмите Generate token, назовите его claude-code, скопируйте значение t2g_….

Токен показывается один раз. Обратите внимание: это не тот админский API-ключ, который выпустил memcli. Ключ работает в синхронизации, токен — в MCP. На этой разнице часто спотыкаются; подробности в справочнике MCP.

Шаг 3. Зарегистрируйте сервер в Claude Code

Два пути; для работы с памятью мы рекомендуем адаптер.

{
  "mcpServers": {
    "trip2g-memory": {
      "command": "python3",
      "args": ["/absolute/path/to/trip2g/docs/en/user/trip2g_mcp_stdio_adapter.py"],
      "env": {
        "TRIP2G_MCP_URL": "http://localhost:24081/_system/mcp",
        "TRIP2G_TOKEN": "t2g_your-token-here"
      }
    }
  }
}

claude mcp add --transport http trip2g-memory http://localhost:24081/_system/mcp \
  --header "Authorization: Bearer t2g_your-token-here"

Шаг 4. Проверьте

Откройте новую сессию Claude Code и выполните:

/mcp

trip2g-memory должен значиться подключённым. Затем попросите Claude:

Запиши в ./memory-vault заметку "memory-test.md" о том, что деплой-пользователь —
"deploy@prod-1". Потом найди через инструмент trip2g-memory "deploy user"
и процитируй, что нашлось.

Если поиск вернул только что записанный факт, память работает целиком: файл → синхронизация → индекс → recall по MCP. Если /mcp показывает ошибку подключения, проверьте, что путь к адаптеру абсолютный, а токен начинается с t2g_.

Более строгая проверка через сессии (тест, который действительно доказывает постоянство): велите Claude что-то запомнить, затем полностью закройте сессию и откройте новую:

Сессия 1: «Запомни, что этот проект деплоится командой `make ship`, а не `make deploy`.
           Запиши это в память.»
(закройте Claude Code, откройте заново в том же проекте)
Сессия 2: «Как задеплоить этот проект?»

Если Сессия 2 ответит make ship без повторных объяснений — память пережила настоящую границу сессии. Прогоните тот же тест на второй машине (указав TRIP2G_MCP_URL на общий инстанс), и ответ всё равно верен — а вот этого встроенная авто-память не умеет.

Шаг 5. Научите Claude ей пользоваться

Память накапливается, только если агент в неё пишет. Добавьте правила в CLAUDE.md:

## Memory
- REMEMBER: write durable facts (decisions, gotchas, environment details)
  as markdown files into ./memory-vault. One topic per file.
- RECALL: before re-deriving anything about this project, search
  trip2g-memory first. Read only the section you need.

Теперь сессии начинаются с припоминания, а не с пересказа. Цепочка извлечения (search → expand → note_html) читает один раздел вместо целой заметки — примерно в 15 раз дешевле по медиане на реальных заметках; замеры и воспроизводимый скрипт в бенчмарке экономии токенов.

Честно о трении

• Вы держите сервер. Память доступна, пока запущен Docker. У официального сервера памяти и CLAUDE.md такой зависимости нет.
• В общую базу ничего не захватывается само. Встроенная авто-память заметки сохраняет сама, но только на локальную машину. Чтобы память попала в общую базу между машинами, заметку пишете вы (или агент по инструкции). Mem0 извлекает факты из переписки без просьбы; trip2g меняет это удобство на память, которую можно проверить и разделить.
• Две учётки. Админский API-ключ (синхронизация) и персональный токен (MCP) — разные вещи, а сообщения об ошибках при их путанице пока не блестящие.

За пределами одной машины

Всё выше крутится на localhost, но сервер не обязан быть локальным. Направьте TRIP2G_MCP_URL на любой инстанс trip2g, и та же память будет с вами на всех машинах, с доступом по токену. Команда может делить одну базу памяти: каждый видит подграфы, разрешённые его подпиской. А через федерацию один поиск разлетается из вашей памяти по базам знаний партнёров; memcli даже создаёт стартовую hub-заметку сам.

FAQ

Чем это отличается от CLAUDE.md?
CLAUDE.md — один файл, целиком загружаемый в каждую сессию; он ест контекст всегда и не масштабируется дальше пары сотен строк. Сервер памяти ищется по запросу: сотни заметок не стоят ничего, пока одна из них не понадобилась.

А от встроенной авто-памяти Claude Code?
Авто-память (~/.claude/projects/<hash>/memory/MEMORY.md) локальна для машины, best-effort и грузится целиком до порога ~200 строк; она не разделяется с другими машинами и коллегами и не ищется. Сервер памяти — это база с поиском, версиями и контролем доступа, общая для машин и агентов. Они хорошо сочетаются: авто-память — на привычки машины, сервер — на долговечные общие знания.

Если у Claude Code уже есть память, зачем вообще сервер?
Для соло-разработчика на одной машине часто незачем: включите авто-память и держите конвенции в CLAUDE.md. Сервер нужен, когда память должна ходить между машинами, быть общей с командой, версионироваться и проверяться или работать ещё и как сайт. Ровно ради этих четырёх пунктов страница и существует.

Claude сам пишет воспоминания?
В локальную авто-память — да, на этой машине. В общую базу trip2g — только по инструкции (шаг 5), и это сознательно: в общей памяти лежит то, что записано намеренно. Если нужно автоизвлечение из переписки — честно лучше Mem0, мы так и пишем выше.

Могу ли я править то, что Claude помнит?
Да. Заметки памяти — это файлы в ./memory-vault; правьте их в Obsidian или любом редакторе, вотчер синхронизирует правку за ~500 мс. Удалили файл — удалили воспоминание.

А история памяти?
Каждая правка версионируется на сервере (note_versions) и зеркалируется в git: можно посмотреть diff, как воспоминание менялось, или восстановить затёртую заметку.

Работает с Cursor, Codex, другими агентами?
Да, со всем, что говорит на MCP: тот же конфиг адаптера работает в Cursor и Claude Desktop. Базе памяти всё равно, какой агент к ней обращается, а значит все ваши агенты делят одну память.

Сколько это стоит?
Софт под MIT и self-hosted; вы платите только за машину с Docker. Никаких тарифов за место или количество воспоминаний.

Память куда-то отправляется?
Нет. Сервер работает на вашей машине, и заметки покидают её, только если вы явно их федерируете или публикуете.

Смотрите также

• Долгосрочная память для ИИ-агентов — полный справочник, на котором основан туториал
• Обзор MCP-серверов памяти — как соотносятся варианты
• memcli — всё, что делает запуск одной командой
• Stdio-адаптер — один инструмент, ровно нужный раздел
• LLM Wiki — как память вырастает в базу знаний