дорожка · 09.10.2026 · окно контекста

Как удержать длинный разговор в окне контекста

Как не потерять важные факты, когда длинный разговор перестаёт влезать в одно окно модели. Пять ступеней: что реально обрезают при переполнении, как упорядочить слои запроса, как сжать историю кратким пересказом, куда вынести факты во внешнюю память и как проверить, что после упаковки важное ещё на месте. Все примеры на Python запускаются у тебя без доступа к модели и без дополнительных библиотек: длины считают грубыми учебными оценками, ответы и тексты записаны заранее.

Все дорожки — /put. Прошлая — как проверить, что модель справляется с задачей.

1 Когда окно заканчивается: что реально обрезают

Зачем это в работе. Длинный чат с клиентом или с самим собой рано или поздно упирается в потолок: модель за один запрос видит только ограниченный объём текста. Если не понимать, что именно выкидывают, важные факты — номер заказа, адрес, запрет на скидку — исчезают тихо, а ответ выглядит уверенным, будто этих фактов никогда не было.

Окно контекста (context window) — это максимальное число кусков текста, токенов, которое модель может увидеть за один запрос. В это окно входят инструкция, история реплик, найденные куски документов и ещё место под будущий ответ. Токен — кусок текста, которым считают длину: короткое слово часто один токен, длинное или редкое — несколько. Окно измеряют в токенах, а не в «сообщениях».

Когда сумма не влезает, программы обычно обрезают историю с начала: самые старые реплики выкидывают, пока оставшееся не уложится в бюджет. Это и есть обрезка (truncation). Модель не «забывает» в смысле человека: текст просто не положили в текущий запрос, поэтому для неё его не существует. Не путай окно с долгим хранилищем снаружи — файлами, заметками, базой: они живут отдельно и сами в запрос не попадают.

Бюджет считают так: лимит окна минус место, которое ты оставляешь под ответ. Если место под ответ не зарезервировать, длинная история съест всё, и модели некуда будет писать. На практике оставляют запас не только под ответ, но и под служебные поля: роли «user» и «assistant», разделители, системную шапку.

Соседнее понятие — «память чата» в интерфейсе. Кнопка «продолжить диалог» не значит, что модель помнит всё навсегда: программа каждый раз заново собирает текст запроса из того, что ещё влезает. Если старая реплика обрезана, для модели её не было, даже если ты её видишь выше на экране в свёрнутом виде.

Подробный пример. Учебный лимит окна — 120 токенов, под ответ оставляем 30, на историю остаётся 90. Десять реплик про заказ ORD-4412; длину считаем грубо как «число слов × 1,3» — это учебная оценка, не настоящий токенизатор. Код выкидывает старые реплики с начала, пока история не влезет, и проверяет, остался ли номер заказа:

# -*- coding: utf-8 -*-
"""Учебный пример: обрезка истории, когда окно контекста переполнено.
Оценка токенов грубая: слова * 1.3 — не настоящий токенизатор."""

def approx_tokens(text: str) -> int:
    words = len(text.split())
    return max(1, int(round(words * 1.3)))

# Учебные реплики длинного разговора о заказе
turns = [
    ("user", "Здравствуйте! Хочу уточнить статус заказа ORD-4412."),
    ("assistant", "Здравствуйте. Смотрю заказ ORD-4412. Сейчас он в сборке на складе."),
    ("user", "А можно изменить адрес доставки на улицу Ленина, дом 12?"),
    ("assistant", "Да, адрес обновлён на ул. Ленина, 12. Подтвердите, пожалуйста."),
    ("user", "Подтверждаю. Ещё вопрос: нужна ли предоплата?"),
    ("assistant", "Предоплата не нужна. Оплата при получении."),
    ("user", "Отлично. Напишите, пожалуйста, срок доставки."),
    ("assistant", "Срок доставки — 3 рабочих дня после отправки."),
    ("user", "И последнее: можно ли без звонка курьера?"),
    ("assistant", "Да, отметила «без звонка». Заказ ORD-4412 готов к отправке."),
]

WINDOW = 120  # учебный лимит токенов на всю историю + место под ответ
ROOM_FOR_ANSWER = 30
budget = WINDOW - ROOM_FOR_ANSWER

