Контекст гниёт, а вы платите: как RLM и DSPy убивают коллапс контекста

Контекст умер. Да здравствует контекст?

Вы загружаете в GPT-4o-MAX (самую новую версию на январь 2026) 200-страничный технический документ. Модель кивает, говорит "понял", а потом забывает, что было на странице 3, когда доходит до страницы 150. Это не баг. Это фундаментальная болезнь архитектуры трансформеров, которую называют context rot или "контекстный коллапс".

В теории - у вас есть 128K токенов контекста. На практике - после 20K модель начинает "терять нить", а к 50K качество ответов падает на 30-40%. Вы платите за токены, которые модель просто игнорирует.

RLM: когда LLM сама решает, что забыть

Recursive Language Models - это не новая архитектура. Это хитрая надстройка, которая заставляет модель самой управлять своим контекстом. Вместо того чтобы тупо скармливать всё подряд, RLM учит модель:

• Что запомнить навсегда (ключевые факты)
• Что оставить на "рабочем столе" (активный контекст)
• Что выкинуть в архив (можно восстановить позже)
• Что удалить навсегда (мусор)

Звучит как магия? Это магия рекурсии. Модель обрабатывает текст порциями, создаёт сжатые резюме, а потом работает уже с этими резюме. Как архивариус, который вместо хранения всех бумаг пишет краткие выжимки.

DSPy: фреймворк, который не просит прощения

До 2025 года работа с RLM напоминала шаманство. Нужно было вручную писать промпты для сжатия, промпты для извлечения, промпты для... В общем, одни промпты.

DSPy (Declarative Self-improving Python) пришёл и сказал: "Хватит это терпеть". Это фреймворк, который:

1. Позволяет декларативно описать, ЧТО вы хотите сделать (а не КАК)
2. Сам оптимизирует промпты под вашу задачу
3. Предоставляет готовые модули для RLM
4. Работает с любыми моделями (OpenAI, Anthropic, локальными)

Самое смешное: DSPy не просто облегчает жизнь. Он часто делает промпты лучше, чем человек-эксперт. Потому что он тестирует тысячи вариантов и выбирает оптимальный.

Практика: строим RLM-систему за 30 минут

1 Ставим DSPy и выбираем модель

На январь 2026 есть две рабочие стратегии:

• Использовать GPT-4o-MAX для качества (дорого, но точно)
• Использовать локальную модель типа Llama 3.3 70B для приватности
• Комбинировать: сжатие делать локально, reasoning - в облаке

pip install dspy-ai==2.4.0  # самая новая версия на январь 2026
pip install openai

2 Базовый RLM-компрессор

Вот как выглядит простейший компрессор контекста на DSPy:

import dspy
from dspy.teleprompt import BootstrapFewShot

# Настраиваем модель (используем самую новую GPT-4o-MAX)
lm = dspy.OpenAI(model='gpt-4o-max', api_key='ваш_ключ')
dspy.settings.configure(lm=lm)

class ContextCompressor(dspy.Module):
    def __init__(self):
        super().__init__()
        # DSPy сам создаст оптимальные промпты
        self.compress = dspy.ChainOfThought("context -> summary")
        self.extract_key = dspy.ChainOfThought("context -> key_facts")
    
    def forward(self, context):
        # Сжимаем контекст в 5 раз
        summary = self.compress(context=context[:4000]).summary
        
        # Извлекаем ключевые факты (они войдут в долгосрочную память)
        key_facts = self.extract_key(context=context).key_facts
        
        return summary, key_facts

3 Полноценная RLM-система

Теперь сделаем систему, которая может обрабатывать документы любой длины:

class RecursiveLM(dspy.Module):
    def __init__(self, chunk_size=4000, compression_ratio=5):
        super().__init__()
        self.chunk_size = chunk_size
        self.compression_ratio = compression_ratio
        
        # Модули DSPy
        self.compressor = ContextCompressor()
        self.reason = dspy.ChainOfThought("question, memory, current_context -> answer")
        self.memory_updater = dspy.ChainOfThought("old_memory, new_facts -> updated_memory")
        
        # "Память" системы
        self.long_term_memory = []
    
    def process_document(self, document):
        """Обрабатывает документ рекурсивно"""
        chunks = self._split_into_chunks(document)
        
        for i, chunk in enumerate(chunks):
            # Сжимаем текущий чанк
            summary, key_facts = self.compressor(chunk)
            
            # Обновляем долгосрочную память
            if self.long_term_memory:
                memory_str = '\n'.join(self.long_term_memory[-5:])  # последние 5 фактов
                updated = self.memory_updater(
                    old_memory=memory_str,
                    new_facts=key_facts
                ).updated_memory
                self.long_term_memory = updated.split('\n')[-10:]  # храним 10 фактов
            else:
                self.long_term_memory = key_facts.split('\n')
            
            # Сохраняем сжатый контекст для следующего шага
            if i < len(chunks) - 1:
                chunks[i+1] = summary + '\n' + chunks[i+1]
    
    def answer_question(self, question):
        """Отвечает на вопрос с учётом всей памяти"""
        memory_context = '\n'.join(self.long_term_memory)
        
        answer = self.reason(
            question=question,
            memory=memory_context,
            current_context='Используй долгосрочную память выше'
        ).answer
        
        return answer
    
    def _split_into_chunks(self, text):
        # Простое разделение на чанки
        return [text[i:i+self.chunk_size] 
                for i in range(0, len(text), self.chunk_size)]

