> ## Content Index
> Fetch the complete content index at: https://matveev.tech/llms.txt
> Use this file to discover other available public pages before exploring further.

# Память AI-агентов: контекст, RAG, графы и mem0
- URL: https://matveev.tech/pamyat-ai-agentov-rag-grafy-mem0/
- Published: 2026-03-13T15:45:17.000Z
- Updated: 2026-03-13T15:45:17.000Z
- Description: Полный разбор памяти AI-агентов — от простого trimming до графовых баз. Какой тип для какой задачи.
- Author: Pavel Matveev
- Tags: AI, Агенты, Глоссарий

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

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

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

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

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

**Суммаризация** — когда чат приближается к лимиту контекста, вызывается отдельный промпт, который сжимает всю историю в краткое саммари. В OpenAI Codex CLI это видно прямо в консоли: процент свободного контекста падает до нуля, потом резко подскакивает обратно до 70%. По [данным JetBrains Research](https://blog.jetbrains.com/research/2025/12/efficient-context-management?ref=matveev.tech), суммаризация теоретически позволяет масштабировать диалог бесконечно, но на практике с каждым циклом сжатия теряется всё больше деталей. Через 4-5 компактингов от изначальной задачи может не остаться ничего — она превращается в «гомеопатический промпт».

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

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

Согласно [исследованию Anthropic по context engineering](https://www.anthropic.com/engineering/effective-context-engineering-for-ai-agents?ref=matveev.tech), ключ не в том, чтобы дать модели больше памяти, а в том, чтобы дать ей нужную информацию в нужный момент.

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

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

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

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

Подробнее я писал про это в [обзоре Agent Teams в Claude Code](https://matveev.tech/claude-code-agent-teams-instrukciya/) и в статье про [мультиагенты в OpenAI Codex](https://matveev.tech/codex-multi-agent-setup/).

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

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

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

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

По сути, auto-memory превращает файловую систему в долгосрочное хранилище. Никаких баз данных, никаких эмбеддингов — просто markdown-файлы. И по [бенчмаркам Letta](https://www.letta.com/blog/benchmarking-ai-agent-memory?ref=matveev.tech), filesystem-подход набирает 74% на бенчмарке LoCoMo, обгоняя некоторые специализированные решения.

Подробный гайд я писал в статье [Память Claude Code — auto memory, rules и CLAUDE.md](https://matveev.tech/claude-code-memory-auto-rules/).

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

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

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

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

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

Но у RAG есть ограничение: он находит **похожие** тексты, но не понимает **связи** между ними. Если спросить «как менялись мои предпочтения за последний год» — RAG вернёт отдельные кусочки, но не выстроит цепочку изменений. По [данным Mem0](https://mem0.ai/blog/rag-vs-ai-memory?ref=matveev.tech), RAG отвечает на вопрос «что похоже на X?», а не «как X связан с Y?».

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

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

### mem0

[Mem0](https://mem0.ai/?ref=matveev.tech) — open-source решение, которое комбинирует RAG и графы. На каждое сообщение пользователя текст прогоняется дважды: сначала через RAG + граф для поиска релевантных воспоминаний, потом — для добавления новых фактов. LLM раскладывает высказывания на сущности и обновляет граф связей.

По [бенчмаркам](https://guptadeepak.com/the-ai-memory-wars-why-one-system-crushed-the-competition-and-its-not-openai?ref=matveev.tech), mem0 обгоняет OpenAI Memory на 26% по точности с задержкой на 91% меньше. Причём сам mem0 использует для процессинга дешёвую LLM — можно поставить хоть Gemini Flash, хоть локальную модель.

### Zep

[Zep](https://www.getzep.com/?ref=matveev.tech) добавляет к графам временные метки — факты ранжируются по актуальности. «Павел жил в Москве» (2023) уступает приоритету «Павел живёт в Тбилиси» (2026). Но бесплатная версия Zep больше не поддерживается, новые версии — только в виде облачного решения.

### Letta (бывший MemGPT)

[Letta](https://www.letta.com/?ref=matveev.tech) пошла дальше — модель сама управляет своей памятью. Решает, что хранить в «рабочей памяти» (горячие факты), что архивировать (холодное хранилище), а что забыть. По концепции это ближе всего к тому, как работает человеческая память. 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 с базой знаний — оптимальный вариант.

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

- [Память Claude Code — auto memory, rules и CLAUDE.md](https://matveev.tech/claude-code-memory-auto-rules/) — подробный гайд по настройке памяти в Claude Code
- [Agent Teams в Claude Code: как запустить команду AI-агентов](https://matveev.tech/claude-code-agent-teams-instrukciya/) — субагенты с отдельным контекстом
- [Мультиагенты в OpenAI Codex — настройка и примеры](https://matveev.tech/codex-multi-agent-setup/) — аналогичный подход в Codex
- [Claude Code: как сэкономить токены на MCP с Tool Search](https://matveev.tech/claude-code-tool-search-mcp-tokeny/) — RAG и инструменты через MCP
- [21 плагин Claude Cowork — честный рейтинг](https://matveev.tech/claude-cowork-plugins-tier-list/) — обзор экосистемы расширений