Decompose: ускорьте RAG в 70 раз, отфильтровав документы regex-ом перед отправкой в LLM

Зачем платить LLM за сортировку мусора?

Представьте: у вас RAG-система, которая отвечает на вопросы по документам. Пользователь спрашивает про финансовые показатели. Система находит 20 релевантных чанков. Но половина из них - это шапки документов, подписи, юридические оговорки. Бесполезный шум.

Вы отправляете все 20 чанков в GPT-4.5 Turbo (самая новая версия на февраль 2026). Модель тратит драгоценные токены на анализ мусора. Вы платите за это деньги. И ждете ответа.

А что если отфильтровать мусор ДО отправки в LLM? Простыми регулярными выражениями?

Как работает Decompose v2.1 (актуально на февраль 2026)

Библиотека появилась в конце 2025 года. К февралю 2026 вышла версия 2.1 с поддержкой многоязычных паттернов и интеграцией с популярными RAG-фреймворками.

Принцип простой:

1. Вы определяете категории документов (например: "основной текст", "шапка", "подпись", "таблица")
2. Для каждой категории пишете regex-паттерны
3. Decompose анализирует каждый чанк и присваивает ему категорию
4. В LLM отправляются только чанки нужных категорий

Вся магия в том, что regex работает за 14 миллисекунд. А LLM тратила бы на ту же задачу 1000+ миллисекунд. Разница в 70 раз - не маркетинговая утка, а реальные замеры.

Установка и базовый пример

Ставится одной командой:

pip install decompose-rag

Базовый сценарий использования:

from decompose import DocumentDecomposer

# Определяем категории и паттерны
decomposer = DocumentDecomposer(
    categories={
        "main_text": [r"^[А-Я].{50,}"],  # Текст с заглавной буквы, длиной от 50 символов
        "header": [r"^\s*[А-ЯА-Я\s]{10,}\s*$", r"ДОГОВОР\s*№"],
        "signature": [r"\s*[А-Я][а-я]+\s+[А-Я]\.[А-Я]\.", r"\d{2}\.\d{2}\.\d{4}"],
        "table": [r"\|.*\|.*\|", r"\+[-]+\+"],
        "boilerplate": [r"Настоящий договор", r"в соответствии с законодательством"]
    }
)

# Документы после чанкинга (например, из вашего RAG-пайплайна)
document_chunks = [
    "ДОГОВОР № 123 от 15.02.2026",
    "Настоящий договор регулирует отношения между сторонами...",
    "Выручка компании за 2025 год составила 15 млн долларов...",
    "Иванов И.И. Петров П.П. 15.02.2026",
    "| Показатель | Значение |\n|------------|----------|\n| Выручка | 15M |"
]

# Классифицируем
classified = decomposer.decompose(document_chunks)

# Фильтруем - оставляем только основной текст и таблицы
filtered_chunks = [
    chunk for chunk, category in classified 
    if category in ["main_text", "table"]
]

print(f"Было: {len(document_chunks)} чанков")
print(f"Стало: {len(filtered_chunks)} чанков")
print(f"Убрали: {len(document_chunks) - len(filtered_chunks)} мусорных фрагментов")

Почему это работает лучше, чем LLM-классификатор?

Давайте сравним два подхода:

LLM умнее? Безусловно. Но для шаблонных задач вроде "отличить шапку договора от основного текста" она избыточна. Это как использовать нейросеть для сортировки писем по папкам - работает, но дорого и медленно.

Интеграция с реальным RAG-пайплайном

Допустим, у вас уже есть рабочая система, построенная на стандартном RAG-стеке. Добавить Decompose можно за 15 минут:

# Ваш существующий RAG-пайплайн
from rag_pipeline import VectorStore, Retriever, LLMClient
from decompose import DocumentDecomposer

# Инициализируем Decomposer с паттернами для вашей предметной области
decomposer = DocumentDecomposer.from_preset("legal_documents")  # Есть пресеты!

class OptimizedRAGPipeline:
    def __init__(self):
        self.vector_store = VectorStore()
        self.retriever = Retriever(self.vector_store)
        self.llm = LLMClient(model="gpt-4.5-turbo")
        
    def query(self, question: str, top_k: int = 20):
        # 1. Находим релевантные чанки
        chunks = self.retriever.retrieve(question, k=top_k)
        
        # 2. Фильтруем мусор (НОВЫЙ ЭТАП!)
        filtered_chunks = decomposer.filter(chunks, keep_categories=["main_text", "table", "list"])
        
        # 3. Формируем промпт только с полезным контекстом
        context = "\n\n".join(filtered_chunks)
        prompt = f"""Ответь на вопрос на основе контекста:
        
        Контекст:
        {context}
        
        Вопрос: {question}
        """
        
        # 4. Отправляем в LLM (теперь промпт короче и чище!)
        response = self.llm.generate(prompt)
        return response

