Архитектура памяти LLM¶

~5 минут чтения

Предварительно: Длинный контекст | KV-кэш оптимизация

LLM по природе stateless -- каждый вызов начинается с чистого листа. Но для LLM-агентов нужна персистентная память: предпочтения пользователя, история ошибок, контекст между сессиями. MemGPT/Letta решает это через OS-аналогию (Core Memory как RAM с латентностью <1ms, Archival как Disk на 50--200ms), Mem0 -- через гибрид vector + graph + key-value ($0.01--0.10/пользователь). При этом рабочая память трансформера ограничена 5--10 переменными (Microsoft BAPO model) -- задолго до переполнения контекстного окна способность модели эффективно использовать информацию исчерпывается.

Ключевые концепции¶

Проблема: stateless LLM¶

LLM stateless по природе -- каждый вызов независим. Для агентов нужна persistency: запоминание пользователя, self-improvement, контекст между сессиями.

Проблема	Описание
No persistence	Каждый разговор с нуля
Context overflow	Контекстное окно быстро заполняется
No learning	Не запоминает предпочтения
No self-improvement	Не учится на ошибках

Working Memory -- настоящий bottleneck¶

Ключевой инсайт (Microsoft, BAPO model): working memory важнее raw context window. Задолго до переполнения контекста, способность трансформера эффективно использовать информацию исчерпывается.

BAPO (Bounded Attention Prefix Oracle): два bandwidth параметра: - a: сколько информации pre-computed и передано (memorization) - b: сколько можно look up по факту (attention)

Тип задачи	Примеры	Working Memory
BAPO-Easy	Needle-in-a-Haystack, equality checks	Low (constant)
BAPO-Hard	Graph reachability, majority voting, variable tracking	High (grows with input)

Variable tracking: LLM может отслеживать 5-10 переменных. После этого -- degradation до 50% random guessing.

OS-аналогия (MemGPT/Letta)¶

Traditional OS	LLM Memory
RAM	Core Memory (in-context)
Disk/SSD	Archival Memory (out-of-context)
Virtual Memory	Virtual Context
Paging/Swapping	Memory retrieval tools

graph TD
    subgraph LLM["LLM (CPU)"]
        subgraph CORE["Core Memory (RAM)"]
            C1["Working context"]
            C2["Active facts"]
            C3["Current task state"]
        end
        SWAP["swap"]
        subgraph ARCH["Archival Memory (Disk)"]
            A1["Long-term memories"]
            A2["Conversation history"]
            A3["User preferences"]
        end
        subgraph TOOLS["Memory Tools"]
            T1["core_memory_append"]
            T2["core_memory_replace"]
            T3["archival_memory_insert"]
            T4["archival_memory_search"]
        end
    end
    CORE <--> SWAP <--> ARCH
    TOOLS -.-> CORE
    TOOLS -.-> ARCH

    style LLM fill:#f3e5f5,stroke:#9c27b0
    style CORE fill:#e8f5e9,stroke:#4caf50
    style ARCH fill:#e8eaf6,stroke:#3f51b5
    style TOOLS fill:#fff3e0,stroke:#ef6c00

Landscape 2026¶

System	Архитектура	Best For
Letta (MemGPT)	OS-style hierarchical	Complex agents
Mem0	Hybrid (vector + graph + kv)	User/agent memories
EM-LLM	Episodic memory (cognitive)	Multi-turn conversations
MIRIX	Retrieval-based	Multi-turn
ChatGPT Memory	Proprietary	ChatGPT users

Letta (MemGPT)¶

Memory Blocks:

Block	Purpose	Size
Human	User preferences, facts	~2K tokens
Persona	Agent identity, goals	~2K tokens
Scratchpad	Working memory	Variable
Recall	Recent interactions	Variable

Operations:

Operation	Описание
`core_memory_append`	Add to in-context
`core_memory_replace`	Update existing
`archival_memory_insert`	Store to long-term
`archival_memory_search`	Retrieve from long-term
`conversation_search`	Search past conversations

from letta import create_client

