AI

Память AI-агентов: контекст, RAG, графы и mem0

Полный разбор памяти AI-агентов — от простого trimming до графовых баз. Какой тип для какой задачи.

Pavel Matveev

Pavel Matveev

— 6 min read
Память AI-агентов: контекст, RAG, графы и mem0
TL;DR: Память AI-агентов — это набор техник, которые позволяют LLM «помнить» информацию между запросами и сессиями. От простой суммаризации чата до графовых баз вроде mem0 — каждый подход решает свою задачу. Разбираю, что реально работает, а что оверинжиниринг.

Контекстное окно LLM — это как оперативка компьютера. Сколько информации модель может «видеть» за один вызов. У GPT-5.4 это уже миллион токенов, у Claude Opus 4.6 — 200 тысяч. Звучит много, но на практике этого не хватает. Длинные сессии с кодинг-агентом, многочасовые задачи, история из сотен сообщений — контекст кончается быстрее, чем кажется.

И когда контекст заканчивается, агент буквально забывает, что было в начале разговора. Он может потерять изначальную задачу, забыть важные решения или начать повторять ошибки, которые уже исправлял. Это фундаментальная проблема, и разные инструменты решают её по-разному.

Простая память: суммаризация, тримминг, контекст ревайнд

Самый базовый подход — манипуляции с контекстным окном. Три основные техники:

Суммаризация — когда чат приближается к лимиту контекста, вызывается отдельный промпт, который сжимает всю историю в краткое саммари. В OpenAI Codex CLI это видно прямо в консоли: процент свободного контекста падает до нуля, потом резко подскакивает обратно до 70%. По данным JetBrains Research, суммаризация теоретически позволяет масштабировать диалог бесконечно, но на практике с каждым циклом сжатия теряется всё больше деталей. Через 4-5 компактингов от изначальной задачи может не остаться ничего — она превращается в «гомеопатический промпт».

Тримминг — ещё грубее. Просто берём последние N сообщений и отбрасываем всё остальное. Именно так работает Simple Memory в n8n: выставляешь window size = 5, и агент видит только пять последних сообщений. Быстро, дёшево, предсказуемо. Но старая информация жёстко утрачена — никакого шанса к ней вернуться.

Контекст ревайнд (undo/rewind) — возврат к чекпоинту диалога и продолжение заново. Не решает проблему конечного контекста напрямую, но позволяет откатиться до момента, когда агент начал галлюцинировать или пошёл не туда. Claude Code поддерживает это из коробки.

Согласно исследованию Anthropic по context engineering, ключ не в том, чтобы дать модели больше памяти, а в том, чтобы дать ей нужную информацию в нужный момент.

Субагенты: разделяй контекст и властвуй

Когда одного контекстного окна не хватает — можно взять несколько. Субагенты в Claude Code это подчинённые агенты с отдельным контекстом, инструментами и системным промптом. Главный агент-координатор раздаёт задачи, а каждый субагент работает в своём изолированном контексте.

Например, при разработке веб-приложения можно создать backend-dev, frontend-dev и deploy-агента. Детали кода бэкенда живут только в контексте бэкенд-разработчика, фронтенд — в своём. Координатор держит в контексте только общую картину. Это не просто увеличенная суммарная память — субагенты могут работать параллельно, экономя время.

А в Agent Teams (экспериментальная фича Claude Code) главный агент сам решает, каких подчинённых создать и как распределить задачи. Полезно для задач вроде «задокументируй огромную кодовую базу» — можно запустить 10 аналитиков на 10 модулей.

Подробнее я писал про это в обзоре Agent Teams в Claude Code и в статье про мультиагенты в OpenAI Codex.

Auto-memory: файловая система как долгосрочная память

Auto-memory — это когда агент сам решает, что запомнить, и записывает это в файлы, которые переживают перезапуск сессии.

