Что такое токены и контекстное окно в ИИ

Короткое объяснение

Токены - это маленькие части текста, с которыми работает языковая модель. Модель не видит текст так, как человек видит страницу. Она разбивает фразы на токены: слова, части слов, пробелы, знаки препинания, куски кода и другие символы.

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

Если совсем просто:

1. токены - это единицы текста для модели;
2. контекстное окно - это “рабочий стол” модели в одном запросе;
3. чем больше текста вы кладете в запрос, тем больше токенов расходуется;
4. когда лимит контекста заканчивается, часть данных приходится сокращать, удалять или заменять кратким summary;
5. стоимость API часто считается по входным и выходным токенам.

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

Что такое токен

Токен - это фрагмент текста после разбиения на части. Токен может быть целым словом, частью слова, знаком препинания, пробелом, числом или куском кода.

Примерно так:

1. короткое частое слово может быть одним токеном;
2. длинное слово может разбиться на несколько токенов;
3. редкое слово может разбиться на части;
4. знак препинания тоже может занимать токен;
5. код часто расходует много токенов;
6. таблицы и JSON тоже превращаются в токены;
7. русский текст может расходовать токены иначе, чем английский.

Важно: токен - это не то же самое, что слово. Нельзя точно считать “1 слово = 1 токен”. Для грубой оценки можно думать так: чем длиннее текст и чем сложнее структура, тем больше токенов.

Почему модели работают с токенами

Языковой модели удобнее работать не с буквами и словами как человеку, а с числовыми представлениями фрагментов текста. Перед обработкой текст проходит токенизацию.

Упрощенно процесс такой:

1. пользователь пишет запрос;
2. система добавляет инструкции и историю диалога;
3. текст разбивается на токены;
4. токены превращаются в числовые представления;
5. модель учитывает связи между токенами;
6. модель генерирует следующий токен;
7. новый токен добавляется к ответу;
8. процесс повторяется, пока ответ не завершится.

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

Что входит в расход токенов

В токены считается не только ваш вопрос. В реальном запросе к модели может быть несколько слоев.

Обычно в расход входят:

1. системная инструкция;
2. developer-инструкции приложения;
3. пользовательский промпт;
4. история диалога;
5. вставленные документы;
6. найденные RAG-фрагменты;
7. описания инструментов;
8. результаты вызовов инструментов;
9. промежуточные данные;
10. финальный ответ модели.

Поэтому короткий вопрос в интерфейсе может на самом деле быть большим запросом внутри системы.

Входные и выходные токены

В AI-сервисах часто разделяют input tokens и output tokens.

Input tokens - это все, что модель получила на вход:

1. инструкции;
2. вопрос пользователя;
3. история;
4. документы;
5. контекст из базы знаний;
6. схемы инструментов.

Output tokens - это то, что модель сгенерировала в ответ:

1. текст ответа;
2. таблица;
3. JSON;
4. код;
5. аргументы tool call;
6. пояснения.

Для API цена часто считается отдельно за вход и выход. Поэтому длинный документ на входе и длинный ответ на выходе увеличивают стоимость.

Что такое контекстное окно

Контекстное окно - это максимальный объем токенов, который модель может учитывать в одном запросе. В этот лимит входит и вход, и будущий ответ.

Представьте рабочий стол. На него можно положить:

1. инструкцию;
2. вопрос;
3. историю разговора;
4. несколько документов;
5. найденные фрагменты базы знаний;
6. черновик ответа.

Но стол не бесконечный. Если положить слишком много, что-то придется убрать или сократить. Контекстное окно работает похожим образом.

Что происходит, когда контекст переполнен

Если данных больше, чем помещается в контекстное окно, система должна принять решение.

Возможные варианты:

1. обрезать старую историю;
2. сократить документы;
3. взять только найденные фрагменты;
4. сделать summary длинного текста;
5. отказать и попросить меньше данных;
6. разбить задачу на несколько запросов;
7. использовать RAG;
8. выбрать модель с большим контекстом.

Если этого не сделать аккуратно, модель может не увидеть важную часть задачи. Тогда она отвечает уверенно, но мимо.

Почему ИИ забывает начало диалога

Модель не хранит весь диалог “в голове” навсегда. Каждый новый ответ строится на том контексте, который приложение передало модели прямо сейчас.

Если диалог длинный, старые сообщения могут:

1. полностью выпасть из контекста;
2. быть сжаты в summary;
3. попасть в контекст частично;
4. оказаться ниже по приоритету, чем новые сообщения;
5. конфликтовать с более свежими инструкциями.

Поэтому в длинных диалогах полезно периодически фиксировать важные решения:

1. “Запомни итоговые требования”.
2. “Сделай краткое резюме текущих договоренностей”.
3. “Дальше используй вот эти правила”.
4. “Игнорируй старую версию плана, работаем по новой”.

Так вы помогаете системе сохранить актуальный контекст.

Почему большой контекст не всегда лучше

Большое контекстное окно полезно, но оно не решает все проблемы.

Минусы слишком длинного контекста:

1. выше стоимость;
2. дольше ответ;
3. больше шума;
4. сложнее найти важное;
5. выше риск противоречий;
6. модель может уделить внимание не тем фрагментам;
7. сложнее проверять качество;
8. больше риск утечки лишних данных.

Хороший контекст - не самый большой, а самый релевантный. Часто лучше дать модели 5 точных фрагментов, чем 200 страниц без отбора.

Как токены влияют на стоимость

Если вы используете ИИ через API, стоимость обычно зависит от количества токенов. Чем больше вход и выход, тем выше цена.

На стоимость влияют:

1. длина системного промпта;
2. длина истории диалога;
3. объем документов;
4. количество RAG-фрагментов;
5. длина ответа;
6. повторные запросы;
7. ретраи после ошибок;
8. вызовы нескольких моделей;
9. генерация таблиц и кода;
10. обработка больших файлов.

Поэтому в production-сценариях считают token usage, задают лимиты и оптимизируют контекст.

Как токены влияют на скорость

Большой запрос обычно обрабатывается дольше. Модели нужно прочитать входной контекст и сгенерировать ответ.

На задержку влияют:

1. размер входного контекста;
2. длина ответа;
3. сложность задачи;
4. выбранная модель;
5. число tool calls;
6. retrieval из базы знаний;
7. сетевые задержки;
8. очередь запросов у провайдера.

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

Как токены влияют на качество

Качество зависит не только от модели, но и от того, что попало в контекст.

Проблемы возникают, когда:

1. важный факт не попал в запрос;
2. контекст слишком длинный и шумный;
3. документы противоречат друг другу;
4. старые инструкции конфликтуют с новыми;
5. история диалога содержит ошибочные предположения;
6. RAG нашел не тот фрагмент;
7. в контексте есть лишние данные;
8. формат ответа не задан.

Иногда модель “ошибается” не потому, что слабая, а потому что ей дали плохой контекст.

Что такое max tokens

Max tokens - это ограничение на длину ответа модели. В разных интерфейсах и API это может называться по-разному, но смысл один: сколько токенов модель может сгенерировать в ответе.

Если лимит слишком маленький:

1. ответ обрывается;
2. таблица не помещается;
3. код выходит неполным;
4. модель не успевает объяснить вывод;
5. JSON может стать невалидным.

Если лимит слишком большой:

1. ответ может стать длинным и водянистым;
2. стоимость выше;
3. задержка больше;
4. пользователю сложнее читать.

Для рабочих задач полезно задавать желаемый объем: “до 1000 знаков”, “10 пунктов”, “таблица на 5 строк”, “краткий вывод”.

Как примерно оценить токены без калькулятора

Точная оценка зависит от конкретной модели и токенизатора. Но для бытовой работы достаточно грубой логики.

Больше токенов расходуют:

1. длинные документы;
2. таблицы;
3. списки с большим количеством пунктов;
4. код;
5. JSON;
6. многоязычный текст;
7. повторяющиеся инструкции;
8. история длинного чата;
9. большие RAG-фрагменты;
10. длинные ответы.

Чтобы снизить расход, можно:

1. удалить лишнюю историю;
2. сократить системный промпт;
3. передавать только нужные документы;
4. просить короткий ответ;
5. разбивать задачу на этапы;
6. использовать summary;
7. хранить знания в RAG, а не вставлять все вручную.

Контекст в ChatGPT и контекст в API

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

В API разработчик контролирует больше:

1. какие сообщения отправить;
2. сколько истории оставить;
3. какие документы добавить;
4. сколько RAG-фрагментов вставить;
5. какой лимит ответа задать;
6. какие инструменты описать;
7. какие данные не отправлять.

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

Чем контекст отличается от памяти

Контекст - это то, что модель видит прямо сейчас в одном запросе. Память - это данные, которые система хранит между запросами и может добавить в будущий контекст.

Пример:

1. контекст: текущий вопрос, последние сообщения и найденные документы;
2. память: имя пользователя, выбранный стиль, прошлые решения, сохраненные настройки;
3. RAG-база: внешние документы, из которых система выбирает релевантные фрагменты;
4. база данных: факты, статусы, заказы, задачи, которые можно получить через tools.

Большое контекстное окно не заменяет память. Оно просто позволяет положить больше данных в один запрос.

Как RAG помогает с контекстом

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

Упрощенная схема:

1. пользователь задает вопрос;
2. система ищет похожие фрагменты в базе знаний;
3. выбирает несколько самых релевантных;
4. вставляет их в контекст;
5. модель отвечает на основе этих фрагментов;
6. система может показать ссылки на источники внутри базы.

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

Что такое chunking

Chunking - это разбиение длинных документов на фрагменты. Эти фрагменты потом можно искать и передавать модели через RAG.

Хороший chunk должен быть:

1. достаточно коротким, чтобы не забивать контекст;
2. достаточно полным, чтобы сохранять смысл;
3. связанным с заголовком или разделом;
4. без случайного обрыва важной мысли;
5. с метаданными: источник, дата, раздел, URL;
6. проверяемым после retrieval.

Слишком маленькие chunks теряют смысл. Слишком большие chunks засоряют контекст.

Как писать промпты с учетом контекста

Чтобы модель лучше использовала контекст, формулируйте задачу явно.

Хороший промпт:

Используй только данные из контекста ниже. Если ответа нет в контексте, так и скажи. Сначала дай краткий ответ, затем перечисли пункты, на которые ты опирался.

Полезные правила:

1. отделяйте контекст от задания;
2. пишите, можно ли использовать знания модели вне контекста;
3. просите указать, если данных не хватает;
4. задавайте формат ответа;
5. просите не делать выводы без оснований;
6. не смешивайте десять разных задач в одном запросе.

Как уменьшить расход токенов

Практические способы:

1. удаляйте повторяющиеся инструкции;
2. сокращайте историю диалога;
3. используйте summary для старых сообщений;
4. передавайте только релевантные документы;
5. ограничивайте количество RAG-фрагментов;
6. просите конкретный формат ответа;
7. не просите длинный текст, если нужен короткий вывод;
8. храните большие данные вне промпта;
9. используйте tools для точечных запросов к базе;
10. логируйте token usage и смотрите, где расход растет.

Экономия токенов - это не только про деньги. Это еще про скорость, качество и управляемость.

Типичные ошибки

Чаще всего ошибаются так:

1. вставляют весь документ вместо нужного раздела;
2. отправляют всю историю чата без отбора;
3. делают огромный системный промпт на все случаи жизни;
4. забывают, что ответ тоже занимает токены;
5. не задают лимит длины ответа;
6. не проверяют, какие RAG-фрагменты реально попали в контекст;
7. смешивают старые и новые требования;
8. ждут, что модель “помнит” то, чего нет в текущем запросе;
9. передают секреты и персональные данные;
10. считают токены словами один к одному.

Хорошая привычка: перед важным запуском посмотреть, что именно попадет в модельный запрос.

Мини-чеклист для работы с контекстом

Перед отправкой длинной задачи проверьте:

1. понятна ли цель;
2. есть ли нужные данные;
3. убран ли лишний шум;
4. нет ли секретов;
5. не противоречат ли фрагменты друг другу;
6. задан ли формат ответа;
7. задан ли допустимый объем;
8. указано ли, что делать при нехватке данных;
9. не слишком ли длинная история;
10. нужен ли RAG вместо ручной вставки документов.

Если эти пункты закрыты, модель обычно отвечает заметно лучше.

Что изучать дальше

После токенов и контекстного окна стоит разобраться в смежных темах:

1. что такое prompt;
2. что такое системный промпт;
3. что такое RAG;
4. что такое embeddings;
5. что такое hallucination;
6. как добавлять память ИИ-агенту;
7. как выбирать модель под задачу;
8. как считать стоимость AI-сценария;
9. как тестировать ответы модели;
10. как проектировать базу знаний.

Токены и контекст - это фундамент для всех этих тем.

Частые вопросы

Токен - это слово?

Не совсем. Токен может быть словом, частью слова, знаком препинания, пробелом, числом или фрагментом кода. Поэтому нельзя точно считать токены по количеству слов без токенизатора.

Контекстное окно - это память модели?

Нет. Контекстное окно - это объем данных, который модель видит в одном запросе. Память - это данные, которые приложение сохраняет между запросами и при необходимости добавляет в контекст.

Почему длинный промпт может ухудшить ответ?

Потому что длинный промпт может содержать шум, противоречия и лишние детали. Модель тратит внимание на весь контекст, поэтому релевантные факты лучше отбирать, а не просто вставлять все подряд.

Что делать, если документ не помещается в контекст?

Разбейте документ на части, сделайте summary, используйте RAG или задавайте вопросы по разделам. Для продукта лучше хранить документы в базе знаний и передавать модели только найденные фрагменты.

Почему API считает цену в токенах?

Потому что модель обрабатывает входной текст и генерирует выходной текст токенами. Чем больше входных и выходных токенов, тем больше вычислений, задержка и стоимость запроса.