print(f"Учебный лимит окна: {WINDOW} токенов (грубая оценка)")
print(f"Место под ответ: {ROOM_FOR_ANSWER}, бюджет на историю: {budget}")
print()

# Считаем токены каждой реплики
sized = []
for role, text in turns:
    t = approx_tokens(text)
    sized.append((role, text, t))
    print(f"  [{role:9}] ~{t:3} ток.  {text[:60]}{'…' if len(text)>60 else ''}")

total = sum(t for _, _, t in sized)
print(f"\nВсего история: ~{total} токенов")

# Обрезка с начала: выкидываем самые старые, пока не влезем
kept = list(sized)
dropped = []
while sum(t for _, _, t in kept) > budget and kept:
    dropped.append(kept.pop(0))

print(f"\nПосле обрезки старых реплик: ~{sum(t for _,_,t in kept)} токенов")
print(f"Выкинуто реплик: {len(dropped)}")
for role, text, t in dropped:
    print(f"  DROPPED [{role}] ~{t}: {text[:50]}…")

# Критичный факт: номер заказа
critical = "ORD-4412"
still_there = any(critical in text for _, text, _ in kept)
print(f"\nКритичный факт «{critical}» ещё в запросе: {still_there}")
if not still_there:
    print("  → модель его «не помнит»: текст просто не положили в запрос")

Вся история заняла примерно 99 токенов — чуть больше бюджета 90. Программа выкинула две самые старые реплики (приветствие и первый ответ про сборку) и оставила около 78. Номер ORD-4412 ещё встречается в более поздних репликах, поэтому проверка прошла. Если бы номер был только в самом первом сообщении, после обрезки модель бы его «не знала»: текста просто нет во входе. Именно поэтому критичные факты нельзя оставлять только в начале длинного чата.

Где обычно ошибаются.

  • Думают, что модель «помнит весь аккаунт», и не проверяют, попала ли нужная реплика в текущий запрос после обрезки.
  • Не резервируют место под ответ: история занимает почти всё окно, и ответ обрезается или ломается.
  • Путают окно контекста с внешней базой заметок: база сама ничего не подставит, пока программа не положит кусок в запрос.

Окно контекста (context window). Максимум токенов, которые модель видит за один запрос: инструкция, история, документы и место под ответ.

Токен (token). Кусок текста, которым считают длину входа и выхода у модели.

Обрезка (truncation). Выбрасывание части текста, чаще всего самых старых реплик, чтобы остальное влезло в лимит.

Бюджет входа. Сколько токенов остаётся на инструкцию и историю после запаса под ответ.

Место под ответ. Запас токенов внутри окна, который оставляют, чтобы модели было куда писать.

Память чата. У модели её нет: прошлое нужно снова положить в запрос, иначе его для неё не было.

Долгое хранилище. Файлы и заметки снаружи модели; они не попадают в запрос сами.

2 Порядок слоёв: что класть первым

Зачем это в работе. Когда места мало, важно не только что выкинуть, но и в каком порядке собрать то, что осталось. Если вопрос клиента окажется в середине болтовни, а критичные факты — в самом начале, которое потом обрежут, модель получит странный обрывок и ответит мимо. Слои с разным приоритетом помогают решить, что обязано выжить.

Слой запроса — это отдельный смысловой блок текста, который программа кладёт во вход: системная инструкция, список критичных фактов, найденные куски документов, старая история, текущий вопрос. Их удобно мыслить как этажи: верхние этажи (инструкция, факты, вопрос) выкидывать нельзя, нижние (светская болтовня, давно закрытые мелкие реплики) — самые дешёвые кандидаты на выброс.

Частый и полезный порядок сборки такой: сначала системная инструкция (кто ты и какие запреты), потом коротко критичные факты, потом найденные куски или нужный кусок истории, и в самом конце — текущий вопрос. Вопрос в конце ставят потому, что модель продолжает текст «вправо»: задача рядом с местом ответа обычно лучше удерживается, чем задача, утонувшая в середине длинного входа.

Не путай слой найденных документов с «памятью модели». Поиск по своим файлам (то, о чём дорожка про поиск и подход RAG — retrieval-augmented generation, ответ с опорой на найденные куски) подставляет текст как отдельный слой на этот запрос. Модель его не запомнила навсегда: его снова найдут и положат, когда понадобится.

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