В Claude Code это работает так: включаешь флаг auto-memory, и агент начинает сохранять полезные факты в файл memory.md внутри .claude/projects/. При следующем запуске первые 200 строк этого файла попадают в системный промпт. Если агент видит ссылки на более глубокие md-файлы — он может копнуть дальше.

Memory-файлы хранят факты о проекте — какие инструменты используются, какие решения принимались. Каждый новый сеанс Claude Code начинается уже с контекстом проекта.

По сути, auto-memory превращает файловую систему в долгосрочное хранилище. Никаких баз данных, никаких эмбеддингов — просто markdown-файлы. И по бенчмаркам Letta, filesystem-подход набирает 74% на бенчмарке LoCoMo, обгоняя некоторые специализированные решения.

Подробный гайд я писал в статье Память Claude Code — auto memory, rules и CLAUDE.md.

Похожий подход — Memory Bank: сохранение структурированной информации о проекте в определённую папку. Модель читает файлы, когда нужен контекст, и пишет в них, когда узнаёт что-то полезное.

RAG: векторный поиск по большой базе

Когда данных слишком много для файлов — подключаем RAG (Retrieval-Augmented Generation). Принцип такой: сохраняем информацию в векторную базу, а при запросе ищем релевантные куски по смысловой близости через эмбеддинги.

Допустим, у тебя банковские выписки за несколько лет. Загружаешь их в RAG-хранилище, подключаешь через MCP к Claude Code — и можешь спросить «на что я тратил деньги в Тбилиси?». Агент вызовет RAG-инструмент, найдёт по эмбеддингам нужную страницу выписки и даст ответ.

RAG эффективен, когда нужен поиск по сотням и тысячам документов — там, где другие подходы просто не вместят всё в контекст. Через MCP можно подключить Qdrant, Pinecone, Weaviate и другие векторные базы.

Но у RAG есть ограничение: он находит похожие тексты, но не понимает связи между ними. Если спросить «как менялись мои предпочтения за последний год» — RAG вернёт отдельные кусочки, но не выстроит цепочку изменений. По данным Mem0, RAG отвечает на вопрос «что похоже на X?», а не «как X связан с Y?».

Графовая память: mem0, Zep, Letta

Графовые решения хранят не просто тексты, а сущности и связи между ними. Это как база знаний, где «Павел → живёт → Тбилиси» и «Павел → использует → Claude Code» — связанные факты, по которым можно проследить цепочки.

mem0

Mem0 — open-source решение, которое комбинирует RAG и графы. На каждое сообщение пользователя текст прогоняется дважды: сначала через RAG + граф для поиска релевантных воспоминаний, потом — для добавления новых фактов. LLM раскладывает высказывания на сущности и обновляет граф связей.

По бенчмаркам, mem0 обгоняет OpenAI Memory на 26% по точности с задержкой на 91% меньше. Причём сам mem0 использует для процессинга дешёвую LLM — можно поставить хоть Gemini Flash, хоть локальную модель.

Zep

Zep добавляет к графам временные метки — факты ранжируются по актуальности. «Павел жил в Москве» (2023) уступает приоритету «Павел живёт в Тбилиси» (2026). Но бесплатная версия Zep больше не поддерживается, новые версии — только в виде облачного решения.

Letta (бывший MemGPT)

Letta пошла дальше — модель сама управляет своей памятью. Решает, что хранить в «рабочей памяти» (горячие факты), что архивировать (холодное хранилище), а что забыть. По концепции это ближе всего к тому, как работает человеческая память. Letta набирает 74% на бенчмарке LoCoMo даже в filesystem-режиме, а с полной архитектурой — ещё больше.

Если честно, я не уверен, что графовая память нужна в каждом проекте. Для большинства задач auto-memory + RAG хватает с головой. Графы становятся полезными, когда у тебя длительные отношения с пользователем (персональный ассистент, который помнит предпочтения за месяцы) или когда нужно отслеживать изменения во времени.