client = create_client()
agent = client.create_agent(
    name="memory_agent",
    memory_blocks=[
        {"label": "human", "value": "User prefers Python"},
        {"label": "persona", "value": "Helpful coding assistant"}
    ]
)
response = client.send_message(agent_id=agent.id, message="Help me with my project")

Mem0¶

Hybrid storage: vector (semantic search) + graph (relationships) + key-value (fast exact lookup).

Memory Type	Описание
User Memory	Preferences, facts about user
Agent Memory	Learned behaviors, patterns
Session Memory	Current conversation context

from mem0 import Memory

m = Memory()
m.add("User prefers dark mode", user_id="user123")
results = m.search("interface preferences", user_id="user123")

Production features: multi-tenant, conflict resolution, TTL expiration, versioning.

EM-LLM (ICLR 2025)¶

Cognitive-inspired: surprise-based event segmentation + temporal contiguity.

Metric	Performance
vs InfLLM	Beat across benchmarks
vs RAG (NV-Embed-v2)	Surpassed
Passkey retrieval	Up to 10M tokens

Детали и сравнения¶

Иерархия памяти¶

Tier	Capacity	Latency
Core (RAM)	10K-100K tokens	<1ms
Archival (Disk)	Unlimited	50-200ms
Recall buffer	Recent N turns	<1ms

Паттерны памяти¶

Pattern 1: Hierarchical (MemGPT)

Core Memory (always in context) <-> Archival Memory (retrieved on demand)

Pattern 2: Vector + Graph (Mem0)

Vector Store (similarity) + Graph Store (relationships) -> Unified Query

Pattern 3: Self-Editing

LLM can: READ, WRITE, UPDATE, DELETE own memory through tool calls.

Режимы отказа памяти¶

Отказ	Причина	Решение
Загрязнение контекста	Слишком много нерелевантных memories	Лучше retrieval, суммаризация
Забывание	Важные факты не сохранены	Priority-based storage
Конфликты	Противоречивые memories	Timestamp, source tracking
Промах retrieval	Не та memory извлечена	Лучше embeddings, re-ranking

Strategies for BAPO-Hard Tasks¶

Reasoning models: reasoning tokens enable solving hard tasks (trade-off: many tokens)
Problem decomposition: complex HTML -> rendered text only (compact intermediate repr)
External solvers: classify separately, aggregate in Python
Pre-annotation: annotate data before LLM processing

Продакшен¶

Стоимость хранения:

System	Cost
Letta (self-hosted)	$50-200/month infra
Mem0 Cloud	$0.01-0.10/user
Custom	$100-500/month infra

Бюджет латентности:

Operation	Target
Core memory read	<1ms
Archival retrieval	50-200ms
Memory update	10-50ms
Full context rebuild	200-500ms

Метрики оценки¶

Metric	Описание
Recall@k	Relevant memories retrieved
Precision@k	Accuracy of retrieved
Latency	Time to retrieve
Storage efficiency	Tokens stored vs retrieved

Interview Questions¶

1. Зачем LLM нужна архитектура памяти?¶

Red flag: "Просто увеличить контекстное окно -- память не нужна"

Strong answer: "LLM stateless -- каждый вызов независим. Для агентов нужна persistency: запоминание пользователей, self-improvement, контекст между сессиями. Даже при 1M контексте working memory ограничена 5-10 переменными (BAPO model). MemGPT/Letta решает через OS-аналогию: Core Memory (RAM, <1ms) + Archival Memory (Disk, 50-200ms) + tool-based paging. Mem0 -- через hybrid storage (vector + graph + kv) для multi-tenant production."

2. Как работает MemGPT/Letta?¶

Red flag: "Это просто RAG с vector store"

Strong answer: "OS-аналогия: Core Memory (10K-100K tokens, in-context, <1ms) -- активный контекст. Archival Memory (unlimited, 50-200ms) -- long-term. LLM управляет памятью через tools: append, replace, insert, search. Ключевое отличие от RAG: self-editing -- модель сама решает что запомнить, обновить или удалить. Не нужен внешний retrieval pipeline. #1 на Terminal-Bench."

3. Working memory bottleneck -- что это и как бороться?¶

Red flag: "Больше контекста = лучше память"