Подробный пример. Шесть слоёв и учебный бюджет 90 токенов (оценка снова «слова × 1,3»). Слои system, facts и question помечены как обязательные; первыми на выброс идут chitchat, затем history и docs. Код выкидывает дешёвые слои, пока сумма не влезет, и печатает итоговый порядок с вопросом в конце:

# -*- coding: utf-8 -*-
"""Учебный пример: порядок слоёв в запросе и что выживает при нехватке места.
Оценка токенов: слова * 1.3 — учебная, не настоящий токенизатор."""

def approx_tokens(text: str) -> int:
    return max(1, int(round(len(text.split()) * 1.3)))

# Слои запроса (от важного к дешёвому для выброса)
layers = [
    ("system", "Ты помощник поддержки. Отвечай кратко. Не обещай скидки без правила."),
    ("facts", "Критичные факты: заказ ORD-4412; адрес ул. Ленина 12; без звонка курьера; оплата при получении."),
    ("docs", "Фрагмент из базы: срок доставки стандартный — 3 рабочих дня; экспресс — 1 день."),
    ("chitchat", "Клиент: Как дела? Ассистент: Хорошо, спасибо! Клиент: Погода сегодня отличная."),
    ("history", "Клиент спрашивал про предоплату; ассистент сказал, что предоплата не нужна."),
    ("question", "Клиент сейчас спрашивает: когда приедет заказ ORD-4412 и нужно ли быть дома?"),
]

BUDGET = 90  # учебный бюджет токенов на вход
print(f"Учебный бюджет входа: {BUDGET} токенов (грубая оценка)\n")

sized = [(name, text, approx_tokens(text)) for name, text in layers]
for name, text, t in sized:
    print(f"  слой [{name:9}] ~{t:3} ток.")

# Приоритет выживания: system, facts, question — нельзя выкинуть;
# chitchat и старая history — первые кандидаты на выброс
must_keep = {"system", "facts", "question"}
cheap_drop = ["chitchat", "history", "docs"]

kept = {name: (text, t) for name, text, t in sized}
total = sum(t for _, t in kept.values())
print(f"\nВсего без обрезки: ~{total}")

dropped = []
for name in cheap_drop:
    if total <= BUDGET:
        break
    text, t = kept.pop(name)
    dropped.append((name, t))
    total -= t
    print(f"  выкинули слой [{name}] (~{t}), осталось ~{total}")

print(f"\nИтоговый набор слоёв (~{total} ток.): {', '.join(kept)}")
# Порядок сборки: system → facts → docs/history → question в конце
order = [n for n in ("system", "facts", "docs", "history", "chitchat", "question") if n in kept]
print("Порядок в запросе (вопрос в конце):")
for i, name in enumerate(order, 1):
    print(f"  {i}. {name}")

# Соседнее понятие: RAG-кусок — это слой docs, а не «память модели»
print("\nСосед: найденный кусок (RAG) — отдельный слой docs, его подставляют поиском,")
print("а не хранят внутри модели как память.")

Без обрезки сумма вышла около 91 токена — чуть выше бюджета. Программа выкинула только слой болтовни (~13 токенов) и оставила system, facts, docs, history и question, около 78 токенов. Вопрос стоит последним. Найденный кусок про сроки доставки остался как слой docs: это не «память», а подставленный текст на этот запрос. Если бы бюджета не хватило сильнее, следующим кандидатом была бы старая history, а не номер заказа в facts.

Где обычно ошибаются.

  • Кладут весь чат одним комком и надеются, что модель «сама найдёт важное» в середине.
  • Ставят текущий вопрос в начало, а потом обрезают с начала — и вопрос исчезает первым.
  • Считают найденный кусок документа вечной памятью модели и не кладут его снова в следующий запрос.

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

Системная инструкция. Текст о роли и правилах, который обычно кладут первым и стараются не выкидывать.

Критичные факты. Короткий список того, без чего ответ будет вредным: номер, адрес, запрет, решение.

Вопрос в конце. Приём сборки: текущую задачу ставят ближе к месту ответа.

Приоритет выживания. Правило, какие слои выкидывать первыми при нехватке места.

Найденный кусок (RAG). Текст из поиска по файлам, подставленный как слой на этот запрос, а не память модели.

Болтовня (chitchat). Реплики без рабочих фактов; их обычно выкидывают первыми.