Что изменилось? Теперь в LLM попадают не 20 случайных чанков, а 10-12 очищенных. Промпт короче. Ответ быстрее. Точность выше (меньше шума).

Альтернативы: почему не SemanticZip и другие?

В 2025-2026 появилось несколько инструментов для оптимизации RAG. Сравним:

• SemanticZip - сжимает документы семантически. Проблема в том, что сжатие тоже требует LLM. Вы экономите на отправке, но тратите на сжатие. Цикл замыкается.
• Kreuzberg v4 - Rust-библиотека для обработки документов. Быстрее, но решает другую задачу (парсинг, чанкинг). Можно использовать вместе с Decompose. Отличный тандем.
• LLM-классификаторы (fine-tuned модели) - точнее на сложных документах, но требуют обучения, GPU и все равно медленнее regex.

Decompose занимает нишу "простой и быстрой предобработки". Он не претендует на звание универсального решения. Но для 80% корпоративных документов (договоры, отчеты, письма) он идеален.

Кому подойдет Decompose? (Спойлер: почти всем)

Библиотека бесплатна, open-source и проста в использовании. Но есть сценарии, где она сияет особенно ярко:

1. Юридические компании - договоры, иски, претензии. Шаблонные документы с кучей boilerplate-текста. Decompose отсекает 40-60% мусора.
2. Финансовые отчеты - таблицы с цифрами и аналитика. Библиотека умеет выделять таблицы и списки, отправляя их в LLM в структурированном виде.
3. Корпоративные порталы - тысячи документов с одинаковыми шапками и подвалами. Типичная боль.
4. Локальные LLM - когда каждый токен на счету, а GPU слабый. Decompose сокращает контекст на 30-50%, ускоряя генерацию.

А вот где Decompose бесполезен:

• Творческие тексты (романы, статьи) - нет шаблонных структур
• Диалоги и соцсети - неформальный язык, сленг
• Мультиязычные документы без четких паттернов

Практические советы: как не выстрелить себе в ногу

Regex - мощное оружие. Им можно и нужно пользоваться, но осторожно.

Первая ошибка новичков - слишком жадные паттерны. Вы написали r"\d{2}\.\d{2}\.\d{4}" для дат. А в документе встречается "Результат: 45.12.2025 (процент)". И вот уже процентная ставка помечена как дата.

Решение: всегда тестируйте паттерны на реальных данных. В Decompose есть встроенный тестер:

from decompose import PatternTester

tester = PatternTester()
matches = tester.test_pattern(
    pattern=r"\b\d{1,3}\.\d{3}\.\d{3}\b",  # Для сумм вроде 15.000.000
    text="Выручка составила 15.000.000 рублей, а индекс 12.345.678 не относится"
)
print(f"Найдено совпадений: {len(matches)}")
print(f"Ложные срабатывания: {tester.check_false_positives(matches)}")

Вторая ошибка - игнорирование контекста. Паттерн r"Статья \d+" найдет и "Статья 15 ГК РФ", и "Статья в журнале №15". В юридических документах это нормально. В медиа-контенте - нет.

Третья ошибка - забыть про обновление паттернов. Документы меняются. Шаблоны устаревают. Раз в месяц проверяйте, не появились ли новые форматы.

Что дальше? Будущее предобработки для RAG

К февралю 2026 Decompose - не единственный игрок. Но самый простой. Разработчики обещают в версии 3.0:

• Автоматическое определение паттернов через few-shot learning
• Интеграцию с гибридным поиском
• Готовые пресеты для 50+ отраслей

Но главный тренд 2026 года - не усложнение, а упрощение. Вместо мега-моделей, которые делают все, появляются микро-инструменты, которые делают одно дело, но идеально. Decompose из этой категории.

Мой прогноз: через год regex-фильтрация станет стандартным этапом в любом production RAG. Как минимум для корпоративных систем. Потому что платить LLM за анализ шапки документа - это как платить хирургу за то, что он снимает с вас пальто.

Начните с простого. Возьмите 100 документов из вашей базы. Посмотрите, сколько в них шаблонного мусора. Напишите 5-10 regex-паттернов. Замерьте, насколько сократится контекст. Результат удивит вас.

А если не удивит - значит, ваши документы слишком уникальны. И это тоже ценный инсайт.