Цель лекции
Сравнить Mem0, Zep и Letta как разные архитектурные ответы на задачу agent memory и показать, как выбирать между ними на практике.
Ожидаемый результат
Читатель умеет сопоставить framework с задачей: персонализация, temporal graph, stateful agent runtime или hybrid stack. Он понимает, почему benchmark results нужно читать вместе с workload, latency, governance и cost.
Зачем это нужно
После трех vendor-focused лекций легко сделать неправильный вывод:
Нужно выбрать одного победителя.
На практике это не конкурс "лучший memory framework". Это выбор архитектурной формы.
Mem0, Zep и Letta отвечают на разные вопросы:
- Mem0: как компактно помнить user facts and preferences?
- Zep: как хранить меняющиеся факты и отношения во времени?
- Letta: как сделать долгоживущего агента, который управляет своим контекстом?
Они могут конкурировать, но могут и дополнять друг друга.
Основная идея
Выбор framework должен идти от dominant memory problem.
Если главная проблема - персонализация, смотрите на Mem0-style memory.
Если главная проблема - temporal entities and governance, смотрите на Zep-style graph memory.
Если главная проблема - autonomous stateful agent, смотрите на Letta-style runtime.
Не начинайте с названия инструмента. Начните с того, что именно должно помнить приложение.
Сравнительная таблица
| Критерий | Mem0 | Zep / Graphiti | Letta |
|---|---|---|---|
| Основной тип памяти | User facts, preferences, compact records | Temporal entities, facts, relationships | Agent state, memory blocks, archival memory |
| Центр архитектуры | Memory service/API | Context Graph / managed graph memory | Stateful agent runtime |
| Кто управляет памятью | Framework + application policies | Graph pipeline + platform governance | Agent через tools + runtime constraints |
| Retrieval model | Hybrid search, filters, entity matching | Hybrid semantic, keyword, graph, temporal search | Context hierarchy + tools + archival search |
| Сильный сценарий | B2C personalization | Enterprise factual memory over time | Long-running autonomous agents |
| Token efficiency | Высокая за счет compact records | Высокая за счет selected graph context | Зависит от block design and agent policy |
| Self-hosting complexity | Обычно ниже | Выше для graph stack | Средняя: server/runtime/database |
| Governance | Нужно дополнять приложением | Сильнее выражено в managed Zep | Нужно проектировать вокруг tool permissions |
| Главный риск | Лишние или устаревшие preferences | Сложность graph modeling and permissions | Агент портит собственную память |
| Не заменяет | Product policies and user UI | Source-of-truth systems | Business database and compliance layer |
Decision tree
Как встроить memory framework в AI stack
Типовая production-схема:
Главный принцип: framework не должен быть напрямую открыт клиенту.
Правильный поток:
- Приложение получает user event.
- Policy layer решает, можно ли писать память.
- Framework извлекает или обновляет memory.
- Retrieval возвращает candidates.
- Context assembly решает, что вставить в prompt.
- Observability фиксирует read/write decisions.
Инфраструктурные требования
| Компонент | Mem0-style | Zep/Graphiti-style | Letta-style |
|---|---|---|---|
| LLM extraction | Нужен для memory extraction | Нужен для entity/relation extraction | Нужен для agent steps and memory tools |
| Embeddings | Обычно нужны | Обычно нужны | Могут быть нужны для archival/search |
| Vector/search backend | Часто нужен | Часть hybrid retrieval | Опционально или внешне |
| Graph backend | Не всегда нужен; зависит от версии/режима | Центральный компонент | Обычно не центральный |
| Runtime server | Может быть managed/SDK | Managed или self-host graph services | Центральный компонент |
| SQL/database | Для app state и audit | Для app state плюс graph infra | Для persistent agent state |
| Observability | Memory CRUD + retrieval traces | Graph extraction + retrieval traces | Tool calls + state evolution |
Бенчмарки: что они показывают
Публичные memory benchmarks обычно проверяют несколько способностей:
- information extraction;
- multi-session reasoning;
- knowledge updates;
- temporal reasoning;
- abstention;
- event ordering;
- preference following;
- context compression;
- retrieval latency;
- token cost.
Например, LongMemEval проверяет long-term memory chat assistants через вопросы по длинной истории и включает abilities вроде information extraction, multi-session reasoning, knowledge updates, temporal reasoning и abstention.
LongMemEval-V2 переносит фокус ближе к agentic context: истории web-agent trajectories, reusable environment experience, dynamic state tracking and workflow knowledge.
Как читать результаты Mem0, Zep и Letta
Mem0 публикует benchmark claims по LoCoMo, LongMemEval and BEAM с акцентом на token efficiency: высокая accuracy при ограниченном числе токенов в retrieval call.
Graphiti/Zep материалы делают акцент на temporal graph retrieval, point-in-time reasoning, hybrid graph search and low-latency retrieval.
Letta Leaderboard оценивает stateful agents через memory reading, writing and updating, отдельно для core memory and archival memory.
Это разные оси.
Нельзя честно сказать:
Framework A всегда лучше Framework B.
Нужно говорить:
Framework A лучше на такой-то memory ability,
при такой-то методике,
на таком-то workload,
с такой-то latency and token budget.
Почему "Zep выигрывает temporal queries" не универсальный вывод
Интуитивно temporal graph должен хорошо работать на запросах о времени:
Where did Alice live before 2025?
What changed after the last contract?
Which preference is current?
Но конкретный benchmark result зависит от:
- dataset;
- extraction quality;
- temporal metadata;
- LLM used for extraction;
- answer grader;
- retrieval budget;
- whether full-history baseline is allowed;
- production latency constraints;
- domain schema.
Если ваш продукт задает много temporal/entity questions, Zep-style graph memory может быть сильным кандидатом. Но все равно нужно проверить на ваших данных.
Как построить свой evaluation harness
Минимальный набор тестов:
| Test type | Что проверяет |
|---|---|
| Preference update | Новое предпочтение заменяет старое или корректно помечает его stale. |
| Temporal query | Агент различает "сейчас", "раньше" и "на дату". |
| Entity disambiguation | Alice Smith и Alice Johnson не смешиваются. |
| Deletion | Удаленная memory не возвращается из vector/search/graph/cache. |
| Permission | Пользователь не видит memory другого tenant. |
| Abstention | Агент говорит "не знаю", если память не содержит ответа. |
| Tool self-edit | Agent-managed memory не портит critical policy. |
| Token budget | Retrieval не раздувает prompt сверх лимита. |
Для каждого framework нужен один и тот же evaluation set, иначе сравнение будет нечестным.
Паттерны выбора
Pattern 1. Personalization-first assistant
Dominant memory:
- preferences;
- profile facts;
- recurring habits.
Good fit:
- Mem0-style memory framework.
Add:
- consent UI;
- delete/edit memory;
- sensitive data filter;
- correction-rate metric.
Pattern 2. Enterprise account memory
Dominant memory:
- companies;
- contracts;
- people;
- changing relationships;
- permissions;
- audit.
Good fit:
- Zep-style managed graph memory
or Graphiti if self-hosting is required.
Add:
- IAM;
- legal retention;
- source citations;
- permission-aware traversal tests.
Pattern 3. Autonomous work agent
Dominant memory:
- agent state;
- current goals;
- tool usage;
- self-updated context;
- long-running workflows.
Good fit:
- Letta-style stateful runtime.
Add:
- tool permissions;
- state evolution tests;
- memory block limits;
- human review for risky changes.
Pattern 4. Hybrid stack
Иногда один framework не закрывает все.
Пример:
Letta runtime for autonomous agent state.
Mem0-style memory for user preferences.
Zep-style graph for enterprise account facts.
Custom SQL for source-of-truth and audit.
Это сложнее, но честнее, если product requirements действительно разные.
Практический checklist перед выбором
Перед внедрением спросите:
- Какие memory abilities являются core для продукта?
- Нужны ли temporal facts?
- Кто должен управлять memory: framework, приложение или сам агент?
- Как пользователь видит и исправляет память?
- Как работает deletion?
- Где source of truth?
- Какой latency budget?
- Какие данные запрещено хранить?
- Какие benchmark scenarios похожи на ваш workload?
- Что будет, если extraction ошибется?
- Как вы откатите плохую memory?
- Можно ли сменить framework без миграционной катастрофы?
Типичные ошибки
Ошибка 1: выбирать по leaderboard.
Leaderboard помогает задавать вопросы, но не заменяет architecture review.
Ошибка 2: сравнивать разные abilities как один score.
Temporal reasoning, personalization и self-editing context - разные задачи.
Ошибка 3: забывать стоимость extraction.
Memory write может быть дорогим, если каждое сообщение вызывает LLM extractor.
Ошибка 4: игнорировать operational complexity.
Graph stack и agent runtime требуют поддержки.
Ошибка 5: не отделять source of truth от memory cache.
CRM, billing, policy documents и repo files часто важнее framework memory.
Ошибка 6: не планировать migration.
Memory records, embeddings, graph edges and agent state должны быть переносимы или хотя бы экспортируемы.
Источники для дальнейшего чтения
- Mem0 research: https://mem0.ai/research
- Zep vs Graphiti: https://help.getzep.com/zep-vs-graphiti
- Graphiti overview: https://help.getzep.com/graphiti/getting-started/overview
- Letta context hierarchy: https://docs.letta.com/v1-sdk/memory/context-hierarchy
- Letta Leaderboard: https://www.letta.com/blog/letta-leaderboard/
- LongMemEval: https://github.com/xiaowu0162/longmemeval
- LongMemEval-V2: https://xiaowu0162.github.io/longmemeval-v2/
Краткое резюме
Mem0, Zep и Letta - не три варианта одного и того же слоя. Это три архитектурных акцента:
- Mem0: compact personalization memory;
- Zep/Graphiti: temporal knowledge graph;
- Letta: stateful agent runtime.
Хороший выбор зависит от dominant memory problem, governance, latency, data shape, evaluation method and operational maturity.
Вопросы для самопроверки
- Почему нельзя выбрать memory framework только по общему benchmark score?
- Какие признаки говорят, что нужен Zep-style temporal graph?
- Когда Letta лучше, чем внешний memory service?
- Какие evals обязательны для проверки deletion and stale memory?
- Как может выглядеть hybrid stack из нескольких memory tools?
Что дальше
В следующей лекции мы расширим карту инструментов за пределы dedicated memory frameworks и разберем open-source agent frameworks with state: LangGraph, AutoGen, CrewAI и Mastra.