Strong answer: "Microsoft BAPO model показывает: working memory важнее raw context. LLM может отслеживать 5-10 переменных, затем degradation до 50% random guessing. BAPO-hard задачи (graph reachability, variable tracking) масштабируются с размером входа. Solutions: (1) reasoning tokens (trade-off: много токенов), (2) problem decomposition (compact intermediate repr), (3) external solvers (classify separately, aggregate в Python), (4) pre-annotation перед подачей в LLM."

4. Какие failure modes у agent memory?¶

Red flag: "Если embeddings хорошие, проблем с памятью не будет"

Strong answer: "(1) Context pollution -- irrelevant memories загрязняют контекст, снижая quality. (2) Forgetting -- important facts не сохранены (нужен priority-based storage). (3) Conflicts -- contradictory memories (timestamp + source tracking). (4) Retrieval miss -- не та memory извлечена (better embeddings + re-ranking). Production: мониторинг Recall@k и Precision@k, conflict resolution через versioning, TTL expiration для устаревших фактов."

Ключевые числа¶

Факт	Значение
Working memory: variables before degradation	5-10
BAPO-hard degradation	To 50% random
Core Memory latency	<1ms
Archival Memory latency	50-200ms
Mem0 cost per user	$0.01-0.10
Context window growth 2020-2025	500x (2K -> 1M)
Letta Terminal-Bench	#1 open-source

Заблуждение: большой контекст заменяет архитектуру памяти

Контекстное окно 1M токенов не решает проблему памяти. Во-первых, working memory ограничена 5-10 переменными -- модель не может эффективно использовать всю информацию. Во-вторых, каждый вызов стоит денег: 1M токенов на входе при 100 queries/day = $200--3000/месяц. Архитектура памяти (Letta/Mem0) хранит только релевантное и стоит $50--200/месяц.

Заблуждение: agent memory = vector store с RAG

Vector store + retrieval -- только один паттерн (semantic similarity). Полноценная agent memory включает: (1) self-editing -- модель сама решает что сохранить/обновить/удалить, (2) graph store для отношений между сущностями, (3) key-value для быстрого exact lookup, (4) conflict resolution для противоречивых фактов. Mem0 комбинирует все три хранилища. MemGPT добавляет иерархию с paging.

Заблуждение: memory retrieval всегда улучшает ответы

Context pollution -- одна из главных проблем: нерелевантные memories загрязняют контекст и ухудшают качество ответов. Исследования показывают, что добавление >10 нерелевантных фактов в контекст снижает accuracy на 15-25%. Нужен строгий retrieval с высоким precision, а не "загрузить все что нашли".

Самопроверка

Дизайн memory системы: Вы строите AI-тьютора, который запоминает прогресс студента между сессиями. Спроектируйте, что хранить в Core Memory vs Archival Memory. Оцените: сколько токенов Core Memory нужно для 1 студента? Для 1000?
BAPO анализ: LLM должен прочитать HTML-страницу (~50K tokens) и ответить на вопрос о конкретном значении в таблице. Это BAPO-Easy или BAPO-Hard? Какую стратегию выбрать для надежного решения?
Failure mode debugging: Agent-помощник "забывает" предпочтения пользователя после 10+ сообщений. Какие из 4 failure modes наиболее вероятны? Как диагностировать и исправить?

Источники¶

Letta -- "Agent Memory: How to Build Agents that Learn and Remember"
Letta -- "Benchmarking AI Agent Memory: Is a Filesystem All You Need?"
arXiv -- "BAPO: Bounded Attention Prefix Oracle" (2505.08140)
arXiv -- "Human-inspired Episodic Memory for Infinite Context LLMs" (ICLR 2025)
arXiv -- "Leave No Context Behind: Efficient Infinite Context Transformers" (2404.07143)
Mem0 Documentation
Dextra Labs -- "Infinite Context LLMs: How Memory Compression Really Works"
Towards Data Science -- "Your 1M+ Context Window LLM Is Less Powerful Than You Think"
GitHub -- "TsinghuaC3I/Awesome-Memory-for-Agents"
Medium -- "Memory Engineering for AI Agents"