Персистентная память для Claude Code: claude-mem против самодельного решения
Claude Code забывает решения за 4 часа? claude-mem против самодельных решений — полное руководство по персистентной памяти
Проблема, с которой рано или поздно сталкивается каждый пользователь Claude Code
Четыре часа интенсивной сессии рефакторинга — и Claude Code вдруг забывает архитектурные решения, принятые в первый час. Соглашение о стиле именования переменных, достигнутое ранее? Исчезло. Причина, по которой конкретная библиотека была выбрана из трёх альтернатив? Испарилась. Это не баг — так работают контекстные окна, и это стоит реального времени разработки.
Согласно подробному анализу на SitePoint, исследование Liu et al. (2023) показывает, что точность снижается для информации, расположенной в середине контекста при задачах извлечения — феномен, известный как «Потерянное в середине» (Lost in the Middle). Контекстное окно Claude Code усугубляет эту проблему: каждое сообщение обрабатывает всю историю разговора, и когда окно заполняется, система «компактифицирует» контекст, резюмируя старые сообщения для освобождения места.
Как объясняет Винсент ван Дет, автокомпактификация срабатывает, когда использование контекста достигает примерно 80–95%, и компромисс жесток: обсуждение архитектуры на 50 строк сжимается до одного предложения. Качество деградирует постепенно перед достижением жёсткого предела — то, что разработчики называют «гниением контекста» (context rot).
Проще говоря: Claude Code не запоминает ничего между сессиями, а в рамках длинных сессий постепенно забывает.
Почему это важно не только из-за раздражения разработчиков
Бизнес-последствия потери контекста выходят далеко за рамки неудобства. Когда ИИ-ассистент для кодирования забывает ранее принятые решения, разработчики повторяют объяснения, заново устанавливают ограничения и отлаживают проблемы, которые уже были решены. Согласно опросу разработчиков 2026 года от Digital Applied, проверка кода, сгенерированного ИИ, теперь занимает медианных 11,4 часа в неделю — рост на 31% по сравнению с прошлым годом — тогда как написание нового кода составляет 9,8 часа в неделю. Активные пользователи агентных инструментов сообщали, что время на ревью возрастает до 14–16 часов в неделю.
Каждый раз, когда контекст сбрасывается, нагрузка на ревью возрастает. Разработчики тратят время на проверку того, что Claude Code не противоречит ранее принятым решениям, вместо того чтобы создавать функциональность. Учитывая, что код, написанный с помощью ИИ, составляет уже более 46% всего кода в 2026 году, по сравнению с примерно 15% в 2023 году, цена нарушенного контекста умножается на всю кодовую базу.
Реальные цифры: если команда из пяти разработчиков теряет по 30 минут в день на восстановление контекста, это 12,5 часов в неделю — эквивалент неполной ставки разработчика, который не делает ничего, кроме повторения инструкций для ИИ.
NPS Claude Code на уровне +58 — необычно высокий для инструмента разработки — показывает, что разработчики любят инструмент, когда он работает. Персистентная память — это то, что позволяет ему работать на протяжении тех сессий, в которых по-настоящему строятся реальные проекты.
Что на самом деле означает персистентная память
Прежде чем погружаться в решения, полезно дать чёткое определение. Персистентная память для Claude Code — это структурированная информация, которая переживает три события:
- Компактификация контекста — когда окно заполняется в середине сессии
- Завершение сессии — когда разработчик закрывает терминал или начинает заново
- Переключение между проектами — когда происходит переход между кодовыми базами
Ключевой вывод из подробного разбора на DEV Community о кросс-сессионной памяти состоит в том, что наивные подходы — сброс всей информации в системный промпт — создают три проблемы: контекстное окно быстро заполняется, стоимость токенов растёт при каждом вызове, и в информации нет никакой структуры.
Эффективная персистентная память должна быть индексированной, категоризированной и достаточно компактной, чтобы загружаться, не съедая рабочее контекстное окно.
claude-mem: подход с богатой функциональностью
claude-mem — это npm-пакет, специально разработанный для добавления структурированной персистентной памяти в Claude Code. Он предоставляет управляемый слой поверх существующих возможностей Claude Code по чтению файлов, обеспечивая автоматическое извлечение, категоризацию и поиск информации для запоминания.
Как это работает
claude-mem работает по простому принципу: в конце каждой сессии (или через заданные интервалы) он извлекает информацию, достойную сохранения — пользовательские поправки, раскрывающие неочевидные предпочтения, архитектурные решения с обоснованием и специфические для проекта ограничения. Эта информация сохраняется в категоризированных markdown-файлах с метаданными в формате frontmatter.
Архитектура повторяет то, что в статье DEV Community описывается как паттерн структурированного хранилища памяти: индексный файл (обычно MEMORY.md), объём которого не превышает 200 строк и который всегда загружается, со ссылками на отдельные файлы памяти, организованные по темам.
Что обеспечивает claude-mem
- Автоматическое извлечение: определяет, что стоит запомнить, без ручных запросов
- Категоризация: разделяет пользовательские предпочтения, факты о проекте, архитектурные решения и паттерны рабочего процесса
- Обнаружение устаревания: помечает воспоминания, которые могут быть неактуальны, на основе изменений в файловой системе
- Бюджетирование токенов: удерживает объём памяти в настраиваемых лимитах, чтобы она не вытесняла рабочий контекст
Установка и особенности настройки
Для настройки claude-mem требуются Node.js и npm. Пакет устанавливается глобально и интегрируется с Claude Code через хуки — shell-команды, которые выполняются в ответ на события, такие как начало и завершение сессии.
Честная оценка: claude-mem добавляет зависимость в рабочий процесс. Для команд, уже управляющих сложными наборами инструментов, это мелочь. Для одиночных разработчиков, которым нужен минимум накладных расходов, стоит взвесить это против более простого подхода.
Самодельная лёгкая альтернатива: память на основе Markdown
Для команд, предпочитающих ноль зависимостей, система памяти на основе markdown, построенная на CLAUDE.md и структурированных файлах, даёт 80% ценности без внешних инструментов. По сути, это то, что документация самого Claude Code поддерживает нативно.
Архитектура
Система использует три уровня:
Уровень 1: CLAUDE.md как всегда загружаемый фундамент
CLAUDE.md находится в корне проекта, и Claude Code автоматически читает его при каждом запуске сессии. Этот файл содержит константы уровня проекта: технологический стек, конвенции, цели деплоя и критические ограничения. Думайте о нём как о документе для онбординга в команде — то, что каждому новому разработчику (или свежей сессии Claude) нужно знать сразу.
Уровень 2: Индексный файл памяти
Файл MEMORY.md в .claude/ выступает в роли оглавления. Он содержит однострочные ссылки на отдельные файлы памяти, но никогда сами воспоминания. Удержание его объёма в пределах 200 строк обеспечивает быструю загрузку и незначительное потребление контекста.
Уровень 3: Отдельные файлы памяти с frontmatter
Каждое воспоминание хранится в отдельном файле в .claude/memory/ со структурированным frontmatter:
---
name: api-pagination-standard
description: All list endpoints use cursor-based pagination, not offset
type: project
---
Cursor-based pagination adopted for all API list endpoints.
**Why:** Offset pagination breaks when items are inserted/deleted during traversal.
Large datasets (50k+ records in analytics tables) showed 3-5s latency with offset.
**How to apply:** Any new list endpoint must accept `cursor` and `limit` parameters.
Never implement offset-based pagination even for "simple" endpoints.
Эта структура — правило, затем почему, затем как применять — даёт Claude Code достаточно контекста для принятия решений в пограничных случаях, а не слепого следования правилу.
Пошаговая настройка
Шаг 1: Создайте структуру директорий
.claude/
├── memory/
│ ├── MEMORY.md # Только индекс — ссылки на файлы ниже
│ ├── user_preferences.md
│ ├── project_api_standards.md
│ ├── feedback_testing.md
│ └── reference_external_tools.md
Шаг 2: Определите категории памяти
Четыре категории покрывают большинство потребностей:
- Воспоминания о пользователе: роль, уровень экспертизы, предпочтительная глубина объяснений
- Воспоминания о проекте: архитектурные решения, дедлайны, ограничения от заинтересованных сторон
- Воспоминания из обратной связи: поправки и подтверждённые подходы из прошлых сессий
- Справочные воспоминания: ссылки на внешние системы (трекеры задач, дашборды, документация)
Шаг 3: Добавьте хук на старт сессии
Настройте хук в параметрах Claude Code, который инструктирует его читать MEMORY.md при каждом запуске сессии. Как рекомендует DEV Community, начало каждого сообщения с инструкции загрузки контекста обеспечивает непрерывность.
Шаг 4: Выработайте привычку на конец сессии
Каждые 20–30 минут во время длинной сессии — или при её завершении — попросите Claude извлечь то, что стоит запомнить, и записать в соответствующий файл памяти. Этот ручной шаг заменяет автоматическое извлечение claude-mem.
Шаг 5: Добавьте правило верификации
Это критически важно. Как предупреждает статья DEV Community о кросс-сессионной памяти, память устаревает. Воспоминание «авторизация находится в middleware/auth.ts» становится ложным в тот момент, когда кто-то переименовывает файл. Правило простое: прежде чем рекомендовать на основе памяти — проверьте. «Память говорит, что X существует» — не то же самое, что «X существует сейчас».
Добавьте это правило непосредственно в CLAUDE.md, чтобы оно сохранялось между всеми сессиями.
Бюджетирование контекстного окна
Руководство SitePoint рекомендует следить, чтобы ни одна сессия не превышала 60% использования контекста, с проактивной компактификацией на отметке 60%. Самодельная система памяти поддерживает это, сохраняя всегда загружаемый контент (CLAUDE.md + индекс MEMORY.md) компактным — в идеале до 300 строк суммарно — и загружая отдельные файлы памяти только при необходимости.
Реальные цифры: хорошо структурированный индекс MEMORY.md на 150 строк плюс CLAUDE.md на 100 строк потребляют примерно 1–2% контекстного окна Claude Code. Отдельные файлы памяти, загружаемые по требованию, добавляют по 0,1–0,5% каждый. Суммарные накладные расходы на персистентную память остаются ниже 5% даже при 20+ файлах памяти, к которым обращались за сессию.
Сравните это со стоимостью отсутствия памяти: повторное объяснение архитектуры проекта занимает 500–1000 токенов за сессию, плюс контекст, потребляемый уточняющими вопросами Claude, которые он не должен был бы задавать.
claude-mem против самодельного решения: честное сравнение
| Фактор | claude-mem | Самодельный Markdown |
|---|---|---|
| Время настройки | 5–10 минут | 30–60 минут |
| Зависимости | npm-пакет | Отсутствуют |
| Автоматическое извлечение | Да | Ручное (через промпты) |
| Обнаружение устаревания | Встроенное | Ручное правило в CLAUDE.md |
| Кастомизация | Параметры конфигурации | Полностью настраиваемая |
| Накладные расходы на токены | Управляются автоматически | Ручное бюджетирование |
| Онбординг команды | Установить и настроить | Задокументировать конвенцию |
| Переносимость | Привязана к claude-mem | Работает с любым инструментом, читающим markdown |
| Обслуживание | Обновления пакета | Самостоятельное |
Вот наша рекомендация: для одиночных разработчиков или небольших команд (2–3 человека), работающих с 1–2 проектами, самодельный подход достаточен и сохраняет набор инструментов компактным. Для команд, управляющих несколькими проектами с ротацией разработчиков, автоматическое извлечение и обнаружение устаревания claude-mem экономят достаточно ручного труда, чтобы оправдать зависимость.
Безопасность: что раскрывает персистентная память
В блоге по исследованию безопасности Cisco описан proof-of-concept, при котором персистентная память могла быть скомпрометирована — отравленная инструкция сохранялась «за пределами текущей сессии, проникая в каждый проект, каждую сессию и даже после перезагрузок». Anthropic устранила это в Claude Code v2.1.50, но основной урок остаётся.
Файлы персистентной памяти доступны для чтения Claude Code и всему остальному, что имеет доступ к файловой системе. Три правила предотвращают проблемы:
- Никогда не храните секреты в файлах памяти. API-ключи, токены и пароли должны находиться в файлах
.envс ограниченными правами доступа — а не в markdown-файлах, которые Claude загружает в своё контекстное окно. - Периодически проверяйте файлы памяти. Если файл памяти содержит инструкции, которые кажутся необычными или не были написаны членом команды, проведите расследование до того, как следующая сессия загрузит его.
- Храните файлы памяти в системе контроля версий. История Git позволяет отследить, когда воспоминание было добавлено и кем. Для приватных репозиториев это безопасно. Для публичных — проведите аудит содержимого памяти перед отправкой.
Что это значит для вашего проекта: персистентная память безопасна, когда к ней относятся как к любому другому конфигурационному файлу — проверяемому, хранящемуся в системе контроля версий и не содержащему секретов.
Комбинирование обоих подходов для максимального эффекта
Наиболее надёжная конфигурация использует самодельную markdown-структуру как фундамент с выборочной автоматизацией, наложенной поверх. Файл CLAUDE.md и структура директорий памяти работают независимо от того, установлен claude-mem или нет, обеспечивая запасной вариант на случай удаления или замены пакета.
Практический комбинированный рабочий процесс
- CLAUDE.md содержит константы проекта, которые редко меняются — технологический стек, правила безопасности, цели деплоя
- Индекс MEMORY.md указывает на категоризированные файлы памяти
- Хук на старт сессии автоматически загружает индекс
- Ручное или claude-mem извлечение записывает новые воспоминания при завершении сессии
- Периодический обзор (еженедельно для активных проектов) удаляет устаревшие воспоминания
Как отмечает анализ Винсента ван Дета, оптимальный момент для управления контекстом — пока он ещё здоров: агент при 60% контекста пишет чёткие, структурированные передачи, тогда как агент при 78% пишет расплывчатые резюме и упускает критическое состояние. Тот же принцип применим к памяти: извлекайте воспоминания, пока сессия свежая, а не когда контекст уже деградировал.
Когда персистентная память — не ответ
Не каждая проблема — это проблема памяти. Некоторые типичные проблемы с контекстом имеют более простые решения:
- Потеря хода работы в середине сессии: Используйте
/compactпроактивно на естественных границах задач, как рекомендует MindStudio, а не когда качество уже деградировало. - Забыли, какие файлы были изменены: Используйте сообщения git commit как якоря контекста. Как предлагает DEV Community, просмотр последних 3 сообщений коммитов восстанавливает картину того, что было сделано.
- Плохой старт свежих сессий: Свежая сессия, начинающаяся с CLAUDE.md без необходимости компактификации, остаётся сфокусированной и экономичной — зачастую общая стоимость ниже, чем у одной марафонской сессии, при стабильном качестве на протяжении всей работы.
Честная оценка: персистентная память решает проблему знаний между сессиями. Она не исправляет плохую гигиену сессий. Короткие, сфокусированные сессии с чёткими передачами всегда будут эффективнее марафонских сессий с навороченными системами памяти, приделанными сбоку.
Часто задаваемые вопросы
Как безопасно использовать персистентную память, не раскрывая секреты?
Файлы памяти должны содержать решения, предпочтения и архитектурный контекст — никогда учётные данные. Переменные окружения и API-ключи должны находиться исключительно в файлах .env с правами доступа chmod 600. Если воспоминание ссылается на внешний сервис, сохраняйте название сервиса и его назначение, а не токен доступа.
В чём разница между памятью на основе базы данных и системами памяти на основе markdown?
Память на основе базы данных поддерживает запросы, полнотекстовый поиск и конкурентный доступ в распределённых системах. Память на основе markdown работает через чтение файлов — проще, без зависимостей и напрямую совместима с нативным поведением Claude Code по чтению файлов. Для одного разработчика или небольшой команды markdown достаточен. Системы на базе данных оправданы, когда память нужно разделять между несколькими ИИ-агентами или сервисами.
Сколько контекстного окна занимает добавление персистентной памяти?
Хорошо структурированная система с индексом MEMORY.md на 150 строк и CLAUDE.md до 100 строк потребляет примерно 1–2% контекстного окна. Отдельные файлы памяти, загружаемые по требованию, добавляют по 0,1–0,5% каждый. Даже при обращении к 20+ файлам памяти за сессию общие накладные расходы остаются ниже 5% — значительно меньше, чем стоимость повторного объяснения контекста проекта с нуля.
Стоит ли выбрать лёгкое решение вместо функционально богатого, такого как claude-mem?
Для одиночных разработчиков или команд из 2–3 человек с небольшим количеством проектов самодельный markdown-подход даёт отличные результаты без зависимостей. Команды, управляющие несколькими проектами с ротацией участников, получают выгоду от автоматического извлечения и обнаружения устаревания claude-mem. Начните с самодельного решения; добавляйте инструментарий, когда ручные усилия по извлечению памяти станут узким местом.
Ключевой вывод для бизнеса
Персистентная память превращает Claude Code из способного, но страдающего амнезией ассистента в члена команды, сохраняющего знания о проекте. Выбор между claude-mem и самодельным markdown менее важен, чем решение внедрить структурированную память вообще.
Три вывода для команд, оценивающих этот подход:
- Начните с самодельного подхода. Его настройка занимает менее часа, не требует зависимостей и даёт немедленную пользу. Структура директорий и конвенции CLAUDE.md работают как фундамент, даже если позже будет добавлен claude-mem.
- Выделите 5% контекста на память — сэкономьте 30+ минут за сессию. Математика проста: небольшие инвестиции в постоянно загружаемый контекст устраняют повторяющиеся объяснения и снижают нагрузку на ревью кода, сгенерированного ИИ.
- Относитесь к памяти как к коду: под контролем версий, с проверками и без секретов. Исследование безопасности Cisco, посвящённое компрометации памяти, делает это требование безусловным. Персистентная память мощна именно потому, что загружается автоматически — а значит, она должна быть достоверной.
Учитывая, что 85% разработчиков теперь регулярно используют ИИ-инструменты, а уровень доверия разработчиков составляет лишь 29%, разрыв между «использованием ИИ» и «эффективным использованием ИИ» — это то место, где команды приобретают или теряют конкурентное преимущество. Персистентная память — один из самых простых способов сократить этот разрыв.
Статья подготовлена на основе открытых источников и может содержать неточности.