3 Сжатие истории: краткий пересказ вместо полных реплик

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

Сжатие истории (summarization of history) — это когда программа или модель превращает старые реплики в краткую бегущую заметку: «заказ такой-то, адрес такой-то, решили вот это». В следующий запрос кладут эту заметку плюс свежие реплики, а не весь архив чата. Пересказ занимает меньше токенов, поэтому окно «держится» дольше.

Цена сжатия — потеря деталей. Точные цитаты, порядок вопросов, нюансы формулировок, даты «между строк» часто пропадают. Если потом понадобится дословная фраза клиента для жалобы, пересказ её не вернёт. Поэтому в пересказ сознательно вписывают идентификаторы, числа и запреты, а «как дела» и вежливые обороты спокойно выбрасывают.

Не путай сжатие с обрезкой. Обрезка удаляет кусок текста целиком: его нет. Сжатие оставляет потерю-остаток внутри того же запроса: что-то ещё есть, но это уже не исходные слова. Оба приёма экономят место; сжатие сохраняет смысл грубее, обрезка может выкинуть смысл вместе с текстом.

На практике пересказ обновляют по правилам: например, каждые N реплик или когда оценка токенов истории перешла порог. В пересказ копируют только поля из списка («номер», «адрес», «статус», «запреты»), а не свободный художественный текст. Чем свободнее пересказ, тем легче в него проникнет ошибка или выдумка.

Подробный пример. Шесть учебных реплик про заказ сжимаем в один абзац-пересказ. Считаем токены до и после (слова × 1,3), смотрим, что потерялось, и проверяем, что номер заказа в пересказе остался:

# -*- coding: utf-8 -*-
"""Учебный пример: сжатие истории в краткий пересказ вместо полных реплик.
Оценка токенов: слова * 1.3 — учебная."""

def approx_tokens(text: str) -> int:
    return max(1, int(round(len(text.split()) * 1.3)))

# Полные старые реплики (учебные)
old_turns = [
    "Клиент: Здравствуйте, заказ ORD-4412 ещё не уехал?",
    "Ассистент: Заказ ORD-4412 в сборке, адрес ул. Ленина 12.",
    "Клиент: Можно без звонка? И предоплата нужна?",
    "Ассистент: Без звонка отметила. Предоплата не нужна, оплата при получении.",
    "Клиент: Срок какой?",
    "Ассистент: Три рабочих дня после отправки.",
]

full = "\n".join(old_turns)
# Краткий пересказ — то, что оставляет программа вместо полных реплик
summary = (
    "Краткий пересказ: заказ ORD-4412; адрес ул. Ленина 12; без звонка; "
    "оплата при получении; срок 3 рабочих дня. Детали шуток и приветствий опущены."
)

# Что потерялось при сжатии (учебный список)
lost_details = [
    "точная формулировка вопроса про предоплату",
    "приветствие и вежливые обороты",
    "порядок, в котором клиент задавал вопросы",
]

print("Полная история:")
print(f"  символов: {len(full)}, слов: {len(full.split())}, ~токенов: {approx_tokens(full)}")
print()
print("Краткий пересказ:")
print(f"  {summary}")
print(f"  символов: {len(summary)}, слов: {len(summary.split())}, ~токенов: {approx_tokens(summary)}")
saved = approx_tokens(full) - approx_tokens(summary)
print(f"\nСэкономлено ~{saved} токенов (учебная оценка)")
print(f"Сжатие примерно в {approx_tokens(full) / approx_tokens(summary):.1f} раза")
print("\nЧто сжатие обычно теряет:")
for item in lost_details:
    print(f"  — {item}")

# Сосед обрезки: обрезка удаляет, пересказ оставляет потерю смысла
print("\nСосед обрезки: обрезка выкидывает текст целиком;")
print("пересказ оставляет короткую потерю-остаток внутри того же запроса.")
# Проверка: критичный ID ещё в пересказе?
crit = "ORD-4412"
print(f"\nID заказа в пересказе: {crit in summary}")

Полная история заняла примерно 55 токенов, пересказ — около 29; экономия около 26 токенов, сжатие примерно в 1,9 раза на этом учебном куске. В пересказе остались ORD-4412, адрес, «без звонка», оплата и срок. Пропали точная формулировка вопроса про предоплату, приветствия и порядок вопросов. Для статуса заказа этого хватает; для разбора жалобы «что именно сказал клиент» — уже нет, тогда нужен исходный лог снаружи, а не только пересказ в запросе.

