дорожка · 07.10.2026 · ответ строго по форме

Как получить от модели ответ строго по форме

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

Все дорожки — /put. Прошлая — как модель выбирает следующее слово.

1 Почему свободный текст ломает программу

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

Программа читает ответ с помощью парсера (parser) — кода, который разбирает текст по строгим правилам и превращает его в данные: словарь, список, число. Самый частый формат для таких данных — JSON: текст, где данные записаны в фигурных скобках парами «имя поля: значение», например {"kategoriya": "возврат"}. В Python его разбирает функция json.loads. Парсер ничего не угадывает: одна лишняя запятая или не та кавычка — и он падает с ошибкой.

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

Поэтому просьба «ответь в JSON» срабатывает часто, но не всегда. Типичные поломки такие: текст до или после данных; обёртка ```json; одинарные кавычки вместо двойных; запятая после последнего поля; поле названо иначе, чем ждёт код («цена» вместо price); и обрыв на середине, когда ответ упёрся в лимит длины (max tokens) — настройку, которая задаёт, сколько токенов модель может выдать за один ответ.

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

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

import json

otvet = 'Конечно! Вот результат:\n```json\n{"kategoriya": "возврат",}\n```'
try:
    json.loads(otvet)
except json.JSONDecodeError as e:
    print("не разобралось:", e)

kusok = otvet[otvet.find("{"): otvet.rfind("}") + 1]
print("вырезали:", kusok)
try:
    json.loads(kusok)
except json.JSONDecodeError as e:
    print("и вырезка не спасла:", e)

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

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

  • Проверяют просьбу «верни JSON» на пяти примерах, видят пять удач и считают, что так будет всегда. Поломки редкие, но на тысяче писем они обязательно появятся.
  • Пишут всё новые регулярные выражения (шаблоны поиска по тексту), чтобы чинить ответы. Это бесконечная работа: чинить надо форму на входе, а не мусор на выходе.
  • Забывают про лимит длины. Длинный список, оборванный на середине, — это не «немного другой JSON», а неразбираемый текст.

Парсер (parser). Код, который читает текст по строгим правилам и превращает его в данные.

JSON. Текстовый формат данных из пар «имя поля: значение» в фигурных скобках и списков в квадратных.

Разбор (parsing). Превращение текста в данные; при малейшей ошибке записи он не удаётся.

Обёртка markdown. Тройные обратные кавычки, которыми чат оформляет код; для парсера это лишние символы.

Лимит длины ответа (max tokens). Наибольшее число токенов, которое модель может выдать за один ответ; при упоре ответ обрывается.

Синтаксис. Правильность записи: скобки, кавычки, запятые.

Содержание. Правильность самих значений; правильная запись его не гарантирует.

2 Схема: описать форму ответа заранее

Зачем это в работе. Чтобы модель и программа договорились, форму надо записать не словами «верни категорию и срочность», а точным описанием: какие поля, какого они типа и какие значения допустимы. Тогда одна и та же запись говорит модели, что писать, а коду — что принимать.

Такое описание называется схемой (schema). Самый распространённый язык схем для JSON — JSON Schema: это тоже JSON, в котором сказано, например, «объект с полем kategoriya; это строка, и она может быть только одной из трёх: возврат, доставка, другое». Список допустимых значений называется перечислением (enum), а поля, без которых ответ не принимается, — обязательными (required).

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

В Python схему удобно не писать руками, а описать обычным классом через библиотеку pydantic (ставится командой pip install pydantic). Ты перечисляешь поля и их типы, а библиотека сама строит из класса JSON Schema (метод model_json_schema) и сама проверяет ответ (метод model_validate_json). Тип Literal[...] и есть перечисление: он разрешает только перечисленные строки.

Ограничение: чем сложнее схема — глубокая вложенность, десятки полей, поля, которые зависят друг от друга, — тем чаще модель ошибается и тем длиннее сам ответ. К тому же строгие режимы сервисов, о которых следующая ступень, обычно поддерживают не все возможности JSON Schema, а только часть; какую именно, написано в документации конкретного сервиса. Соседнее понятие — образец ответа в запросе (few-shot): пара готовых примеров «вот письмо, вот разбор». Образец показывает «примерно так» и помогает со стилем и содержанием, схема говорит «только так» и отвечает за форму. Их часто используют вместе.

Подробный пример. Опишем разбор письма тремя полями: категория из трёх вариантов, признак срочности (логическое значение: да или нет, в JSON это true или false) и краткое пересказанное содержание. Код печатает схему, которую можно отдать модели, затем принимает правильный ответ и отвергает ответ с выдуманной категорией:

import json
from typing import Literal
from pydantic import BaseModel, ValidationError

class Pismo(BaseModel):
    kategoriya: Literal["возврат", "доставка", "другое"]
    srochno: bool
    kratko: str

print(json.dumps(Pismo.model_json_schema(), ensure_ascii=False, indent=2))

print(Pismo.model_validate_json(
    '{"kategoriya": "доставка", "srochno": true, "kratko": "посылка застряла"}'))

try:
    Pismo.model_validate_json('{"kategoriya": "жалоба", "srochno": true, "kratko": "…"}')
except ValidationError as e:
    print(e)

В напечатанной схеме видно всё, что мы задали классом: у kategoriya есть enum из трёх слов, у srochno тип boolean, и все три поля перечислены в required. Правильный ответ превращается в объект, с которым дальше работает код. Ответ с категорией «жалоба» не проходит, и ошибка говорит точно, что не так: какое поле и какие значения допустимы. Эта точность пригодится на четвёртой ступени.

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

  • Задают поле категории просто как строку без перечисления. Тогда модель пишет то «возврат», то «Возврат товара», то refund, и код, который сравнивает строки, работает через раз.
  • Дают полям непонятные имена вроде f1 и f2. Модель видит имена и решает по ним, что туда класть; понятное имя и короткое описание поля — часть инструкции.
  • Пытаются за один запрос вытащить сразу тридцать полей. Надёжнее разбить работу на несколько небольших схем и запросов.

Схема (schema). Точное описание формы данных: какие поля, какого типа, какие значения допустимы.

JSON Schema. Распространённый язык схем для JSON, сам записанный в виде JSON.

Перечисление (enum). Короткий список единственно допустимых значений поля.

Обязательное поле (required). Поле, без которого ответ не принимается.

Валидация (validation). Проверка, что данные соответствуют схеме.

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

Логическое значение (boolean). Значение «да или нет»; в JSON записывается как true или false.

Образец в запросе (few-shot). Готовые примеры «вход — правильный ответ», которые показывают модели стиль и содержание.

3 Ограниченный выбор токенов: как сервис удерживает форму

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

Вспомним: на каждом шаге модель выдаёт оценки всем токенам своего словаря, софтмакс превращает их в вероятности, а отдельная программа выбирает один токен. Ограниченное декодирование (constrained decoding) добавляет перед выбором фильтр. Программа знает схему и знает, что уже написано, поэтому может сказать, какие символы сейчас вообще допустимы: в самом начале — только открывающая фигурная скобка, после имени поля — только двоеточие, в поле srochno — только true или false.

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

Чтобы на каждом шаге понимать, что допустимо, схему заранее переводят в грамматику (grammar) — набор правил о том, какие последовательности символов правильны, — и программа отслеживает, в каком месте этих правил она сейчас находится. Трудность в том, что токены — кусочки разной длины: один токен может одновременно закрыть кавычку и поставить запятую. Поэтому проверяют каждый кандидат целиком, а не по одному символу. Отсюда и ограничение строгих режимов: не всякую схему удаётся перевести в такие правила, поэтому сервисы поддерживают лишь часть JSON Schema.

Маска гарантирует форму, но не смысл. Если модель «хотела» написать категорию, которой нет в перечислении, её заставят выбрать из разрешённых, и она выберет ту, у которой после фильтра больше вероятность, даже если та неверна по сути. И маска не спасает от лимита длины: если ответ оборвался, незакрытый JSON так и останется незакрытым. Соседнее понятие — режим «просто JSON» (JSON mode), который есть у некоторых сервисов: он добивается, чтобы получился какой-нибудь правильный JSON, но не обещает, что поля совпадут с твоей схемой. Строгий режим по схеме (у разных сервисов называется по-разному, например structured outputs) ограничивает выбор именно твоей схемой.

Подробный пример. Модель уже написала {"srochno": и выбирает следующий токен. Возьмём учебные, придуманные для наглядности вероятности: true 0,30, «Да» 0,55, false 0,15. Без маски жадный выбор взял бы «Да» — по смыслу верно, но JSON сломан. С маской «Да» запрещено, и оставшиеся доли пересчитываются:

p = {"true": 0.30, "Да": 0.55, "false": 0.15}
razresheno = {"true", "false"}

ostalos = {t: v for t, v in p.items() if t in razresheno}
s = sum(ostalos.values())
print({t: round(v / s, 3) for t, v in ostalos.items()})

Получается true 0,667 и false 0,333: 0,30 и 0,15 делим на их сумму 0,45. Здесь смысл сохранился, потому что «Да» и true значат одно и то же. Но представь, что модель хотела написать категорию «жалоба», а в перечислении её нет: маска молча отдаст её долю ближайшей разрешённой категории, и ответ будет правильным по форме и неверным по сути. Об этом пятая ступень.

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

  • Думают, что строгий режим проверяет факты. Он проверяет только то, что ответ подходит под схему.
  • Включают строгий режим и убирают проверку в коде. Обрыв по лимиту длины и ошибки содержания строгий режим не ловит, поэтому проверка остаётся.
  • Отправляют сложную схему и удивляются ошибке ещё до ответа: сервис отказался, потому что поддерживает не все возможности JSON Schema. Сначала смотрят документацию конкретного сервиса.

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

Маска (mask). Фильтр, который ставит недопустимым токенам нулевую вероятность.

Перенормировка. Пересчёт оставшихся вероятностей, чтобы в сумме снова была единица.

Грамматика (grammar). Набор правил о том, какие последовательности символов правильны.

Режим JSON (JSON mode). Режим сервиса, который добивается правильного JSON, но не следит за твоей схемой.

Строгий режим по схеме (structured outputs). Режим, в котором выбор токенов ограничен именно твоей схемой.

Гарантия формы. Уверенность, что ответ разберётся, но не что он верен по сути.

4 Проверка и повтор: что делать, если ответ не прошёл

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

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

Если проверка не прошла, частый приём — повторный запрос (retry), в который добавляют прошлый ответ модели и текст ошибки: «поле kategoriya может быть только возврат, доставка или другое, а пришло жалоба». Модель видит конкретную ошибку и часто её исправляет, но не всегда, поэтому число повторов ограничивают заранее, обычно двумя-тремя. Это отличается от повтора при сбое сети: там шлют тот же запрос ещё раз, а здесь запрос меняют. Повтор того же запроса при низкой температуре, как мы помним, часто даёт ту же самую ошибку.

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

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

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

from typing import Literal
from pydantic import BaseModel, ValidationError

class Pismo(BaseModel):
    kategoriya: Literal["возврат", "доставка", "другое"]
    srochno: bool

# вместо настоящей модели — заранее записанные ответы
otvety = ['{"kategoriya": "жалоба", "srochno": true}',
          '{"kategoriya": "другое", "srochno": true}']

def sprosit_model(zapros, popytka):
    return otvety[popytka]

zapros = "Разбери письмо: «Курьер нагрубил, верните деньги за доставку»."
for popytka in range(3):
    tekst = sprosit_model(zapros, popytka)
    try:
        pismo = Pismo.model_validate_json(tekst)
        print("принято с попытки", popytka + 1, ":", pismo)
        break
    except ValidationError as e:
        oshibka = e.errors()[0]["msg"]
        print("попытка", popytka + 1, "ошибка:", oshibka)
        zapros += (f"\nТвой прошлый ответ: {tekst}"
                   f"\nОшибка проверки: {oshibka}"
                   "\nИсправь и верни только JSON.")
else:
    print("три неудачи — письмо в ручную очередь")

Первая попытка не проходит, и в журнал попадает понятная причина. Вторая принимается. Обрати внимание на конструкцию for … else: блок else выполняется, только если цикл закончился без break, то есть все попытки провалились. Чтобы подключить настоящую модель, достаточно заменить одну функцию sprosit_model, а вся логика проверки, повтора и запасного пути останется прежней.

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

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

Бизнес-правило. Проверка смысла данных, которую схема выразить не может, например «дата не в будущем».

Повторный запрос (retry). Новый запрос с прошлым ответом и текстом ошибки, чтобы модель исправилась.

Предел повторов. Заранее заданное наибольшее число попыток.

Запасной путь (fallback). Что делать, если все попытки провалились: ручная очередь, пометка или явная ошибка.

Ошибка проверки (ValidationError). Исключение pydantic с точным указанием, какое поле и почему не прошло.

Доля с первой попытки. Сколько ответов прошло проверку сразу; измеряется по своему журналу.

Журнал (log). Записи о каждом ответе и проверке, по которым видно надёжность.

5 Форма не равна правде: схема под смысл

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

Если поле обязательное и не может быть пустым, модель обязана что-то в него вписать. Попроси достать из письма номер заказа, а номера в письме нет, — и модель вполне может вписать правдоподобный номер, потому что пустой вариант схема запретила, а при ограниченном выборе токенов ей и вовсе не дадут выйти из поля. Лечится тем, что полю разрешают быть пустым: тип «строка или null». Null — это значение «ничего» в JSON, в Python оно называется None. В описании поля прямо пишут: «если номера в письме нет, верни null». Поле при этом остаётся обязательным: модель должна его упомянуть, но может честно оставить пустым.

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

Перечисления делают ответ проверяемым, но только если в них есть выход: вариант «другое» или «не уверен». Без него маска с третьей ступени втиснет странное письмо в неподходящую категорию, и ответ будет выглядеть совершенно нормально. Даты и числа тоже лучше просить в однозначном виде: дату в формате ISO, то есть 2026-10-07, а не «7 октября», где непонятен год и легко спутать порядок.

Ограничение: схема не измеряет точность. Чтобы знать, насколько содержание верно, нужен набор проверочных примеров (eval set): несколько десятков настоящих писем, для которых ты сам заранее записал правильные поля, и простой подсчёт совпадений. Это уже не форма, а оценка качества — продолжение ступени «Контроль» с основной дорожки. Соседнее понятие — поле «уверенность модели» в схеме, например confidence: 0.95: это тоже сгенерированный текст, а не измерение, и на него нельзя опираться вместо проверочного набора.

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

from typing import Literal
from pydantic import BaseModel, Field

class Pismo(BaseModel):
    citata: str = Field(description="Дословная фраза из письма, на которой основан выбор")
    kategoriya: Literal["возврат", "доставка", "другое"]
    nomer_zakaza: str | None = Field(description="Номер заказа из письма; если его нет — null")

print(list(Pismo.model_json_schema()["properties"]))
print(Pismo.model_json_schema()["required"])

etalon = [("доставка", None), ("возврат", "A-1043"), ("другое", None)]
model  = [("доставка", "A-0001"), ("возврат", "A-1043"), ("доставка", None)]
sovpalo = sum(e == m for e, m in zip(etalon, model))
print(f"совпало {sovpalo} из {len(etalon)}")

Код печатает порядок полей и список обязательных: все три обязательны, но nomer_zakaza может быть пустым. Подсчёт даёт «совпало 1 из 3», и обе ошибки показательны. В первом письме номера не было, а модель вписала «A-0001» — ровно та выдумка, от которой спасает разрешённый null вместе с описанием поля. В третьем письме категория неверная, и никакая схема этого не поймала бы: заметить это может только проверочный набор. Правь схему или инструкцию, запускай набор снова и сравнивай числа совпадений до и после.

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

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

Null. Значение «ничего» в JSON; в Python ему соответствует None.

Пустое значение по праву (nullable). Поле, которое обязано присутствовать, но может честно быть пустым.

Порядок полей. Последовательность, в которой модель пишет поля; поздние поля видят ранние.

Опора (цитата). Дословный кусок исходного текста, выписанный до вывода и проверяемый кодом.

Выход из перечисления. Вариант «другое» или «не уверен», чтобы не втискивать ответ в неподходящую категорию.

Формат ISO. Однозначная запись даты вида 2026-10-07: год, месяц, день.

Набор проверочных примеров (eval set). Входы с заранее известными правильными ответами для подсчёта точности.

Эталон. Правильный ответ из проверочного набора, с которым сравнивают ответ модели.

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