Как не потерять важные факты, когда длинный разговор перестаёт влезать в одно окно модели. Пять ступеней: что реально обрезают при переполнении, как упорядочить слои запроса, как сжать историю кратким пересказом, куда вынести факты во внешнюю память и как проверить, что после упаковки важное ещё на месте. Все примеры на Python запускаются у тебя без доступа к модели и без дополнительных библиотек: длины считают грубыми учебными оценками, ответы и тексты записаны заранее.
Все дорожки — /put. Прошлая — как проверить, что модель справляется с задачей.
Зачем это в работе. Длинный чат с клиентом или с самим собой рано или поздно упирается в потолок: модель за один запрос видит только ограниченный объём текста. Если не понимать, что именно выкидывают, важные факты — номер заказа, адрес, запрет на скидку — исчезают тихо, а ответ выглядит уверенным, будто этих фактов никогда не было.
Окно контекста (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). Выбрасывание части текста, чаще всего самых старых реплик, чтобы остальное влезло в лимит.
Бюджет входа. Сколько токенов остаётся на инструкцию и историю после запаса под ответ.
Место под ответ. Запас токенов внутри окна, который оставляют, чтобы модели было куда писать.
Память чата. У модели её нет: прошлое нужно снова положить в запрос, иначе его для неё не было.
Долгое хранилище. Файлы и заметки снаружи модели; они не попадают в запрос сами.
Зачем это в работе. Когда места мало, важно не только что выкинуть, но и в каком порядке собрать то, что осталось. Если вопрос клиента окажется в середине болтовни, а критичные факты — в самом начале, которое потом обрежут, модель получит странный обрывок и ответит мимо. Слои с разным приоритетом помогают решить, что обязано выжить.
Слой запроса — это отдельный смысловой блок текста, который программа кладёт во вход: системная инструкция, список критичных фактов, найденные куски документов, старая история, текущий вопрос. Их удобно мыслить как этажи: верхние этажи (инструкция, факты, вопрос) выкидывать нельзя, нижние (светская болтовня, давно закрытые мелкие реплики) — самые дешёвые кандидаты на выброс.
Частый и полезный порядок сборки такой: сначала системная инструкция (кто ты и какие запреты), потом коротко критичные факты, потом найденные куски или нужный кусок истории, и в самом конце — текущий вопрос. Вопрос в конце ставят потому, что модель продолжает текст «вправо»: задача рядом с местом ответа обычно лучше удерживается, чем задача, утонувшая в середине длинного входа.
Не путай слой найденных документов с «памятью модели». Поиск по своим файлам (то, о чём дорожка про поиск и подход 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). Реплики без рабочих фактов; их обычно выкидывают первыми.
Зачем это в работе. Обрезка решает нехватку места жёстко: старое просто исчезает. Часто нужен мягче вариант — оставить в запросе короткий пересказ того, о чём уже договорились, вместо десяти полных реплик. Места становится больше, но детали теряются, и это надо учитывать заранее.
Сжатие истории (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, адрес, запрет, решение.
Сосед обрезки. Обрезка удаляет текст; сжатие оставляет короткий, уже неточный остаток.
Исходный лог. Полные реплики снаружи запроса; нужны, когда важна дословность.
Зачем это в работе. Даже идеальный пересказ всё ещё сидит внутри запроса и ест токены. Факты, которые должны жить между сессиями — правила скидок, карточка заказа, решение от прошлой недели, — лучше хранить снаружи и подставлять поиском только когда они нужны. Тогда чат может быть коротким, а знание — длинным.
Внешняя память здесь — обычные заметки, таблица или файлы, к которым программа умеет обратиться: найти подходящий кусок и положить его слоем в запрос. Это прямо продолжает дорожку про поиск по своим заметкам: кусок текста достают по смыслу или по словам, а модель отвечает уже с опорой на найденное, а не на весь архив чата.
Отличие от пересказа важное. Пересказ живёт внутри текущего запроса и занимает место всегда, пока ты его туда кладёшь. Внешняя заметка лежит снаружи: в этом запросе её может не быть вовсе, если поиск решил, что она не нужна. Зато через неделю в новом чате ту же заметку можно найти снова — модель «не обязана» помнить прошлый диалог.
В заметку пишут стабильные факты и правила, а не поток сознания. Хороший шаблон: идентификатор, поля «ключ: значение», дата решения, ссылка на правило. Плохой шаблон: длинный художественный пересказ всего чата без структуры — его и искать неудобно, и в запрос он снова раздует окно.
Связка со слоями из второй ступени такая: найденные заметки становятся слоем 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, адрес, правило, дата решения.
Поиск по заметкам. Отбор нужных кусков по словам или по смыслу перед ответом модели.
Сессия. Один непрерывный разговор; между сессиями модель сама прошлое не тащит.
Сосед пересказа. Пересказ всё ещё внутри запроса; внешняя заметка подставляется только когда нужна.
Целиком файл. Антипример: тащить большой документ без отбора и снова упираться в окно.
Зачем это в работе. Обрезка, слои, сжатие и внешняя память имеют смысл, только если после упаковки запроса ты умеешь проверить результат. Иначе система «оптимизирует» вход и незаметно выкидывает номер заказа или правило скидки, а ты узнаешь об этом из жалобы клиента.
Первая проверка — оценка бюджета. Перед отправкой считают приблизительную длину входа и сравнивают с лимитом минус запас под ответ. Для учёбы достаточно грубых оценок: число слов × 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»; не замена настоящему токенизатору.
Токенизатор. Настоящая программа модели, которая режет текст на токены по своим правилам.
Сравнение до/после. Печать длины и состава запроса до упаковки и после, чтобы увидеть цену экономии.
Проверка входа. Контроль целостности запроса; это не то же самое, что проверка качества ответа.
Стоп-условие. Правило программы: если обязательного нет или бюджет сорван — не слать запрос, а чинить упаковку.