Какой тип памяти для какой задачи

Задача Подход Почему
Короткий чат, 5-10 сообщений Тримминг Просто, предсказуемо, дёшево
Кодинг-сессия на пару часов Суммаризация + субагенты Контекст не кончится, детали не потеряются
Проект с инструкциями и правилами Auto-memory (CLAUDE.md) Файлы переживают перезапуск, легко редактировать
Поиск по сотням документов RAG через MCP Эмбеддинги находят нужное быстро
Персональный ассистент на месяцы mem0 / Zep Графы хранят связи и изменения
Автономный агент с субагентами Все вышеперечисленные Комбинация подходов для разных уровней

Моё мнение: что работает, а что оверинжиниринг

Я работаю с Claude Code каждый день, и вот что заметил: auto-memory в связке с хорошо структурированным CLAUDE.md покрывает 80% задач. Серьёзно. Просто файлы. Никаких баз данных. Агент читает инструкции, запоминает решения, при следующем запуске уже в контексте. Для pet-проектов, даже для продуктовой разработки в небольшой команде — этого хватает.

RAG нужен, когда данных реально много — тысячи документов, выписки, логи. Подключаешь через MCP и забываешь. Работает стабильно и предсказуемо.

А вот графовая память... Думаю, для большинства проектов это пока оверинжиниринг. Mem0 крутой технически, но добавляет слой сложности: нужно настраивать LLM для процессинга фактов, следить за качеством графа, дебажить связи. Мне кажется, это оправдано только для продуктов, где персонализация — ключевая фича. Ну, типа персональный AI-помощник, который работает с тобой месяцами и должен помнить, что ты любишь корейскую историю, но терпеть не можешь видеоклипы в рекомендациях YouTube.

Вообще, тренд идёт в сторону того, что инструменты памяти становятся стандартной частью агентских фреймворков, а не отдельными решениями. Anthropic уже встроила auto-memory в Claude Code. OpenAI добавила память в ChatGPT. Скорее всего, через год вопрос «как дать агенту память» будет звучать так же странно, как сейчас «как дать приложению базу данных» — это будет просто часть стандартного стека.

FAQ

Чем отличается RAG от графовой памяти? RAG ищет похожие тексты через эмбеддинги — как полнотекстовый поиск по смыслу. Графовая память хранит сущности и связи между ними. RAG ответит на вопрос «что похоже?», а граф — на вопрос «как связано?». Для большинства задач RAG достаточно, графы нужны для сложных отношений.

Можно ли использовать mem0 бесплатно? Да, mem0 open-source — можно развернуть локально. Нужна LLM для процессинга фактов (подойдёт даже дешёвая Gemini Flash через PolzaAI или любой OpenAI-совместимый провайдер) и хранилище для эмбеддингов. Облачная версия mem0 тоже есть, но для экспериментов хватит self-hosted.

Что лучше для кодинг-агента — RAG или auto-memory? Для кодинг-агента auto-memory (файлы с инструкциями и правилами проекта) работает лучше. RAG пригодится, если нужно искать по огромной кодовой базе или документации. Claude Code использует auto-memory по умолчанию, RAG подключается через MCP.

Как работает суммаризация контекста в Claude Code и Codex? Когда контекст приближается к лимиту, запускается отдельный вызов LLM, который сжимает историю до ключевых моментов. Свободное место в контексте подскакивает примерно до 70%. Процесс автоматический, но может терять детали — на длинных сессиях после 4-5 сжатий от начального промпта мало что остаётся.

Нужна ли графовая память для простого чат-бота? Нет, для простого бота хватит тримминга (последние N сообщений) или суммаризации. Графовая память оправдана, только если бот должен помнить пользователя неделями и отслеживать изменения в предпочтениях. Для большинства B2B-ботов и саппорт-чатов RAG с базой знаний — оптимальный вариант.

Что ещё почитать