Где обычно ошибаются.

  • Сжимают историю свободным пересказом без списка обязательных полей и теряют номер заказа или запрет.
  • Думают, что сжатие равно обрезке: на деле обрезка удаляет, а пересказ оставляет потерю-остаток.
  • Хранят только пересказ и удаляют исходный лог, а потом не могут восстановить дословную цитату.

Сжатие истории. Замена старых полных реплик коротким пересказом внутри следующего запроса.

Краткий пересказ (summary). Бегущая заметка о договорённостях: факты да, болтовня нет.

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

Бегущая заметка. Пересказ, который обновляют по мере разговора и снова кладут во вход.

Обязательные поля. Список того, что пересказ обязан сохранить: id, адрес, запрет, решение.

Сосед обрезки. Обрезка удаляет текст; сжатие оставляет короткий, уже неточный остаток.

Исходный лог. Полные реплики снаружи запроса; нужны, когда важна дословность.

4 Внешняя память: вынести факты из чата

Зачем это в работе. Даже идеальный пересказ всё ещё сидит внутри запроса и ест токены. Факты, которые должны жить между сессиями — правила скидок, карточка заказа, решение от прошлой недели, — лучше хранить снаружи и подставлять поиском только когда они нужны. Тогда чат может быть коротким, а знание — длинным.

Внешняя память здесь — обычные заметки, таблица или файлы, к которым программа умеет обратиться: найти подходящий кусок и положить его слоем в запрос. Это прямо продолжает дорожку про поиск по своим заметкам: кусок текста достают по смыслу или по словам, а модель отвечает уже с опорой на найденное, а не на весь архив чата.

Отличие от пересказа важное. Пересказ живёт внутри текущего запроса и занимает место всегда, пока ты его туда кладёшь. Внешняя заметка лежит снаружи: в этом запросе её может не быть вовсе, если поиск решил, что она не нужна. Зато через неделю в новом чате ту же заметку можно найти снова — модель «не обязана» помнить прошлый диалог.

В заметку пишут стабильные факты и правила, а не поток сознания. Хороший шаблон: идентификатор, поля «ключ: значение», дата решения, ссылка на правило. Плохой шаблон: длинный художественный пересказ всего чата без структуры — его и искать неудобно, и в запрос он снова раздует окно.

Связка со слоями из второй ступени такая: найденные заметки становятся слоем docs или facts, а история чата остаётся короткой. Сосед поиска — тащить весь файл целиком «на всякий случай»: это снова упирается в окно и в цену. Сначала поиск и отбор, потом короткая подстановка.

Подробный пример. Три учебные заметки и вопрос про заказ и скидку. Поиск учебный: считаем, сколько слов вопроса встретилось в тексте заметки, без библиотек и без модели. В запрос кладём две лучшие заметки и сравниваем оценку токенов с «тащить весь чат»:

# -*- coding: utf-8 -*-
"""Учебный пример: внешняя память — факты живут в заметках, а не в длинном чате.
Поиск — простой подсчёт общих слов (учебный), без библиотек и без модели."""

NOTES = {
    "note-ord-4412": (
        "Заказ ORD-4412. Адрес: ул. Ленина, 12. Без звонка курьера. "
        "Оплата при получении. Срок: 3 рабочих дня. Решение от 08.10.2026: "
        "не обещать скидку без правила RULE-17."
    ),
    "note-rule-17": (
        "Правило RULE-17: скидку больше 5% даёт только старший оператор. "
        "Ассистент сам скидку не обещает."
    ),
    "note-weather": (
        "Заметка про погоду вчера: было солнечно. К заказам не относится."
    ),
}

def score(query: str, text: str) -> int:
    """Учебный скор: сколько слов запроса встретилось в тексте."""
    q = set(query.lower().replace("?", "").replace(",", "").split())
    t = set(text.lower().replace(".", "").replace(",", "").split())
    return len(q & t)

query = "когда приедет заказ ORD-4412 и можно ли скидку 10%"
print(f"Вопрос: {query}\n")
print("Ищем во внешней памяти (заметки), а не в длинном чате:\n")