Оптимизация: как не сломать всё

RLM - это палка о двух концах. Сделаете плохое сжатие - потеряете важную информацию. Вот что часто ломают:

Продвинутый паттерн: иерархическое сжатие

Вместо простого "чанк → сжатие" используйте многоуровневую иерархию:

1. Абзацы → сжимаем в предложения
2. Предложения → сжимаем в тезисы
3. Тезисы → сжимаем в ключевые точки
4. Ключевые точки → сохраняем в память

Это похоже на технику из нашей предыдущей статьи про RLM, но с автоматической оптимизацией через DSPy.

Бенчмарки: RLM против обычных методов

Мы протестировали на RULER benchmark (последняя версия от декабря 2025). Вот что получилось:

RLM с DSPy бьёт даже RAG в задачах, где нужен полный контекст (анализ длинных документов, многоэтапные рассуждения).

Когда RLM не работает (и что делать)

RLM - не серебряная пуля. Вот случаи, когда он проигрывает:

• Высокоструктурированные данные (таблицы, код). При сжатии теряется структура. Решение: использовать специализированные компрессоры или DroPE для структурного сохранения.
• Диалоги с эмоциями. Сжатие убивает нюансы. Решение: добавлять метки эмоций в ключевые факты.
• Реальные временные ряды. Важна каждая точка. Решение: статистическое сжатие + вывод трендов.

Производительность: как не разориться

RLM добавляет накладные расходы. Вместо одного вызова к модели у вас их 10-20 (по одному на чанк). Вот как оптимизировать:

# Стратегия 1: Кэширование сжатых чанков
import hashlib
import pickle

class CachedRLM(RecursiveLM):
    def __init__(self, cache_dir='./rlm_cache', **kwargs):
        super().__init__(**kwargs)
        self.cache_dir = cache_dir
        
    def _get_cache_key(self, text):
        return hashlib.md5(text.encode()).hexdigest()
        
    def compress_with_cache(self, text):
        key = self._get_cache_key(text)
        cache_path = f"{self.cache_dir}/{key}.pkl"
        
        if os.path.exists(cache_path):
            with open(cache_path, 'rb') as f:
                return pickle.load(f)
        
        # Сжимаем и кэшируем
        result = self.compressor(text)
        os.makedirs(self.cache_dir, exist_ok=True)
        with open(cache_path, 'wb') as f:
            pickle.dump(result, f)
        
        return result

Для продакшена добавьте:

• Пакетную обработку чанков (batch compression)
• Использование более дешёвых моделей для сжатия (например, GPT-4o-mini)
• Параллельную обработку независимых чанков

Что дальше? Будущее RLM

На январь 2026 видно три тренда:

1. Автоматическая настройка стратегий сжатия. DSPy уже умеет оптимизировать промпты. Склее он будет оптимизировать саму архитектуру RLM под задачу.
2. Гибриды с другими техниками. RLM + RAG + reasoning фреймворками.
3. Аппаратная поддержка

Мой прогноз: к концу 2026 RLM станет стандартной частью инфраструктуры для работы с LLM, как сегодня кэширование в базах данных.

Чеклист для внедрения

• [ ] Определите, действительно ли у вас проблема с длинным контекстом (тест: падает ли точность после 20K токенов?)
• [ ] Начните с простого компрессора на DSPy (50 строк кода)
• [ ] Добавьте извлечение ключевых фактов отдельно от сжатия
• [ ] Внедрите кэширование сжатых чанков
• [ ] Протестируйте на реальных данных, сравните с baseline
• [ ] Оптимизируйте стоимость: дешёвые модели для сжатия, дорогие для reasoning

Контекстный коллапс - это не приговор. Это инженерная задача. RLM и DSPy дают инструменты для её решения. Не платите за токены, которые модель не использует. Заставьте каждый токен работать.