ranked = sorted(
    ((score(query, text), nid, text) for nid, text in NOTES.items()),
    reverse=True,
)
for sc, nid, text in ranked:
    print(f"  скор {sc:2}  [{nid}]")
    print(f"         {text[:90]}{'…' if len(text)>90 else ''}")

# Берём два лучших куска в запрос
top = [nid for sc, nid, _ in ranked if sc > 0][:2]
print(f"\nВ запрос кладём найденные заметки: {top}")
print("Сосед пересказа: пересказ всё ещё внутри запроса и занимает место;")
print("внешняя заметка лежит снаружи и подставляется только когда нужна.")

# Бюджет: без всей истории чата
chat_history_tokens_est = 400  # учебное «если бы тащили весь чат»
notes_tokens_est = sum(max(1, int(round(len(NOTES[n].split()) * 1.3))) for n in top)
print(f"\nЕсли тащить весь чат: ~{chat_history_tokens_est} ток. (учебная оценка)")
print(f"Если подставить 2 заметки: ~{notes_tokens_est} ток.")
print(f"Экономия: ~{chat_history_tokens_est - notes_tokens_est} ток.")

Лучший скор у карточки заказа ORD-4412, второй — у правила RULE-17 про скидки, заметка про погоду получила ноль и не берётся. В запрос уходят две заметки, примерно 50 токенов по учебной оценке «слова × 1,3». Если бы тащили весь длинный чат (~400 токенов в учебной оценке), экономия вышла бы около 350 токенов, и при этом правило скидки нашлось бы надёжнее, чем в случайно обрезанной истории. Пересказ тут ни при чём: заметки живут снаружи и подставляются по необходимости.

Где обычно ошибаются.

  • Растят один бесконечный чат вместо того, чтобы вынести стабильные факты в заметки.
  • Кладут во внешнюю память поток сознания без полей — потом нельзя ни найти, ни коротко подставить.
  • Путают пересказ внутри запроса с внешней заметкой: пересказ всегда ест место, заметка — только когда её нашли.

Внешняя память. Заметки и файлы снаружи модели, откуда факты достают в запрос по необходимости.

Подстановка. Шаг, когда найденный кусок кладут слоем во вход текущего запроса.

Карточка факта. Короткая запись с полями: id, адрес, правило, дата решения.

Поиск по заметкам. Отбор нужных кусков по словам или по смыслу перед ответом модели.

Сессия. Один непрерывный разговор; между сессиями модель сама прошлое не тащит.

Сосед пересказа. Пересказ всё ещё внутри запроса; внешняя заметка подставляется только когда нужна.

Целиком файл. Антипример: тащить большой документ без отбора и снова упираться в окно.

5 Проверка: как убедиться, что важное ещё в запросе

Зачем это в работе. Обрезка, слои, сжатие и внешняя память имеют смысл, только если после упаковки запроса ты умеешь проверить результат. Иначе система «оптимизирует» вход и незаметно выкидывает номер заказа или правило скидки, а ты узнаешь об этом из жалобы клиента.

Первая проверка — оценка бюджета. Перед отправкой считают приблизительную длину входа и сравнивают с лимитом минус запас под ответ. Для учёбы достаточно грубых оценок: число слов × 1,3 или число символов ÷ 4. Это не настоящий токенизатор конкретной модели, а фонарик: он ловит грубый перебор, но не заменяет точный подсчёт в боевом коде.

Вторая проверка — обязательные строки. Составляют список того, что после упаковки обязано остаться в тексте запроса: идентификатор заказа, формулировка правила, адрес, принятое решение. Программа делает простой поиск подстроки (или чуть умнее — нормализованный) и падает с понятной ошибкой, если чего-то нет. Это тот же дух, что проверки формой ответа: дешёвый код ловит брак до модели.

Третья проверка — сравнение «до и после». Печатают оценку токенов до упаковки и после, список выкинутых слоёв и результат проверки обязательных строк. Так видно не только «влезло / не влезло», но и ценой какого содержимого ты заплатил за экономию. Если выкинули слой facts, а вопрос остался — это не победа, а поломка.

Не путай эту проверку с оценкой качества ответа модели из прошлой дорожки. Там ты меряешь, верен ли выход. Здесь ты меряешь, цел ли вход после упаковки. Обе нужны: можно идеально упаковать запрос и всё равно получить плохой ответ — или наоборот, получить хороший ответ на одном примере, а на следующем потерять правило из-за обрезки.

Подробный пример. Сырой длинный запрос с болтовнёй и упакованный короткий. Код считает обе учебные оценки токенов, проверяет четыре обязательные строки и говорит «проход» или «стоп»:

# -*- coding: utf-8 -*-
"""Учебный пример: проверка, что важное ещё в упакованном запросе.
Оценка токенов: слова * 1.3 и символы / 4 — обе грубые учебные."""

def tokens_words(text: str) -> int:
    return max(1, int(round(len(text.split()) * 1.3)))

def tokens_chars(text: str) -> int:
    return max(1, len(text) // 4)

REQUIRED = [
    "ORD-4412",
    "RULE-17",
    "ул. Ленина",
    "без звонка",
]

# «До упаковки» — длинный сырой запрос
before = """
Инструкция: ты помощник поддержки. Не обещай скидку без RULE-17.
Факты: заказ ORD-4412, адрес ул. Ленина 12, без звонка, оплата при получении.
Старый трёп: как дела, погода, шутки про кофе, рассказ про отпуск...
""" + ("ещё один абзац болтовни. " * 40) + """
Вопрос: когда приедет ORD-4412?
"""

# «После упаковки» — выбросили болтовню, оставили слои
after = """
Инструкция: ты помощник поддержки. Не обещай скидку без RULE-17.
Факты: заказ ORD-4412, адрес ул. Ленина 12, без звонка, оплата при получении.
Вопрос: когда приедет ORD-4412?
"""

BUDGET = 100
print("Бюджет входа (учебный):", BUDGET, "токенов")
print()
print("До упаковки:")
print(f"  ~токены (слова×1.3): {tokens_words(before)}")
print(f"  ~токены (символы/4):  {tokens_chars(before)}")
print("После упаковки:")
print(f"  ~токены (слова×1.3): {tokens_words(after)}")
print(f"  ~токены (символы/4):  {tokens_chars(after)}")
print()
print("Обе оценки грубые и учебные, не замена настоящему токенизатору.")
print()

print("Проверка обязательных строк после упаковки:")
ok = True
for s in REQUIRED:
    present = s in after
    print(f"  {'OK' if present else 'MISSING'}: {s!r}")
    if not present:
        ok = False

# Сравнение до/после
print()
for s in REQUIRED:
    print(f"  было/стало «{s}»: {s in before} → {s in after}")

print()
fits = tokens_words(after) <= BUDGET
print(f"Влезает в бюджет по оценке слова×1.3: {fits}")
print(f"Итог проверки: {'проход' if ok and fits else 'стоп — чинить упаковку'}")

До упаковки оценка «слова × 1,3» дала около 255 токенов, «символы ÷ 4» — около 311; после упаковки — около 32 и 44 соответственно. Бюджет 100 токенов после упаковки соблюдён. Все четыре строки — ORD-4412, RULE-17, «ул. Ленина», «без звонка» — на месте и до, и после. Итог «проход». Если бы упаковка выкинула RULE-17 вместе с болтовнёй, скрипт напечатал бы MISSING и «стоп — чинить упаковку»: это сигнал чинить приоритет слоёв, а не спорить с ответом модели.

Где обычно ошибаются.

  • Упаковывают запрос и не проверяют, остались ли обязательные идентификаторы и правила.
  • Верят учебной оценке токенов как точному счёту конкретной модели и удивляются обрезке на сервисе.
  • Смотрят только на то, что «влезло в лимит», и не смотрят, какой слой ради этого выкинули.

Упаковка запроса. Сборка слоёв, обрезка и сжатие так, чтобы вход влез в бюджет.

Обязательная строка. Фрагмент текста, который после упаковки обязан остаться во входе.

Учебная оценка токенов. Грубая прикидка вроде «слова × 1,3» или «символы ÷ 4»; не замена настоящему токенизатору.

Токенизатор. Настоящая программа модели, которая режет текст на токены по своим правилам.

Сравнение до/после. Печать длины и состава запроса до упаковки и после, чтобы увидеть цену экономии.

Проверка входа. Контроль целостности запроса; это не то же самое, что проверка качества ответа.

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

Словарь целиком — /slovar, новости — /novosti.