Начало работы

Что такое Delirium API

Delirium API — это универсальное решение для доступа к API ведущих сервисов в области искусственного интеллекта, таких как OpenAI, Anthropic и Gemini. Сервис выступает в роли посредника: запросы отправляются на наш сервер, который перенаправляет их через цепочку прокси-серверов в Европе. Мы получаем ответ от целевого сервиса и возвращаем его вам.

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

Ключ API

Для использования Delirium API необходимо получить ключ. Для этого необходимо зарегистрироваться в Telegram-боте.

Авторизация

Для любых запросов к Delirium API универсальным способом авторизации является передача ключа в заголовке:

Authorization: Bearer <КЛЮЧ>

Однако, в целях поддержки официальных библиотек мы также принимаем другие формы авторизации, например заголовок x-api-key для Anthropic или параметр key строки запроса для Gemini. В любом случае, использовать нужно именно наш ключ.

Путь к API

Для того, чтобы использовать сервис Delirium API, запросы необходимо отправлять по адресу https://api.delirium.ru

В зависимости от провайдера, к которому идет обращение, после домена также необходимо указывать соответствующий идентификатор, например: https://api.delirium.ru/openai/v1. Об этом можно найти более подробную информацию в соответствующем разделе документации.

Компьютерное зрение или запрос по изображению в API

Большинство API, работающих с искусственным интеллектом, поддерживают работу с изображениями в качестве входных данных. Это позволяет использовать возможности моделей не только для обработки текста, но и для анализа визуального контента. Ниже описаны два основных способа передачи изображений: через URL и в виде закодированной строки base64.

1. Отправка изображения по URL

Если изображение доступно в интернете, вы можете передать ссылку на него. API загружает изображение по этому URL и обрабатывает его.

2. Отправка изображения в виде base64

Если вы не хотите публиковать изображение в интернете, вы можете передать его напрямую в теле запроса в виде строки base64. Это особенно полезно при работе с приватными или временными изображениями.

Рекомендации

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

Кэширование промптов

Что такое кэширование

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

Кэширование промптов решает эту проблему. Провайдер запоминает начало запроса (префикс), и если следующий запрос начинается так же, повторная обработка не требуется. Кэшированные токены тарифицируются по сниженной ставке, а ответ приходит быстрее.

Как это работает

Модель проверяет, совпадает ли начало нового запроса с тем, что уже обработано ранее. Если совпадает — это попадание в кэш (cache hit). Совпадение всегда идёт с начала запроса: если первые 5 000 токенов одинаковые, а дальше идёт новый вопрос пользователя — первые 5 000 будут взяты из кэша.

Поэтому важно располагать содержимое запроса правильно:

• В начале — неизменяемые части: системный промпт, инструкции, описание инструментов, загруженные документы
• В конце — изменяемая часть: вопрос пользователя, новые данные

Когда кэширование полезно

• Длинный системный промпт, одинаковый для всех запросов
• Анализ документа: один и тот же текст с разными вопросами к нему
• Многоступенчатые диалоги: история переписки нарастает, но начало всегда одинаковое
• Агенты с большим набором инструментов (tools/functions)

Поддержка у провайдеров

Подробности о работе кэширования для каждого провайдера — в соответствующих разделах документации.

Как Delirium API учитывает кэш

Delirium API автоматически распознаёт кэшированные токены в ответах провайдеров и тарифицирует их по сниженной ставке. Специальной настройки не требуется — экономия применяется автоматически. Стоимость кэшированных токенов отображается на странице цен отдельной строкой «Кэш чтение».

Пакетная обработка (Batch Processing)

Что такое Batch Processing

Batch Processing позволяет отправить сразу большой набор запросов к модели и получить результаты асинхронно — не в реальном времени, а в течение определённого окна (как правило, до 24 часов). Взамен провайдеры дают скидку 50% на токены по сравнению с обычными синхронными запросами.

Идея простая: если ответ не нужен немедленно, обработку можно подождать ради ощутимой экономии.

Когда это полезно

• Массовая генерация эмбеддингов для базы документов
• Классификация или разметка больших объёмов данных
• Прогон оценочных тестов (evals)
• Любая фоновая обработка, где задержка в несколько часов некритична

Если нужен мгновенный ответ (чат, интерактивный сценарий) — используйте обычные синхронные запросы.

Как это работает

1. Вы формируете набор запросов, каждый со своим идентификатором.
2. Отправляете их одной операцией создания пакета (batch).
3. Провайдер обрабатывает запросы в фоне и складывает результаты.
4. Вы периодически запрашиваете статус пакета (polling), пока он не завершится.
5. Забираете результаты — каждый ответ соотносится с исходным запросом по его идентификатору.

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

Поддержка у провайдеров

Подробности и примеры для каждого провайдера — в соответствующих разделах документации (OpenAI, Anthropic, Google).

Тарификация в Delirium API

• Скидка 50%. Токены пакетных запросов тарифицируются по отдельной batch-ставке — вдвое дешевле обычной. Скидка действует только для моделей, у которых она настроена; актуальный список — на странице цен.
• Платите только за выполненное. Списание происходит по завершении пакета и считается по фактическому использованию из успешных результатов. За отменённые, истёкшие или завершившиеся ошибкой запросы плата не взимается.
• Проверка баланса при создании. Перед запуском Delirium API оценивает максимальную стоимость пакета и требует, чтобы на балансе была сумма с запасом. Если средств недостаточно — пакет не создаётся.

Важные особенности

• Только ваши пакеты. Доступ к пакету возможен только по его идентификатору и только владельцу. Метода «получить список всех пакетов» нет — сохраняйте идентификаторы, которые возвращает создание пакета.
• Формат — как у провайдера. Delirium API не вводит собственный формат: запросы и ответы полностью совпадают с оригинальным Batch API провайдера, поэтому официальные SDK совместимы.
• Модель должна поддерживать batch. Если хотя бы один запрос в пакете ссылается на модель без batch-тарифа или на неподдерживаемый эндпоинт, весь пакет отклоняется при создании — частично обработанных пакетов не бывает.

Запрос баланса

Для удобства пользователей Delirium API предоставляет доступ к балансу личного кабинета посредством простого запроса API.

Разрешения для ключа

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

Метод API

GET https://api.delirium.ru/delirium/balance

Формат ответа

Формат ответа зависит от типа API ключа:

Для ключей без ограничения бюджета:

Возвращается общий баланс аккаунта:

{
    "balance": 123.45
}

Для ключей с ограничением бюджета:

Возвращается баланс, подсчитанный для данного ключа:

{
    "balance": 37.66,
    "budget": {
        "limit": 50.00,
        "used": 12.34
    }
}

Где:

• balance — для неограниченных ключей: общий баланс аккаунта; для ключей с бюджетом: остаток бюджета ключа (рассчитывается как limit — used)
• budget.limit — установленный лимит бюджета для данного ключа
• budget.used — использованная сумма данным ключом

Пример запроса:

curl --location 'https://api.delirium.ru/delirium/balance' --header 'Authorization: Bearer <КЛЮЧ>'

Предварительный подсчет стоимости запроса

Причина ошибки 402 Insufficient balance to run this request

При получении запроса от пользователя на стороне Delirium API происходит предварительный подсчет стоимости запроса, который также можно назвать "прогнозируемый". Это нужно, чтобы баланс пользователя в системе не стал негативным.

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

В этом случае для подсчета токенов ответа берется максимальное число, которое данная модель может вернуть. Для модели OpenAI GPT-4o, например, это 4 096 токенов.

Пример

Допустим, пользователь отправил запрос к модели OpenAI gpt-4o:

{
    "model": "gpt-4o",
    "messages": [
        {
            "role": "user",
            "content": [
                {
                    "type": "text",
                    "text": "Привет! Расскажи про то, как устроена солнечная система"
                }
            ]
        }
    ]
}

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

• Сообщение пользователя — строка "Привет! Расскажи... и т.д." — это 22 токена
• Максимальное количество токенов, которые потенциально может вернуть модель gpt-4o — 4 096 токена

Соответственно у пользователя на счету должно быть минимум: 22 / 1000 * 0,9675 (цена за 1000 токенов запроса) + 4096 / 1000 * 3,8655 (цена за 1000 токенов ответа) = ~15,85 (рублей)

Если средств на счету недостаточно для этого запроса — вернется ошибка.

Реальная стоимость запроса

Важно отметить, что после успешной обработки запроса Delirium API получает от провайдеров реальное потребление токенов. Стоимость запроса заново расчитывается, уже не приблизительно, а точно, и именно эта сумма снимается со счета пользователя.

Как ограничить приблизительный расчет

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

В примерах ниже максимальный ответ ограничен 300 токенами. То есть у пользователя для исполнения этого запроса на балансе должно быть достаточно средств для 22 токенов запроса и 300 токенов ответа.

Пример для OpenAI:

{
    "model": "gpt-4o",
    "max_completion_tokens": 300,
    "messages": [
        ...

Пример для Anthropic:

{
    "model": "claude-3-7-sonnet-20250219",
    "max_tokens": 300,
    "messages": [
        ...

Лимиты запросов к API

Со своей стороны Delirium API никак дополнительно не лимитирует запросы к API, однако, у провайдеров существуют свои ограничения. Они отличаются от провайдера к провайдеру, а также от модели к модели. Лимиты для каждого провайдера, который поддерживается в Delirium API, можно найти на соответствующей странице данной документации.

Обход лимитов

Если для вашего проекта необходимы бóльшие лимиты, чем доступны в данный момент, Delirium API может предложить дополнительные решения. Пожалуйста, свяжитесь с нами в этом случае.

Ошибка: неверный ответ на вопрос «какая ты модель?»

Если задать современным языковым моделям вопрос вроде «Какая ты модель?», нередко можно получить неожиданный и даже неверный ответ. Например, GPT-5 может уверенно заявить, что она — GPT-4o или просто GPT-4. Это классический пример галлюцинации — ситуации, когда модель генерирует информацию, не соответствующую действительности.

Откуда берётся ошибка

Причина кроется в особенностях обучения. Языковые модели обучаются на больших объемах текстовых данных, собранных до их выпуска. На момент обучения GPT-5, самой модели GPT-5 ещё не существовало — в тренировочных данных присутствовала только информация о предыдущих версиях.

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

Как избежать недостоверных ответов

Разработчики API это прекрасно понимают. Именно поэтому любой серьёзный провайдер в ответе API всегда указывает имя модели, которая использовалась для генерации. Этот параметр является единственным надёжным источником истины о том, какая модель фактически выполнила запрос.

Если требуется точно определить модель, нужно ориентироваться исключительно на поле, которое как правило называется model, в API-ответе, а не на текстовый ответ самой модели на вопрос «Кто ты?».

Нативные API провайдеров и универсальный OpenAI-совместимый формат

Delirium API предоставляет два способа обращаться к моделям: нативные эндпоинты каждого провайдера (/v1/messages у Anthropic, …:generateContent у Google, /v1/responses у OpenAI) и универсальный OpenAI-совместимый /v1/chat/completions. Совместимый формат удобен: он позволяет переключать провайдеров без изменения кода и проще для прототипирования. Но он сводит интерфейсы всех провайдеров к подмножеству OpenAI Chat Completions образца 2023 года, и часть провайдер-специфичных возможностей через него либо недоступна, либо работает заметно хуже.

Ниже — конкретные случаи, в которых это имеет значение.

Anthropic: подпись блоков размышлений

В extended thinking (Claude 3.7 и Claude 4 и позже) модель возвращает ответ как последовательность блоков, среди которых есть thinking-блоки с её внутренними рассуждениями. Каждый такой блок сопровождается полем signature — криптографической подписью Anthropic над содержимым блока.

В многоходовом диалоге thinking-блоки последнего ответа модели нужно передавать обратно в следующий запрос байт-в-байт, вместе с подписью. Это не опциональная оптимизация, а часть протокола: подпись позволяет модели верифицировать, что цепочка рассуждений действительно её собственная, а не подделка. Если подпись отсутствует или не совпадает, API возвращает ошибку Invalid signature in thinking block. Если же удалить thinking-блоки из истории «чтобы не падало», модель теряет контекст рассуждений, и качество ответов в агентных сценариях с tool use заметно деградирует.

Поле signature не является частью схемы OpenAI Chat Completions, поэтому при работе через совместимый формат оно может теряться в стриминге или не передаваться обратно — многоходовые сценарии с reasoning перестают работать корректно.

Подробности — в документации Anthropic по extended thinking.

OpenAI: сохранение reasoning между ходами

Reasoning-модели OpenAI (o3, o4-mini, GPT-5) генерируют невидимые reasoning-токены, на которых строится финальный ответ. У OpenAI два API: классический /v1/chat/completions и новый /v1/responses. Принципиальная разница в том, что в Chat Completions reasoning-токены отбрасываются между ходами, а в Responses API они сохраняются и передаются в следующий запрос (через previous_response_id или encrypted_content).

По публикуемым OpenAI замерам, сохранение reasoning-контекста даёт +3% на SWE-bench и +5% на TAU-bench в многоходовых сценариях, а главное — поднимает попадание в кеш с ~20% до ~80%, что в длинных агентных диалогах транслируется в 40–80% экономии на стоимости и latency. Шлюзы, которые реализуют только Chat Completions endpoint, лишают пользователя этой оптимизации автоматически.

См. руководство OpenAI по reasoning models.

Anthropic: prompt caching

Anthropic поддерживает кеширование части промпта со скидкой 90% на чтение из кеша. Управление кешированием — явное: на нужные блоки сообщения проставляется маркер cache_control, и провайдер кеширует префикс именно до этой границы. Это даёт точный контроль: можно закешировать длинный system prompt и список tool definitions, но не закешировать пользовательский ввод, который у каждого запроса свой.

Через универсальный формат cache_control либо не пробрасывается совсем, либо требует нестандартных полей в теле запроса. Иногда поверх делают «автоматическое» кеширование по эвристикам, но оно не даёт контроля над тем, где именно стоит cache breakpoint, и реальный hit rate в результате оказывается заметно ниже, чем при явной разметке.

См. документацию Anthropic по prompt caching.

Anthropic: цитирование источников

Citations API — нативная возможность Anthropic, в которой модель при работе с документами сама расставляет точные ссылки на конкретные предложения в исходниках. Цитаты возвращаются как отдельные структурированные элементы ответа с указанием диапазонов символов в исходных документах. По данным Anthropic, точность таких цитат на 15 процентных пунктов выше, чем у prompt-based решений вида «попроси модель привести ссылки текстом».

В схеме OpenAI Chat Completions нет полей для структурированных цитат, поэтому через совместимый формат эта возможность недоступна.

См. документацию по Citations API.

Gemini: grounding, safety settings, function calling

У Gemini ряд возможностей доступен только через нативный API:

• Grounding with Google Search — встроенный инструмент, который позволяет модели обращаться к актуальной выдаче Google и возвращать groundingMetadata с поисковыми запросами и ссылками на источники.
• thinking_config — управление бюджетом рассуждений и включение thought summaries в ответ.
• safety_settings — гранулярные пороги по четырём категориям контента (harassment, hate speech, sexually explicit, dangerous). Через универсальный формат в лучшем случае остаётся глобальный переключатель.
• Function calling совместно со structured output — нативный API это поддерживает; OpenAI-совместимый endpoint Google возвращает 400 Bad Request при попытке скомбинировать.
• Стриминг аргументов tool call — нативно идёт по мере генерации; в совместимом режиме аргументы буферизуются и приходят одним куском в конце ответа, что критично для интерактивных интерфейсов с «живым» tool use.

См. документацию Google по grounding, thinking и safety settings.

Когда что выбирать

OpenAI-совместимый формат подходит для простых случаев: короткие запросы без reasoning, один и тот же код для разных провайдеров, быстрая миграция с существующего проекта.

Если задача сложнее — агенты с инструментами, длинные диалоги с reasoning-моделями, работа с документами и цитатами, тонкая настройка под конкретного провайдера, — лучше обращаться напрямую к его нативному API. Delirium API передаёт такие запросы провайдеру как есть: тот же формат, тот же официальный SDK, та же документация. Меняется только базовый URL и ключ.

OpenAI‑совместимый API

Введение

В Delirium API поддерживаются оригинальные API самых популярных LLM провайдеров, таких как OpenAI, Anthropic и Gemini. Это сделано для того, чтобы гарантировать доступ ко всем инструментам и особому функционалу, предоставляемому провайдерами искусственного интеллекта.

Однако и у универсального API есть свои преимущества, главным из которых является легкость переключения между моделями разных провайдеров без необходимости использовать разные SDK. В связи с этим, наряду с поддержкой оригинальных API, Delirium API также поддерживает универсальный API на основе спецификации OpenAI.

OpenAI-совместимый API — это прокси‑шлюз, принимающий запросы в формате OpenAI API и автоматически перенаправляющий их к различным LLM-провайдерам. На входе и выходе вы всегда работаете с унифицированным протоколом OpenAI, а конвертация форматов и маршрутизация выполняются на нашей стороне.

Как это работает

1. Клиент отправляет запрос к одному из эндпоинтов /v1/* так же, как если бы он обращался к OpenAI API.
2. Роутер определяет целевого провайдера из поля model (например, anthropic/claude-sonnet-4-20250514).
3. Адаптер переводит тело запроса в нативный формат выбранного провайдера.
4. Ответ от LLM приводится к стандартному формату OpenAI и отправляется клиенту.

Преимущества

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

Доступные эндпоинты

Базовый адрес для OpenAI-совместимого API:

https://openai.api.delirium.ru/v1

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

Адресация моделей

Имя модели имеет вид <провайдер>/<название‑модели>. В случае с OpenRouter необходимо указывать openrouter/<провайдер>/<название‑модели>

Список поддерживаемых моделей можно посмотреть в разделах Модели для каждого провайдера в данной документации.

Пример использования

curl "https://openai.api.delirium.ru/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "anthropic/claude-sonnet-4-20250514",
        "messages": [
            {
                "role": "user",
                "content": "Привет!"
            }
        ]
    }'

import openai

client = openai.OpenAI(
    base_url="https://openai.api.delirium.ru/v1",
    api_key="<КЛЮЧ>"
)

response = client.chat.completions.create(
    model="anthropic/claude-sonnet-4-20250514",
    messages=[{"role": "user", "content": "Привет!"}]
)

print(response.choices[0].message.content)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://openai.api.delirium.ru/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.chat.completions.create({
  model: 'anthropic/claude-sonnet-4-20250514',
  messages: [{ role: 'user', content: 'Привет!' }]
});

console.log(response.choices[0].message.content);

Модели OpenAI

Мы обеспечиваем поддержку всех актуальных моделей OpenAI и оперативно интегрируем новые. OpenAI является одним из лидеров в области искусственного интеллекта, предлагая передовые модели, такие как GPT, DALL-E и Whisper.

При обращении к моделям можно не указывать точную версию (snapshot), достаточно указать имя всей серии. Запрос автоматически будет направлен на самую актуальную и надежную версию. Например, при обращении к модели gpt-4o запрос автоматически будет направлен к модели gpt-4o-2024-08-06 — самой актуальной на время написания этой статьи. Версии моделей, которые на данный момент являются алиасом по умолчанию для всей серии выделены жирным в списке ниже.

Языковые модели

Рассуждающие модели

Open-source модели

Модели gpt-oss-20b и gpt-oss-120b доступны через OpenRouter.

Модели управления компьютером

Устаревшие языковые модели

Генерация изображений

Генерация видео

Распознавание речи

Синтез речи (TTS)

Embeddings

* RPM — requests per minute (запросов в минуту) / TPM — tokens per minute (токенов в минуту)

Кэширование промптов (OpenAI)

Модели OpenAI (GPT-4o и новее) поддерживают автоматическое кэширование промптов. Никаких изменений в коде не нужно — кэширование работает прозрачно для всех запросов.

Как работает

1. API автоматически кэширует запросы длиной от 1 024 токенов
2. При повторном запросе с таким же началом (префиксом) кэшированная часть обрабатывается со скидкой
3. Совпадение должно быть точным — любое отличие в префиксе сбрасывает кэш
4. Кэшируется всё содержимое запроса: сообщения, изображения, описание инструментов, схемы structured output

Стоимость

• Запись в кэш: бесплатно — никаких дополнительных расходов
• Чтение из кэша: от 50% до 90% дешевле обычных входных токенов (зависит от модели: GPT-5 — 90%, GPT-4.1 — 75%, GPT-4o — 50%)

Время жизни кэша

Кэш по умолчанию хранится в памяти 5–10 минут с момента последнего использования. Для моделей GPT-5 и новее доступен расширенный режим — до 24 часов:

{
  "model": "gpt-5.1",
  "input": "...",
  "prompt_cache_retention": "24h"
}

Как увеличить частоту попаданий

• Располагайте статичное содержимое (системный промпт, инструкции, tools) в начале запроса
• Динамическую часть (вопрос пользователя) — в конце
• Порядок инструментов и изображений должен быть одинаковым между запросами
• Для запросов с общим длинным префиксом используйте параметр prompt_cache_key — он улучшает маршрутизацию и повышает вероятность попадания в кэш

Как отслеживать

Информация о кэшировании возвращается в поле usage ответа:

{
  "usage": {
    "prompt_tokens": 2006,
    "completion_tokens": 300,
    "prompt_tokens_details": {
      "cached_tokens": 1920
    }
  }
}

Значение cached_tokens показывает, сколько токенов было обработано из кэша. Если оно равно 0 — запрос был обработан полностью с нуля.

Поддерживаемые модели

Кэширование доступно для GPT-4o и всех более новых моделей, включая серии o1, o3, o4, GPT-5.

Пример

curl "https://api.delirium.ru/openai/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o",
        "messages": [
            {
                "role": "system",
                "content": "Длинный системный промпт (более 1024 токенов)..."
            },
            {
                "role": "user",
                "content": "Вопрос пользователя"
            }
        ]
    }'

import openai

client = openai.OpenAI(
    base_url="https://api.delirium.ru/openai/v1",
    api_key="<КЛЮЧ>"
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[
        {"role": "system", "content": "Длинный системный промпт (более 1024 токенов)..."},
        {"role": "user", "content": "Вопрос пользователя"}
    ]
)

print(response.usage)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.chat.completions.create({
  model: 'gpt-4o',
  messages: [
    { role: 'system', content: 'Длинный системный промпт (более 1024 токенов)...' },
    { role: 'user', content: 'Вопрос пользователя' }
  ]
});

console.log(response.usage);

Отправьте два одинаковых запроса с интервалом в несколько секунд. Во втором ответе cached_tokens будет больше нуля — это означает, что кэш сработал и вы платите за эти токены вдвое меньше.

Поддержка API от OpenAI

Responses API

11 марта 2025 года компания OpenAI представила Responses API — новый инструмент для разработчиков, объединяющий простоту Chat Completions API с возможностями Assistants API. Он включает встроенные функции, такие как веб-поиск для получения актуальной информации из интернета, работа с файлами и инструмент Computer Use, позволяющий агентам выполнять задачи на компьютере, имитируя действия пользователя. OpenAI планирует заменить Assistants API и Chat Completions API на Responses API к середине 2026 года, учитывая отзывы разработчиков и стремясь улучшить функциональность.

Delirium API, в свою очередь, начинает внедрять поддержку Responses API поэтапно. На данный момент поддерживаются все виды запросов и инструментов, кроме работы с файлами и векторными хранилищами. Как и в случае с Assistants API, этот функционал со временем станет доступен в подписке Delirium API Pro.

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

Chat Completions API

Все методы и инструменты поддерживаются без ограничений.

Audio API

Все методы и инструменты поддерживаются без ограничений.

Video API

Методы и инструменты поддерживаются с ограничениями.

Embeddings API

Все методы и инструменты поддерживаются без ограничений.

Images API

Все методы и инструменты поддерживаются без ограничений.

Assistants API

Доступ к Assistants API, инструментам по работе с файлами, векторным хранилищем и code interpreter находится в разработке. По всем вопросам напишите нам на странице контактов.

Генерация текста

Все методы и форматы запросов и ответов в Delirium API идентичны оригинальным от OpenAI. Таким образом, официальные SDK полностью совместимы с Delirium API.

Для запросов к OpenAI в качестве пути к API необходимо использовать:

https://api.delirium.ru/openai/v1

Пример

Пример простого запроса генерации текста.

Responses API

curl "https://api.delirium.ru/openai/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o",
        "input": "Привет!"
    }'

import openai

client = openai.OpenAI(
    base_url="https://api.delirium.ru/openai/v1",
    api_key="<КЛЮЧ>"
)

response = client.responses.create(
    model="gpt-4o",
    input="Привет!"
)

print(response.output_text)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.responses.create({
  model: 'gpt-4o',
  input: 'Привет!'
});

console.log(response.output_text);

Chat Completions API

curl "https://api.delirium.ru/openai/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o",
        "messages": [
            {
                "role": "user",
                "content": "Привет!"
            }
        ]
    }'

import openai

client = openai.OpenAI(
    base_url="https://api.delirium.ru/openai/v1",
    api_key="<КЛЮЧ>"
)

response = client.chat.completions.create(
    model="gpt-4o",
    messages=[{"role": "user", "content": "Привет!"}]
)

print(response.choices[0].message.content)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.chat.completions.create({
  model: 'gpt-4o',
  messages: [{ role: 'user', content: 'Привет!' }]
});

console.log(response.choices[0].message.content);

Компьютерное зрение или запрос по изображению в OpenAI API

Базовая информация о том, как в API работает компьютерное зрение, доступна в разделе Компьютерное зрение.

Пример со ссылкой на изображение

Responses API

curl "https://api.delirium.ru/openai/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o-mini",
        "input": [
            {
                "role": "user",
                "content": [
                    {"type": "input_text", "text": "Что изображено на картинке?"},
                    {
                        "type": "input_image",
                        "image_url": "https://domain.com/your_image.jpg"
                    }
                ]
            }
        ]
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.responses.create(
    model="gpt-4o-mini",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Что изображено на картинке?"},
                {
                    "type": "input_image",
                    "image_url": "https://domain.com/your_image.jpg"
                }
            ]
        }
    ]
)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.responses.create({
  model: 'gpt-4o-mini',
  input: [
    {
      role: 'user',
      content: [
        { type: 'input_text', text: 'Что изображено на картинке?' },
        { type: 'input_image', image_url: 'https://domain.com/your_image.jpg' }
      ]
    }
  ]
});

Chat Completions API

curl "https://api.delirium.ru/openai/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o-mini",
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Что изображено на картинке?"},
                    {
                        "type": "image_url",
                        "image_url": "https://domain.com/your_image.jpg"
                    }
                ]
            }
        ]
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Что изображено на картинке?"},
                {
                    "type": "image_url",
                    "image_url": "https://domain.com/your_image.jpg"
                }
            ]
        }
    ]
)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Что изображено на картинке?' },
        { type: 'image_url', image_url: 'https://domain.com/your_image.jpg' }
      ]
    }
  ]
});

Пример c base64 изображением

Responses API

import base64
from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

base64_image = encode_image("path_to_your_image.jpg")

response = client.responses.create(
    model="gpt-4o-mini",
    input=[{
        "role": "user",
        "content": [
            {"type": "input_text", "text": "Что изображено на картинке?"},
            {
                "type": "input_image",
                "image_url": f"data:image/jpeg;base64,{base64_image}"
            }
        ]
    }]
)

import fs from 'fs';
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

function encodeImage(imagePath) {
  return fs.readFileSync(imagePath).toString('base64');
}

const base64Image = encodeImage('path_to_your_image.jpg');

const response = await client.responses.create({
  model: 'gpt-4o-mini',
  input: [{
    role: 'user',
    content: [
      { type: 'input_text', text: 'Что изображено на картинке?' },
      {
        type: 'input_image',
        image_url: `data:image/jpeg;base64,${base64Image}`
      }
    ]
  }]
});

Chat Completions API

import base64
from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

base64_image = encode_image("path_to_your_image.jpg")

response = client.chat.completions.create(
    model="gpt-4o-mini",
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "What is in this image?"},
            {
                "type": "image_url",
                "image_url": f"data:image/jpeg;base64,{base64_image}"
            }
        ]
    }]
)

import fs from 'fs';
import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

function encodeImage(imagePath) {
  return fs.readFileSync(imagePath).toString('base64');
}

const base64Image = encodeImage('path_to_your_image.jpg');

const response = await client.chat.completions.create({
  model: 'gpt-4o-mini',
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'What is in this image?' },
      { type: 'image_url', image_url: `data:image/jpeg;base64,${base64Image}` }
    ]
  }]
});

Требования к входным изображениям

Входные изображения должны соответствовать следующим требованиям для использования в API:

Поддерживаемые типы файлов:

• PNG (.png)
• JPEG (.jpeg, .jpg)
• WEBP (.webp)
• Неанимированный GIF (.gif)

Ограничения по размеру:

• До 20MB на изображение
• Низкое разрешение: 512x512 пикселей
• Высокое разрешение: короткая сторона — 768 пикселей, длинная сторона — до 2000 пикселей

Другие требования:

• Без водяных знаков или логотипов
• Без текста
• Без NSFW-контента
• Изображения должны быть достаточно чёткими, чтобы человек мог их понять

Уровень детализации входного изображения

Параметр detail сообщает модели, какой уровень детализации использовать при обработке и распознавании изображения (низкий, высокий или auto, чтобы модель сама выбрала). Если параметр не указан, модель использует auto. Укажите его сразу после image_url, вот так:

{
    "type": "input_image",
    "image_url": "https://domain.com/your_image.jpg",
    "detail": "high",
}

Вы можете сэкономить токены и ускорить ответы, используя detail: "low". Это позволяет модели обрабатывать изображение с бюджетом в 85 токенов. Модель получает изображение с низким разрешением 512px x 512px. Это подходит, если для вашего случая не требуется видеть изображение с высоким разрешением (например, если вы спрашиваете о форме или цвете на изображении).

Или предоставить модели больше деталей, чтобы она могла глубже понять изображение, используя detail: "high". Это позволяет модели увидеть изображение с низким разрешением (с использованием 85 токенов), а затем создать подробные фрагменты, используя 170 токенов для каждого блока 512px x 512px.

Обработка нескольких изображений

Responses API может принимать и обрабатывать несколько входных изображений. Модель обрабатывает каждое изображение и использует информацию со всех изображений для ответа на вопрос.

curl "https://api.delirium.ru/openai/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o-mini",
        "input": [
            {
                "role": "user",
                "content": [
                    {"type": "input_text", "text": "Есть ли отличия между изображениями?"},
                    {
                        "type": "input_image",
                        "image_url": "https://domain.com/image1.jpg"
                    },
                    {
                        "type": "input_image",
                        "image_url": "https://domain.com/image2.jpg"
                    }
                ]
            }
        ]
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.responses.create(
    model="gpt-4o-mini",
    input=[
        {
            "role": "user",
            "content": [
                {"type": "input_text", "text": "Есть ли отличия между изображениями?"},
                {
                    "type": "input_image",
                    "image_url": "https://domain.com/image1.jpg"
                },
                {
                    "type": "input_image",
                    "image_url": "https://domain.com/image2.jpg"
                }
            ]
        }
    ]
)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.responses.create({
  model: 'gpt-4o-mini',
  input: [
    {
      role: 'user',
      content: [
        { type: 'input_text', text: 'Есть ли отличия между изображениями?' },
        { type: 'input_image', image_url: 'https://domain.com/image1.jpg' },
        { type: 'input_image', image_url: 'https://domain.com/image2.jpg' }
      ]
    }
  ]
});

Генерация изображений

OpenAI предлагает семейство моделей GPT Image для генерации и редактирования изображений:

• gpt-image-1 — базовая модель с хорошим качеством и умеренной стоимостью.
• gpt-image-1-mini — компактный вариант для быстрых черновиков и экспериментов.
• gpt-image-1.5 — улучшенное качество при схожей скорости.
• gpt-image-2 — самая новая модель, поддерживает практически любое разрешение и наиболее точное следование промпту.

Все модели работают через один и тот же эндпоинт и возвращают изображения в формате base64 (b64_json).

Биллинг по токенам

В отличие от старых моделей DALL·E, которые оплачивались за картинку, семейство GPT Image тарифицируется по токенам. Итоговая стоимость одного запроса складывается из трёх составляющих:

• Ввод (текст): токены текстового промпта.
• Изображение (ввод): токены входящих изображений в запросах редактирования. В модели gpt-image-2 входящие изображения всегда обрабатываются в режиме высокой точности, поэтому расход выше, чем в более ранних моделях.
• Вывод: токены, в которые модель кодирует итоговое изображение. Растут с качеством (quality) и разрешением.

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

Генерация изображений

Минимальный запрос к модели генерации:

curl -X POST "https://api.delirium.ru/openai/v1/images/generations" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -H "Content-type: application/json" \
    -d '{
        "model": "gpt-image-2",
        "prompt": "Стеклянная бутылка, внутри которой плывет корабль посреди шторма"
    }' | jq -r '.data[0].b64_json' | base64 --decode > image.png

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.images.generate(
    model="gpt-image-2",
    prompt="Стеклянная бутылка, внутри которой плывет корабль"
)

with open("image.png", "wb") as f:
    f.write(base64.b64decode(response.data[0].b64_json))

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.images.generate({
  model: 'gpt-image-2',
  prompt: 'Стеклянная бутылка, внутри которой плывет корабль'
});

const buffer = Buffer.from(response.data[0].b64_json, 'base64');
fs.writeFileSync('image.png', buffer);

Параметр n позволяет получить несколько изображений за один запрос. Для всех моделей семейства GPT Image ответ содержит массив data с полем b64_json у каждого элемента, а также объект usage с подробной разбивкой по токенам.

Редактирование изображений

Эндпоинт редактирования позволяет:

• изменять существующее изображение по текстовому промпту,
• генерировать новое изображение, используя одно или несколько референсов,
• заменять отдельные области изображения с помощью маски (инпейтинг).

Редактирование поддерживается всеми моделями семейства GPT Image.

Новое изображение по референсам

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

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

curl -s -D >(grep -i x-request-id >&2) \
  -o >(jq -r '.data[0].b64_json' | base64 --decode > gift-basket.png) \
  -X POST "https://api.delirium.ru/openai/v1/images/edits" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  -F "model=gpt-image-2" \
  -F "image[]=@body-lotion.png" \
  -F "image[]=@bath-bomb.png" \
  -F "image[]=@incense-kit.png" \
  -F "image[]=@soap.png" \
  -F 'prompt=Создай фотореалистичное изображение подарочной корзины на белом фоне, подписанной "Отдых и восстановление" с лентой и рукописным шрифтом, содержащей все предметы из референсных изображений'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.images.edit(
    model="gpt-image-2",
    image=["body-lotion.png", "bath-bomb.png", "incense-kit.png", "soap.png"],
    prompt="Создай фотореалистичное изображение подарочной корзины на белом фоне, подписанной \"Отдых и восстановление\" с лентой и рукописным шрифтом, содержащей все предметы из референсных изображений"
)

with open("gift-basket.png", "wb") as f:
    f.write(base64.b64decode(response.data[0].b64_json))

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.images.edit({
  model: 'gpt-image-2',
  image: [fs.createReadStream('body-lotion.png'), fs.createReadStream('bath-bomb.png'), fs.createReadStream('incense-kit.png'), fs.createReadStream('soap.png')],
  prompt: 'Создай фотореалистичное изображение подарочной корзины на белом фоне, подписанной "Отдых и восстановление" с лентой и рукописным шрифтом, содержащей все предметы из референсных изображений'
});

const buffer = Buffer.from(response.data[0].b64_json, 'base64');
fs.writeFileSync('gift-basket.png', buffer);

Инпейтинг с маской

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

curl -s -D >(grep -i x-request-id >&2) \
  -o >(jq -r '.data[0].b64_json' | base64 --decode > clouds.png) \
  -X POST "https://api.delirium.ru/openai/v1/images/edits" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  -F "model=gpt-image-2" \
  -F "mask=@mask.png" \
  -F "image[]=@clouds.png" \
  -F 'prompt=Небо в облаках, одно из которых напоминает слона'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.images.edit(
    model="gpt-image-2",
    image=["clouds.png"],
    mask="mask.png",
    prompt="Небо в облаках, одно из которых напоминает слона"
)

with open("clouds.png", "wb") as f:
    f.write(base64.b64decode(response.data[0].b64_json))

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.images.edit({
  model: 'gpt-image-2',
  image: fs.createReadStream('clouds.png'),
  mask: fs.createReadStream('mask.png'),
  prompt: 'Небо в облаках, одно из которых напоминает слона'
});

const buffer = Buffer.from(response.data[0].b64_json, 'base64');
fs.writeFileSync('clouds.png', buffer);

Требования к маске

• Исходное изображение и маска должны быть в одном формате и одного размера (до 50 МБ).
• Маска должна содержать альфа-канал. Если графический редактор его не создаёт, альфа-канал можно добавить программно — например, скопировав монохромное изображение маски в alpha-канал RGBA-версии.

Сохранение деталей на референсах (input_fidelity)

Параметр input_fidelity управляет тем, насколько точно модель сохраняет детали входящих изображений при редактировании. Поддерживается моделями gpt-image-1, gpt-image-1-mini и gpt-image-1.5.

Модель gpt-image-2 всегда обрабатывает входящие изображения в режиме высокой точности, поэтому параметр input_fidelity для неё не принимается. Это одна из причин, по которой запросы к gpt-image-2 с референсами могут расходовать больше токенов на ввод изображения, чем в предыдущих моделях.

Настройка параметров вывода

При генерации поддерживаются следующие параметры:

• size — размер итогового изображения.
• quality — качество рендеринга (low, medium, high, auto).
• output_format — формат файла (png, jpeg, webp).
• output_compression — уровень сжатия (0–100%) для jpeg и webp.
• background — фон: opaque, transparent или auto.
• moderation — строгость модерации (auto, low).

Параметры size, quality и background поддерживают значение auto, при котором модель подбирает оптимальное значение сама.

Размер

Модели gpt-image-1, gpt-image-1-mini и gpt-image-1.5 принимают фиксированный набор значений:

• 1024x1024 — квадрат (по умолчанию)
• 1536x1024 — альбомная
• 1024x1536 — портретная
• auto

Модель gpt-image-2 принимает практически любое разрешение, удовлетворяющее ограничениям:

• длинная сторона не более 3840 px;
• обе стороны кратны 16 px;
• соотношение сторон не больше 3:1;
• общее количество пикселей от 655 360 до 8 294 400.

Квадратные изображения обычно рендерятся быстрее. Разрешения выше 2560×1440 (≈3,7 МП) считаются экспериментальными — время рендеринга и точность могут варьироваться.

Качество

• low — быстрые черновики и иконки.
• medium — компромисс между скоростью и качеством.
• high — финальные ассеты.
• auto — выбор оптимального уровня моделью.

Формат и сжатие

• По умолчанию возвращается PNG с поддержкой прозрачности.
• jpeg заметно быстрее PNG — стоит выбирать его, если критична задержка.
• Для jpeg и webp можно указать output_compression (например, output_compression=50 — сжатие 50%).

Прозрачность

• Работает только с форматами png и webp.
• Включается параметром background="transparent".
• Не поддерживается моделью gpt-image-2 — запросы с background="transparent" к ней отклоняются.

Модерация

Параметр moderation управляет строгостью фильтрации контента:

• auto (по умолчанию) — стандартная фильтрация.
• low — менее строгая.

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

Ограничения

Семейство GPT Image — мощный и универсальный инструмент, но у него есть известные ограничения:

• Задержка. Сложные запросы могут обрабатываться до 2 минут.
• Отображение текста. Качество рендеринга текста значительно улучшилось по сравнению с DALL·E, но модель всё ещё допускает неточности в расположении и чёткости букв.
• Постоянство. Модель хорошо сохраняет визуальную целостность внутри одной генерации, но может терять консистентность повторяющихся персонажей или элементов бренда между несколькими запросами.
• Контроль композиции. В структурированных макетах модель может ошибаться в точном расположении элементов.

Генерация видео с помощью Sora

Создавайте, редактируйте и управляйте видео с помощью Sora API.

Обзор

Sora — это новейшая разработка OpenAI в области генеративных медиа: современная модель для создания видео, способная генерировать детализированные динамические ролики со звуком на основе текстового описания или изображений. Построенная на многолетних исследованиях мультимодальной диффузии и обученная на разнообразных визуальных данных, Sora обладает глубоким пониманием 3D-пространства, движения и непрерывности сцен.

Video API предоставляет пять эндпоинтов, каждый из которых имеет свои возможности:

• Создание видео: запуск нового задания рендеринга из промпта с опциональными референсными изображениями или ID ремикса.
• Получение статуса видео: проверка текущего состояния задания и мониторинг его прогресса.
• Скачивание видео: получение готового MP4-файла после завершения задания.
• Список видео (не поддерживается): просмотр ваших видео с пагинацией для истории или управления.
• Удаление видео: удаление отдельного видео по ID из хранилища OpenAI.

Модели

Вторая генерация модели Sora представлена в двух вариантах, каждый из которых оптимизирован для разных задач.

Sora 2

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

Sora 2 Pro

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

Генерация видео

Генерация видео — это асинхронный процесс:

1. При вызове эндпоинта POST /videos API возвращает объект задания с id и начальным status.
2. Вы можете опрашивать эндпоинт GET /videos/{video_id} до тех пор, пока статус не изменится на completed.
3. Когда задание достигнет состояния completed, вы можете скачать финальный MP4-файл через GET /videos/{video_id}/content.

Запуск задания рендеринга

Начните с вызова POST /videos с текстовым промптом и необходимыми параметрами.

curl -X POST "https://api.delirium.ru/openai/v1/videos" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  -H "Content-Type: multipart/form-data" \
  -F prompt="Видео с надписью 'Спасибо' сверкающими буквами" \
  -F model="sora-2-pro" \
  -F size="1280x720" \
  -F seconds="8"

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.videos.create(
    model="sora-2-pro",
    prompt="Видео с надписью 'Спасибо' сверкающими буквами",
    size="1280x720",
    seconds=8
)

video_id = response.id

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const video = await client.videos.create({
  model: 'sora-2-pro',
  prompt: "Видео с надписью 'Спасибо' сверкающими буквами",
  size: '1280x720',
  seconds: 8
});

console.log(video.id);

Ответ представляет собой JSON-объект с уникальным id и начальным статусом, таким как queued или in_progress. Это означает, что задание рендеринга запущено.

{
  "id": "video_68d7512d07848190b3e45da0ecbebcde004da08e1e0678d5",
  "object": "video",
  "created_at": 1758941485,
  "status": "queued",
  "model": "sora-2-pro",
  "progress": 0,
  "seconds": "8",
  "size": "1280x720"
}

Ограничения и правила

API применяет несколько ограничений по контенту:

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

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

Эффективные промпты

Для лучших результатов описывайте тип кадра, объект, действие, обстановку и освещение. Например:

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

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

Мониторинг прогресса

Генерация видео занимает время. В зависимости от модели, нагрузки на API и разрешения, один рендер может занять несколько минут. Для эффективного управления вы можете опрашивать API для получения обновлений статуса.

Опрос эндпоинта статуса

Вызовите GET /videos/{video_id} с ID, полученным из запроса создания. Опрашивайте с разумным интервалом (например, каждые 10–20 секунд), используйте экспоненциальную задержку при необходимости.

curl "https://api.delirium.ru/openai/v1/videos/video_abc123" \
  -H "Authorization: Bearer <КЛЮЧ>"

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.videos.retrieve("video_abc123")
print(response.status)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const video = await client.videos.retrieve('video_abc123');
console.log(video.status);

Пример ответа:

{
  "id": "video_68d7512d07848190b3e45da0ecbebcde004da08e1e0678d5",
  "object": "video",
  "created_at": 1758941485,
  "status": "in_progress",
  "model": "sora-2-pro",
  "progress": 33,
  "seconds": "8",
  "size": "1280x720"
}

Получение результатов

Скачивание MP4

Когда задание достигнет статуса completed, получите MP4-файл через GET /videos/{video_id}/content. Этот эндпоинт передаёт бинарные данные видео и возвращает стандартные заголовки контента.

curl -L "https://api.delirium.ru/openai/v1/videos/video_abc123/content" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  --output video.mp4

import requests

url = "https://api.delirium.ru/openai/v1/videos/video_abc123/content"
headers = {"Authorization": "Bearer <КЛЮЧ>"}

response = requests.get(url, headers=headers, stream=True)
with open("video.mp4", "wb") as f:
    for chunk in response.iter_content(chunk_size=8192):
        f.write(chunk)

import fs from 'fs';
import https from 'https';

const file = fs.createWriteStream('video.mp4');
https.get('https://api.delirium.ru/openai/v1/videos/video_abc123/content', {
  headers: { 'Authorization': 'Bearer <КЛЮЧ>' }
}, (res) => {
  res.pipe(file);
});

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

Скачивание дополнительных ресурсов

Для каждого завершённого видео вы также можете скачать превью (thumbnail) и спрайтшит (spritesheet). Используйте параметр запроса variant, чтобы указать, что вы хотите скачать. По умолчанию используется variant=video для MP4.

curl -L "https://api.delirium.ru/openai/v1/videos/video_abc123/content?variant=thumbnail" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  --output thumbnail.webp

curl -L "https://api.delirium.ru/openai/v1/videos/video_abc123/content?variant=spritesheet" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  --output spritesheet.jpg

Использование референсных изображений

Вы можете направлять генерацию с помощью входного изображения, которое выступает в роли первого кадра вашего видео. Это полезно, если вам нужно, чтобы выходное видео сохраняло вид брендового актива, персонажа или конкретной среды. Включите файл изображения как параметр input_reference в ваш запрос POST /videos. Изображение должно соответствовать разрешению целевого видео (size).

Поддерживаемые форматы файлов: image/jpeg, image/png и image/webp.

curl -X POST "https://api.delirium.ru/openai/v1/videos" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  -H "Content-Type: multipart/form-data" \
  -F prompt="Она оборачивается и улыбается, затем медленно выходит из кадра." \
  -F model="sora-2-pro" \
  -F size="1280x720" \
  -F seconds="8" \
  -F input_reference="@sample_720p.jpeg;type=image/jpeg"

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

with open("sample_720p.jpeg", "rb") as img:
    response = client.videos.create(
        model="sora-2-pro",
        prompt="Она оборачивается и улыбается, затем медленно выходит из кадра.",
        size="1280x720",
        seconds=8,
        input_reference=img
    )

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const video = await client.videos.create({
  model: 'sora-2-pro',
  prompt: "Она оборачивается и улыбается, затем медленно выходит из кадра.",
  size: '1280x720',
  seconds: 8,
  input_reference: fs.createReadStream('sample_720p.jpeg')
});

Ремикс завершённых видео

Ремикс позволяет взять существующее видео и внести целенаправленные изменения без регенерации всего с нуля. Укажите remix_video_id завершённого задания вместе с новым промптом, описывающим изменение, и система переиспользует структуру, непрерывность и композицию оригинала, применяя модификацию.

curl -X POST "https://api.delirium.ru/openai/v1/videos/<previous_video_id>/remix" \
  -H "Authorization: Bearer <КЛЮЧ>" \
  -H "Content-Type: application/json" \
  -d '{
    "prompt": "Измени цветовую палитру на бирюзовый, песочный и ржавый, с тёплой подсветкой."
  }'

Ремикс особенно ценен для итерации, потому что он позволяет дорабатывать, не отбрасывая то, что уже работает. Ограничивая каждый ремикс одной чёткой корректировкой, вы сохраняете визуальный стиль, согласованность объекта и кадрирование камеры стабильными.

Управление библиотекой

Используйте DELETE /videos/{video_id} для удаления видео, которые вам больше не нужны, из хранилища OpenAI.

curl -X DELETE "https://api.delirium.ru/openai/v1/videos/video_abc123" \
  -H "Authorization: Bearer <КЛЮЧ>"

Распознавание речи

Audio API предоставляет две конечные точки для преобразования аудио в текст:

• transcriptions — транскрибирует аудио на том же языке.
• translations — переводит и транскрибирует аудио на английский язык.

Модели

• gpt-4o-transcribe — высококачественная модель для транскрибации.
• gpt-4o-mini-transcribe — оптимизированная версия с хорошим балансом скорости и качества.
• whisper-1 — классическая модель с полной поддержкой функций.

Новые модели GPT-4o поддерживают ограниченный набор параметров и только форматы json или text.

Поддерживаемые форматы файлов

Поддерживаются следующие форматы: mp3, mp4, mpeg, mpga, m4a, wav, webm.

Максимальный размер файла: 25 МБ.

Примеры

Базовая транскрибация

curl --request POST \
  --url "https://api.delirium.ru/openai/v1/audio/transcriptions" \
  --header "Authorization: Bearer <КЛЮЧ>" \
  --header "Content-Type: multipart/form-data" \
  --form file=@/path/to/file/audio.mp3 \
  --form model=gpt-4o-transcribe

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

with open("/path/to/file/audio.mp3", "rb") as f:
    transcription = client.audio.transcriptions.create(
        model="gpt-4o-transcribe",
        file=f
    )

print(transcription.text)

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const transcription = await client.audio.transcriptions.create({
  model: 'gpt-4o-transcribe',
  file: fs.createReadStream('/path/to/file/audio.mp3')
});

console.log(transcription.text);

Транскрибация с промптом

curl --request POST \
  --url "https://api.delirium.ru/openai/v1/audio/transcriptions" \
  --header "Authorization: Bearer <КЛЮЧ>" \
  --header "Content-Type: multipart/form-data" \
  --form file=@/path/to/file/speech.mp3 \
  --form model=gpt-4o-transcribe \
  --form prompt="Следующий разговор — лекция о последних разработках OpenAI, GPT-4.5 и будущем ИИ."

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

with open("/path/to/file/speech.mp3", "rb") as f:
    transcription = client.audio.transcriptions.create(
        model="gpt-4o-transcribe",
        file=f,
        prompt="Следующий разговор — лекция о последних разработках OpenAI, GPT-4.5 и будущем ИИ."
    )

print(transcription.text)

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const transcription = await client.audio.transcriptions.create({
  model: 'gpt-4o-transcribe',
  file: fs.createReadStream('/path/to/file/speech.mp3'),
  prompt: 'Следующий разговор — лекция о последних разработках OpenAI, GPT-4.5 и будущем ИИ.'
});

console.log(transcription.text);

Перевод на английский

curl --request POST \
  --url "https://api.delirium.ru/openai/v1/audio/translations" \
  --header "Authorization: Bearer <КЛЮЧ>" \
  --header "Content-Type: multipart/form-data" \
  --form file=@/path/to/file/russian.mp3 \
  --form model=whisper-1

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

with open("/path/to/file/russian.mp3", "rb") as f:
    translation = client.audio.translations.create(
        model="whisper-1",
        file=f
    )

print(translation.text)

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const translation = await client.audio.translations.create({
  model: 'whisper-1',
  file: fs.createReadStream('/path/to/file/russian.mp3')
});

console.log(translation.text);

Потоковая транскрибация

curl --request POST \
  --url "https://api.delirium.ru/openai/v1/audio/transcriptions" \
  --header "Authorization: Bearer <КЛЮЧ>" \
  --header "Content-Type: multipart/form-data" \
  --form file=@example.wav \
  --form model=gpt-4o-mini-transcribe \
  --form stream=True

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

with open("example.wav", "rb") as f:
    transcription = client.audio.transcriptions.create(
        model="gpt-4o-mini-transcribe",
        file=f,
        stream=True
    )

for chunk in transcription:
    print(chunk.text)

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const transcription = await client.audio.transcriptions.create({
  model: 'gpt-4o-mini-transcribe',
  file: fs.createReadStream('example.wav'),
  stream: true
});

for await (const chunk of transcription) {
  console.log(chunk.text);
}

Форматы ответов

Для whisper-1: json, text, srt, verbose_json, vtt.

Для gpt-4o моделей: только json и text.

Временные метки

Для получения временных меток используйте модель whisper-1 с параметром timestamp_granularities:

transcription = client.audio.transcriptions.create(
    file=audio_file,
    model="whisper-1",
    response_format="verbose_json",
    timestamp_granularities=["word", "segment"]
)

Поддерживаемые языки

API поддерживает тот же набор языков, что и модель Whisper, включая русский, английский, французский, немецкий, китайский, японский и многие другие (африкаанс, арабский, армянский, азербайджанский, белорусский, боснийский, болгарский, каталанский, хорватский, чешский, датский, нидерландский, эстонский, финский, галисийский, греческий, иврит, хинди, венгерский, исландский, индонезийский, итальянский, каннада, казахский, корейский, латышский, литовский, македонский, малайский, маратхи, маори, непальский, норвежский, персидский, польский, португальский, румынский, сербский, словацкий, словенский, испанский, суахили, шведский, тагальский, тамильский, тайский, турецкий, украинский, урду, вьетнамский, валлийский).

Улучшение надежности

Использование промптов

Для улучшения распознавания специальных терминов и аббревиатур используйте параметр prompt:

transcription = client.audio.transcriptions.create(
    model="whisper-1",
    file=audio_file,
    prompt="OpenAI, ChatGPT, GPT-4, API, машинное обучение, нейронные сети"
)

Постобработка с GPT-4

Для дополнительной обработки транскрипции используйте GPT-4 для исправления ошибок и улучшения форматирования.

Работа с длинными файлами

Для файлов больше 25 МБ разбивайте их на части:

from pydub import AudioSegment

song = AudioSegment.from_mp3("long_audio.mp3")
ten_minutes = 10 * 60 * 1000

first_10_minutes = song[:ten_minutes]
first_10_minutes.export("audio_part1.mp3", format="mp3")

Ограничения

• Максимальный размер файла: 25 МБ.
• Перевод поддерживается только на английский язык.
• Временные метки доступны только для модели whisper-1.
• Потоковая транскрибация не поддерживается в whisper-1.

Синтез речи OpenAI API

Audio API предоставляет конечную точку speech на основе модели GPT-4o mini TTS для преобразования текста в естественную речь. API поддерживает 11 встроенных голосов и может использоваться для:

• Озвучивания статей и блогов
• Создания многоязычного аудиоконтента
• Потоковой передачи аудио в реальном времени

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

Модели

• gpt-4o-mini-tts — новейшая модель с возможностью управления речевыми характеристиками через инструкции
• tts-1 — обеспечивает низкую задержку, но с меньшим качеством
• tts-1-hd — повышенное качество звука, но с большей задержкой

Голоса

Доступно 11 голосов: alloy, ash, ballad, coral, echo, fable, nova, onyx, sage, shimmer. Голоса оптимизированы для английского языка.

Примеры

Базовый синтез речи

curl "https://api.delirium.ru/openai/v1/audio/speech" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -H "Content-Type: application/json" \
    -d '{
        "model": "gpt-4o-mini-tts",
        "input": "Привет! Сегодня замечательный день для создания чего-то удивительного.",
        "voice": "coral",
        "instructions": "Говори с радостной и позитивной интонацией."
    }' \
    --output speech.mp3

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.audio.speech.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input="Привет! Сегодня замечательный день для создания чего-то удивительного.",
    instructions="Говори с радостной и позитивной интонацией."
)

response.stream_to_file("speech.mp3")

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.audio.speech.create({
  model: 'gpt-4o-mini-tts',
  voice: 'coral',
  input: 'Привет! Сегодня замечательный день для создания чего-то удивительного.',
  instructions: 'Говори с радостной и позитивной интонацией.'
});

const buffer = Buffer.from(await response.arrayBuffer());
fs.writeFileSync('speech.mp3', buffer);

Потоковое воспроизведение

curl "https://api.delirium.ru/openai/v1/audio/speech" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -H "Content-Type: application/json" \
    -d '{
        "model": "gpt-4o-mini-tts",
        "input": "Это пример потокового синтеза речи в реальном времени.",
        "voice": "coral",
        "response_format": "wav",
        "instructions": "Говори четко и размеренно."
    }' | ffplay -i -

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

with client.audio.speech.with_streaming_response.create(
    model="gpt-4o-mini-tts",
    voice="coral",
    input="Это пример потокового синтеза речи в реальном времени.",
    response_format="wav",
    instructions="Говори четко и размеренно."
) as response:
    response.stream_to_file("speech_stream.wav")

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.audio.speech.create({
  model: 'gpt-4o-mini-tts',
  voice: 'coral',
  input: 'Это пример потокового синтеза речи в реальном времени.',
  response_format: 'wav',
  instructions: 'Говори четко и размеренно.'
});

const buffer = Buffer.from(await response.arrayBuffer());
fs.writeFileSync('speech_stream.wav', buffer);

Поддерживаемые форматы

• mp3 (по умолчанию) — универсальный формат для большинства приложений
• opus — оптимален для интернет-стриминга и коммуникаций с низкой задержкой
• aac — предпочтителен для цифрового сжатия аудио, YouTube, Android, iOS
• flac — сжатие без потерь, популярно среди аудиофилов для архивирования
• wav — несжатый формат, подходит для приложений с низкой задержкой
• pcm — сырые семплы 24 кГц (16-бит signed, little-endian), без заголовка

Для минимального времени отклика рекомендуется использовать форматы wav или pcm.

Поддерживаемые языки

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

Управление характеристиками речи

С моделью gpt-4o-mini-tts можно управлять аспектами речи через параметр instructions:

• Акцент
• Эмоциональная окраска
• Интонация
• Имитация
• Скорость речи
• Тон голоса
• Шепот

Ограничения

• Пользовательские голоса не поддерживаются
• Необходимо уведомлять пользователей о том, что речь сгенерирована ИИ
• Владельцем созданного аудио является тот, кто его создал

Генерация текста OpenAI API с веб-поиском

Web search — это инструмент OpenAI API, который позволяет моделям искусственного интеллекта выполнять поиск в интернете для получения актуальной информации перед генерацией ответа.

Объем поискового контекста

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

Возможные значения:

• low — малый объем контекста
• medium — средний объем контекста (по умолчанию)
• high — большой объем контекста

Местоположение пользователя

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

Параметры:

• type — тип местоположения (всегда approximate)
• country — двухбуквенный ISO-код страны (например, RU для России)
• city — город
• region — регион

Тарификация

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

Responses API

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

Пример:

curl "https://api.delirium.ru/openai/v1/responses" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o",
        "tools": [{
            "type": "web_search",
            "search_context_size": "low",
            "user_location": {
                "type": "approximate",
                "country": "RU",
                "city": "Moscow",
                "region": "Moscow"
            }
        }],
        "input": "Какая сегодня погода?"
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.responses.create(
    model="gpt-4o",
    tools=[{
        "type": "web_search",
        "search_context_size": "low",
        "user_location": {
            "type": "approximate",
            "country": "RU",
            "city": "Moscow",
            "region": "Moscow"
        }
    }],
    input="Какая сегодня погода?"
)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.responses.create({
  model: 'gpt-4o',
  tools: [{
    type: 'web_search',
    search_context_size: 'low',
    user_location: {
      type: 'approximate',
      country: 'RU',
      city: 'Moscow',
      region: 'Moscow'
    }
  }],
  input: 'Какая сегодня погода?'
});

Chat Completions API

В Chat Completions API поиск доступен через обращение к специальным расширениям основных моделей: gpt-4o-search-preview и gpt-4o-mini-search-preview. При запросе к этим моделям, поиск выполняется обязательно, то есть нельзя включать или выключать его для каких-то определенных запросов.

Пример:

curl "https://api.delirium.ru/openai/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "gpt-4o-search-preview",
        "web_search_options": {
            "search_context_size": "low",
            "user_location": {
                "type": "approximate",
                "approximate": {
                    "country": "RU",
                    "city": "Moscow",
                    "region": "Moscow"
                }
            }
        },
        "messages": [
            {
                "role": "user",
                "content": "Сколько людей живет в Москве?"
            }
        ]
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.chat.completions.create(
    model="gpt-4o-search-preview",
    web_search_options={
        "search_context_size": "low",
        "user_location": {
            "type": "approximate",
            "approximate": {
                "country": "RU",
                "city": "Moscow",
                "region": "Moscow"
            }
        }
    },
    messages=[{"role": "user", "content": "Сколько людей живет в Москве?"}]
)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.chat.completions.create({
  model: 'gpt-4o-search-preview',
  web_search_options: {
    search_context_size: 'low',
    user_location: {
      type: 'approximate',
      approximate: {
        country: 'RU',
        city: 'Moscow',
        region: 'Moscow'
      }
    }
  },
  messages: [{ role: 'user', content: 'Какая сегодня погода?' }]
});

Управление компьютером (Computer Use) в OpenAI API

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

В OpenAI API инструмент представлен особенной моделью — computer-use-preview. Она натренирована именно для задач, связанных с управлением компьютером. В ответ на запросы, эта модель отвечает json с описанием действия, которое необходимо произвести.

Например:

{
    "type": "computer_call",
    "action": {
        "type": "click",
        "button": "left",
        "x": 156,
        "y": 50
    }
}

Действие: кликнуть левой кнопкой мыши в точке с координатами (156, 50).

Принцип работы

Для достижения поставленной цели модель использует цикл CUA (Computer Use Action loop), который состоит из нескольких шагов:

1. Анализ скриншота: Модель получает скриншот текущего состояния интерфейса и анализирует его для понимания контекста.
2. Генерация действий: На основе анализа скриншота модель формирует необходимые действия, такие как клики, ввод текста или прокрутка.
3. Выполнение действий: Сгенерированные действия исполняются в реальной среде, изменяя состояние интерфейса.
4. Обновление состояния: После выполнения действий создается новый скриншот обновленного интерфейса, который снова анализируется моделью.

Этот цикл повторяется до достижения поставленной цели или завершения задачи.

Подготовка среды окружения

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

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

Запуск фреймворка локально может представлять угрозу безопасности. Мы рекомендуем следующий набор мер для их минимизации:

• Используйте изолированную среду (sandbox)
• Установите переменную окружения env в пустой объект, чтобы избежать утечки переменных окружения хоста в браузер
• Установите флаги для отключения расширений и файловой системы
• Запустите экземпляр браузера

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

Например, чтобы запустить экземпляр браузера Playwright, установите SDK Playwright:

• Python: pip install playwright
• JavaScript: npm i playwright, затем npx playwright install

После этого выполните следующий код:

from playwright.sync_api import sync_playwright

with sync_playwright() as p:
    browser = p.chromium.launch(
        headless=False,
        chromium_sandbox=True,
        env={},
        args=[
            "--disable-extensions",
            "--disable-file-system"
        ]
    )
    page = browser.new_page()
    page.set_viewport_size({"width": 1024, "height": 768})
    page.goto("https://ya.ru")

    page.wait_for_timeout(10000)

import { chromium } from 'playwright';

const browser = await chromium.launch({
  headless: false,
  chromiumSandbox: true,
  env: {},
  args: [
    '--disable-extensions',
    '--disable-file-system'
  ]
});
const page = await browser.newPage();
await page.setViewportSize({ width: 1024, height: 768 });
await page.goto('https://ya.ru');
await page.waitForTimeout(10000);

Запускаем цикл CUA

1. Отправить запрос модели

Отправьте запрос на генерацию ответа с использованием модели computer-use-preview, оснащённой инструментом computer_use_preview. Этот запрос должен включать сведения о вашей среде, а также исходный запрос.

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

Дополнительно вы можете включить скриншот начального состояния среды.

from openai import OpenAI
client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.responses.create(
    model="computer-use-preview",
    tools=[{
        "type": "computer_use_preview",
        "display_width": 1024,
        "display_height": 768,
        "environment": "browser" # другие значения: "mac", "windows", "ubuntu"
    }],
    input=[
        {
            "role": "user",
            "content": "Прочитай последний заголовок на Хабре"
        }
        # Опционально: включите скриншот начального состояния среды
        # {
        #     type: "input_image",
        #     image_url: f"data:image/png;base64,{screenshot_base64}"
        # }
    ],
    reasoning={
        "generate_summary": "concise",
    },
    truncation="auto"
)

print(response.output)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.responses.create({
  model: 'computer-use-preview',
  tools: [{
    type: 'computer_use_preview',
    display_width: 1024,
    display_height: 768,
    environment: 'browser' // другие значения: 'mac', 'windows', 'ubuntu'
  }],
  input: [
    {
      role: 'user',
      content: 'Прочитай последний заголовок на Хабре'
    }
    // Опционально: включите скриншот начального состояния среды
    // {
    //   type: 'input_image',
    //   image_url: `data:image/png;base64,${screenshotBase64}`
    // }
  ],
  reasoning: {
    generate_summary: 'concise'
  },
  truncation: 'auto'
});

console.log(response.output);

2. Получить предложенное действие

Модель возвращает ответ, который может содержать элемент computer_call, просто текст или вызовы других инструментов, в зависимости от состояния разговора.

Примеры элементов computer_call включают клик, прокрутку, нажатие клавиши и другие события. В примере элемент представляет собой действие клика:

"output": [
    {
        "type": "reasoning",
        "id": "rs_67cc...",
        "summary": [
            {
                "type": "summary_text",
                "text": "Clicking on the browser address bar."
            }
        ]
    },
    {
        "type": "computer_call",
        "id": "cu_67cc...",
        "call_id": "call_zw3...",
        "action": {
            "type": "click",
            "button": "left",
            "x": 156,
            "y": 50
        },
        "pending_safety_checks": [],
        "status": "completed"
    }
]

3. Выполнить действие

Выполните соответствующие действия на вашем компьютере или в браузере. То, как вы сопоставляете вызов computer_call с действиями в коде, зависит от вашей среды. Этот код показывает примеры реализации наиболее распространённых компьютерных действий.

def handle_model_action(page, action):
    """
    Given a computer action (e.g., click, double_click, scroll, etc.),
    execute the corresponding operation on the Playwright page.
    """
    action_type = action.type

    try:
        match action_type:

            case "click":
                x, y = action.x, action.y
                button = action.button
                print(f"Action: click at ({x}, {y}) with button '{button}'")
                # Not handling things like middle click, etc.
                if button != "left" and button != "right":
                    button = "left"
                page.mouse.click(x, y, button=button)

            case "scroll":
                x, y = action.x, action.y
                scroll_x, scroll_y = action.scroll_x, action.scroll_y
                print(f"Action: scroll at ({x}, {y}) with offsets (scroll_x={scroll_x}, scroll_y={scroll_y})")
                page.mouse.move(x, y)
                page.evaluate(f"window.scrollBy({scroll_x}, {scroll_y})")

            case "keypress":
                keys = action.keys
                for k in keys:
                    print(f"Action: keypress '{k}'")
                    # A simple mapping for common keys; expand as needed.
                    if k.lower() == "enter":
                        page.keyboard.press("Enter")
                    elif k.lower() == "space":
                        page.keyboard.press(" ")
                    else:
                        page.keyboard.press(k)

            case "type":
                text = action.text
                print(f"Action: type text: {text}")
                page.keyboard.type(text)

            case "wait":
                print(f"Action: wait")
                time.sleep(2)

            case "screenshot":
                # Nothing to do as screenshot is taken at each turn
                print(f"Action: screenshot")

            # Handle other actions here

            case _:
                print(f"Unrecognized action: {action}")

    except Exception as e:
        print(f"Error handling action {action}: {e}")

async function handleModelAction(page, action) {
  const actionType = action.type;
  try {
    switch (actionType) {
      case 'click': {
        const { x, y, button } = action;
        console.log(`Action: click at (${x}, ${y}) with button '${button}'`);
        const btn = (button !== 'left' && button !== 'right') ? 'left' : button;
        await page.mouse.click(x, y, { button: btn });
        break;
      }
      case 'scroll': {
        const { x, y, scroll_x, scroll_y } = action;
        console.log(`Action: scroll at (${x}, ${y}) with offsets (scroll_x=${scroll_x}, scroll_y=${scroll_y})`);
        await page.mouse.move(x, y);
        await page.evaluate(`window.scrollBy(${scroll_x}, ${scroll_y})`);
        break;
      }
      case 'keypress': {
        const keys = action.keys;
        for (const k of keys) {
          console.log(`Action: keypress '${k}'`);
          if (k.toLowerCase() === 'enter') await page.keyboard.press('Enter');
          else if (k.toLowerCase() === 'space') await page.keyboard.press(' ');
          else await page.keyboard.press(k);
        }
        break;
      }
      case 'type': {
        const text = action.text;
        console.log(`Action: type text: ${text}`);
        await page.keyboard.type(text);
        break;
      }
      case 'wait': {
        console.log('Action: wait');
        await new Promise(r => setTimeout(r, 2000));
        break;
      }
      case 'screenshot':
        console.log('Action: screenshot');
        break;
      default:
        console.log(`Unrecognized action: ${action}`);
    }
  } catch (e) {
    console.log(`Error handling action ${action}: ${e}`);
  }
}

4. Создание обновленного скриншота

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

def get_screenshot(page):
    """
    Создать скриншот страницы с помощью Playwright и вернуть байты изображения.
    """
    return page.screenshot()

async function getScreenshot(page) {
  return await page.screenshot();
}

5. Повторить цикл

Как только у вас будет скриншот, отправьте его обратно модели в виде computer_call_output, чтобы получить следующее действие. Повторяйте эти шаги, пока в ответе присутствует элемент computer_call.

import time
import base64
from openai import OpenAI
client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

def computer_use_loop(instance, response):
    """
    Исполнять цикл до тех пор, пока в ответе присутствует элемент `computer_call`.
    """
    while True:
        computer_calls = [item for item in response.output if item.type == "computer_call"]
        if not computer_calls:
            print("Не найдено команд для выполнения. Ответ модели:")
            for item in response.output:
                print(item)
            break  # Выход, когда нет команд для выполнения.

        # Ожидаем не более одной команды выполнения в ответе.
        computer_call = computer_calls[0]
        last_call_id = computer_call.call_id
        action = computer_call.action

        # Выполнить действие (функция определена в шаге 3)
        handle_model_action(instance, action)
        time.sleep(1)  # Время ожидания для внесения изменений.

        # Сделать скриншот после действия (функция определена в шаге 4)
        screenshot_bytes = get_screenshot(instance)
        screenshot_base64 = base64.b64encode(screenshot_bytes).decode("utf-8")

        # Отправить скриншот обратно в виде computer_call_output
        response = client.responses.create(
            model="computer-use-preview",
            previous_response_id=response.id,
            tools=[
                {
                    "type": "computer_use_preview",
                    "display_width": 1024,
                    "display_height": 768,
                    "environment": "browser"
                }
            ],
            input=[
                {
                    "call_id": last_call_id,
                    "type": "computer_call_output",
                    "output": {
                        "type": "input_image",
                        "image_url": f"data:image/png;base64,{screenshot_base64}"
                    }
                }
            ],
            truncation="auto"
        )

    return response

import OpenAI from 'openai';
import fs from 'fs';

const client = new OpenAI({
  apiKey: '<КЛЮЧ>',
  baseURL: 'https://api.delirium.ru/openai/v1'
});

async function computerUseLoop(instance, response) {
  while (true) {
    const computerCalls = response.output.filter(item => item.type === 'computer_call');
    if (computerCalls.length === 0) {
      console.log('Не найдено команд для выполнения. Ответ модели:');
      response.output.forEach(item => console.log(item));
      break;
    }

    const computerCall = computerCalls[0];
    const lastCallId = computerCall.call_id;
    const action = computerCall.action;

    await handleModelAction(instance, action);
    await new Promise(r => setTimeout(r, 1000));

    const screenshotBytes = await getScreenshot(instance);
    const screenshotBase64 = Buffer.from(screenshotBytes).toString('base64');

    response = await client.responses.create({
      model: 'computer-use-preview',
      previous_response_id: response.id,
      tools: [{
        type: 'computer_use_preview',
        display_width: 1024,
        display_height: 768,
        environment: 'browser'
      }],
      input: [{
        call_id: lastCallId,
        type: 'computer_call_output',
        output: {
          type: 'input_image',
          image_url: `data:image/png;base64,${screenshotBase64}`
        }
      }],
      truncation: 'auto'
    });
  }
  return response;
}

Управление историей разговора

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

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

Подтверждение проверок безопасности

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

• Обнаружение вредоносных инструкций: мы оцениваем изображение скриншота и проверяем, содержит ли оно опасный контент, который может изменить поведение модели.
• Обнаружение несоответствующего домена: мы оцениваем current_url (если он предоставлен) и проверяем, является ли текущий домен релевантным с учётом истории разговора.
• Обнаружение рискованных доменов: мы проверяем current_url (если он предоставлен) и выдаём предупреждение, если обнаруживаем, что пользователь находится на рискованном домене.

Если одна или несколько из этих проверок срабатывают, в ответе модели с computer_call будет включён параметр pending_safety_checks, указывающий на наличие незавершённых проверок безопасности.

"output": [
    {
        "type": "computer_call",
        ...
        "pending_safety_checks": [
            {
                "id": "cu_sc_67cb...",
                "code": "malicious_instructions",
                "message": "We've detected instructions that may..."
            }
        ],
    }
]

Подтверждение проверок безопасности

Чтобы продолжить, вам необходимо передать проверки безопасности обратно в следующем запросе в виде acknowledged_safety_checks.

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

• Вредоносные инструкции (malicious_instructions) и несоответствующий домен (irrelevant_domain): пользователь должен просмотреть действия модели и подтвердить, что она ведёт себя должным образом.
• Рискованный домен (sensitive_domain): убедитесь, что пользователь активно следит за действиями модели на таких сайтах. Реализация этого режима "наблюдения" может различаться в зависимости от приложения, но, например, можно собирать данные о взаимодействии пользователя с сайтом, чтобы удостовериться, что он активно контролирует работу модели.

from openai import OpenAI
client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.responses.create(
    model="computer-use-preview",
    previous_response_id="<previous_response_id>",
    tools=[{
        "type": "computer_use_preview",
        "display_width": 1024,
        "display_height": 768,
        "environment": "browser"
    }],
    input=[
        {
            "type": "computer_call_output",
            "call_id": "<call_id>",
            "acknowledged_safety_checks": [
                {
                    "id": "<safety_check_id>",
                    "code": "malicious_instructions",
                    "message": "We've detected instructions that may..."
                }
            ],
            "output": {
                "type": "computer_screenshot",
                "image_url": "<image_url>"
            }
        }
    ],
    truncation="auto"
)

import OpenAI from 'openai';

const client = new OpenAI({
  apiKey: '<КЛЮЧ>',
  baseURL: 'https://api.delirium.ru/openai/v1'
});

const response = await client.responses.create({
  model: 'computer-use-preview',
  previous_response_id: '<previous_response_id>',
  tools: [{
    type: 'computer_use_preview',
    display_width: 1024,
    display_height: 768,
    environment: 'browser'
  }],
  input: [{
    type: 'computer_call_output',
    call_id: '<call_id>',
    acknowledged_safety_checks: [{
      id: '<safety_check_id>',
      code: 'malicious_instructions',
      message: "We've detected instructions that may..."
    }],
    output: {
      type: 'computer_screenshot',
      image_url: '<image_url>'
    }
  }],
  truncation: 'auto'
});

Готовое приложение

Готовое приложение для управления компьютером с помощью OpenAI API доступно на GitHub: CUA Sample App

Ограничения

OpenAI рекомендует использовать модель computer-use-preview для задач, связанных с браузером. Модель может допускать случайные ошибки, особенно в средах, отличных от браузерных, так как она реже используется в таких сценариях.

Например, производительность computer-use-preview на платформе OSWorld составляет 38,1%, что указывает на её низкую надёжность при автоматизации задач на операционной системе.

Риски и безопасность

Использование компьютера с помощью модели несёт особенные риски, отличные от стандартных функций API или чатов, особенно при взаимодействии с интернетом.

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

1. Человеческий контроль для задач с высокими рисками

Избегайте автоматизации задач, которые имеют высокие ставки или требуют абсолютной точности.

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

2. Защита от внедрения вредоносных инструкций (prompt injection)

Prompt injection — это случай, когда модель непреднамеренно выполняет нежелательные инструкции из входных данных.

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

Как снизить риск:

• Ограничьте доступ модели к изолированным, доверенным средам (например, песочница, контейнер).

3. Используйте списки блокировки и разрешения

• Черный список (запрещённые сайты/действия).
• Белый список (сайты, с которыми модель должна работать).

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

4. Используйте встроенные проверки безопасности

Доступные механизмы защиты:

• Обнаружение вредоносных инструкций
• Обнаружение нерелевантных доменов
• Обнаружение чувствительных доменов

Если получен pending_safety_check, модель должна:

• Передать управление пользователю для явного подтверждения.
• Гарантировать активный контроль за действиями (например, режим «наблюдения»).

5. Передавайте current_url

Этот параметр повышает точность проверок безопасности.

{
    "type": "computer_call_output",
    "call_id": "call_7OU...",
    "acknowledged_safety_checks": [],
    "output": {
        "type": "computer_screenshot",
        "image_url": "..."
    },
    "current_url": "https://delirium.ru"
}

Векторные эмбеддинги OpenAI API

Текстовые эмбеддинги OpenAI измеряют взаимосвязь текстовых строк. Эмбеддинги обычно используются для:

• Поиска (где результаты ранжируются по релевантности к поисковому запросу)
• Кластеризации (где текстовые строки группируются по схожести)
• Рекомендаций (где рекомендуются элементы со связанными текстовыми строками)
• Обнаружения аномалий (где выявляются выбросы с малой связанностью)
• Измерения разнообразия (где анализируются распределения схожести)
• Классификации (где текстовые строки классифицируются по наиболее похожей метке)

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

Модели

OpenAI предлагает два мощных эмбеддинг-модели третьего поколения (обозначенных как -3 в идентификаторе модели):

• text-embedding-3-small — новейшая и наиболее производительная модель с оптимальным соотношением цена/качество
• text-embedding-3-large — самая мощная модель с высочайшей точностью
• text-embedding-ada-002 — предыдущее поколение, все еще доступна для совместимости

Новые возможности моделей третьего поколения

text-embedding-3-small и text-embedding-3-large — новейшие и наиболее производительные модели эмбеддингов. Они отличаются:

• Более низкой стоимостью
• Более высокой многоязычной производительностью
• Новыми параметрами для контроля общего размера

Управление размерностью

По умолчанию длина векторов эмбеддингов составляет 1536 для text-embedding-3-small или 3072 для text-embedding-3-large.

Чтобы уменьшить размерность эмбеддингов без потери их концептуальных свойств, используйте параметр dimensions. Это позволяет:

• Снизить затраты на хранение и вычисления
• Адаптироваться к ограничениям векторных баз данных
• Балансировать между производительностью и размером

Пример

curl "https://api.delirium.ru/openai/v1/embeddings" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "input": "Your text string goes here",
        "model": "text-embedding-3-small"
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openai/v1"
)

response = client.embeddings.create(
    model="text-embedding-3-small",
    input="Your text string goes here"
)

print(response.data[0].embedding)

import OpenAI from 'openai';

const client = new OpenAI({
  baseURL: 'https://api.delirium.ru/openai/v1',
  apiKey: '<КЛЮЧ>'
});

const response = await client.embeddings.create({
  model: 'text-embedding-3-small',
  input: 'Your text string goes here'
});

console.log(response.data[0].embedding);

Векторные базы данных

Для быстрого поиска по множеству векторов рекомендуется использовать векторные базы данных, такие как:

• Pinecone
• Weaviate
• Qdrant
• Chroma
• FAISS

Модели Anthropic

Anthropic — это один из мировых лидеров в сфере искусственного интеллекта. Компания известна своими передовыми языковыми моделями семейства Claude, конкурирующими с ChatGPT от OpenAI и Gemini от Google. Разработчики особенно высоко оценивают модель Claude, особенно её последние версии Sonnet и Opus, за их выдающиеся способности в программировании.

Языковые модели

* RPM — requests per minute (запросов в минуту) / TPM — tokens per minute (токенов в минуту)

Генерация текста

Все методы и форматы запросов и ответов, а также методы авторизации в Delirium API идентичны оригинальным от Anthropic. Таким образом, официальные SDK полностью совместимы с Delirium API.

Для запросов к Anthropic в качестве пути к API необходимо использовать:

https://api.delirium.ru/anthropic

Пример простого запроса генерации текста:

Для запросов к Anthropic в качестве пути к API необходимо использовать:

curl "https://api.delirium.ru/anthropic/v1/messages" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "claude-3-7-sonnet-20250219",
        "max_tokens": 1000,
        "messages": [
            {
                "role": "user",
                "content": "Привет!"
            }
        ]
    }'

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.delirium.ru/anthropic",
    api_key="<КЛЮЧ>"
)

response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1000,
    messages=[
        {"role": "user", "content": "Привет!"}
    ]
)

print(response.content)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  baseURL: 'https://api.delirium.ru/anthropic',
  apiKey: '<КЛЮЧ>'
});

const response = await client.messages.create({
  model: 'claude-3-7-sonnet-20250219',
  max_tokens: 1000,
  messages: [
    { role: 'user', content: 'Привет!' }
  ]
});

console.log(response.content);

Кэширование промптов (Anthropic)

Модели Claude поддерживают кэширование промптов в двух режимах: автоматическое (одна строка конфигурации) и явное (точечная разметка кэшируемых блоков). В обоих случаях чтение из кэша обходится в 10 раз дешевле обычных входных токенов.

Автоматическое кэширование

Добавьте cache_control на верхнем уровне запроса — система автоматически закэширует всё содержимое до последнего кэшируемого блока:

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 1024,
  "cache_control": {"type": "ephemeral"},
  "system": "Длинный системный промпт...",
  "messages": [...]
}

При последующих запросах с тем же началом кэшированная часть будет прочитана из кэша.

Явное кэширование

Для точного контроля разместите cache_control на конкретных блоках содержимого:

{
  "model": "claude-sonnet-4-5",
  "max_tokens": 1024,
  "system": [
    {
      "type": "text",
      "text": "Длинный системный промпт...",
      "cache_control": {"type": "ephemeral"}
    }
  ],
  "messages": [...]
}

Этот режим полезен, когда нужно закэшировать определённые части запроса — например, системный промпт, но не историю диалога.

Стоимость

В отличие от OpenAI и Google, у Anthropic запись в кэш платная:

Кэширование окупается уже после одного повторного запроса.

Минимальная длина

Минимальная длина кэшируемого содержимого зависит от модели:

Время жизни кэша

По умолчанию — 5 минут. Каждое попадание в кэш продлевает таймер без дополнительной оплаты.

Как отслеживать

В ответе API возвращаются два поля:

{
  "usage": {
    "input_tokens": 50,
    "cache_creation_input_tokens": 5000,
    "cache_read_input_tokens": 0
  }
}

• cache_creation_input_tokens — токены, записанные в кэш (оплачиваются по повышенной ставке)
• cache_read_input_tokens — токены, прочитанные из кэша (скидка 90%)

При повторном запросе cache_creation_input_tokens станет 0, а cache_read_input_tokens покажет количество кэшированных токенов.

Пример

curl "https://api.delirium.ru/anthropic/v1/messages" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
        "model": "claude-sonnet-4-5",
        "max_tokens": 1024,
        "cache_control": {"type": "ephemeral"},
        "system": "Длинный системный промпт (более 1024 токенов)...",
        "messages": [
            {
                "role": "user",
                "content": "Вопрос пользователя"
            }
        ]
    }'

import anthropic

client = anthropic.Anthropic(
    base_url="https://api.delirium.ru/anthropic",
    api_key="<КЛЮЧ>"
)

response = client.messages.create(
    model="claude-sonnet-4-5",
    max_tokens=1024,
    system="Длинный системный промпт (более 1024 токенов)...",
    messages=[
        {"role": "user", "content": "Вопрос пользователя"}
    ]
)

print(response.usage)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  baseURL: 'https://api.delirium.ru/anthropic',
  apiKey: '<КЛЮЧ>'
});

const response = await client.messages.create({
  model: 'claude-sonnet-4-5',
  max_tokens: 1024,
  system: 'Длинный системный промпт (более 1024 токенов)...',
  messages: [
    { role: 'user', content: 'Вопрос пользователя' }
  ]
});

console.log(response.usage);

Порядок кэширования

Anthropic кэширует содержимое запроса в определённом порядке: tools → system → messages. Изменение на любом уровне инвалидирует кэш этого уровня и всех последующих. Например, изменение описания инструментов сбросит кэш инструментов, системного промпта и сообщений.

Компьютерное зрение или запрос по изображению в Anthropic Claude API

Базовая информация о том, как в API работает компьютерное зрение, доступна в разделе Компьютерное зрение.

Пример cо ссылкой на изображение

curl "https://api.delirium.ru/anthropic/v1/messages" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
        "model": "claude-3-7-sonnet-20250219",
        "max_tokens": 1024,
        "messages": [
            {
                "role": "user",
                "content": [
                    {"type": "text", "text": "Что изображено на картинке?"},
                    {
                        "type": "image",
                        "source": {
                            "type": "url",
                            "url": "https://domain.com/your_image.jpg"
                        }
                    }
                ]
            }
        ]
    }'

from anthropic import Anthropic

client = Anthropic(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/anthropic"
)

response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1024,
    messages=[
        {
            "role": "user",
            "content": [
                {"type": "text", "text": "Что изображено на картинке?"},
                {
                    "type": "image",
                    "source": {
                        "type": "url",
                        "url": "https://domain.com/your_image.jpg"
                    }
                }
            ]
        }
    ]
)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: '<КЛЮЧ>',
  baseURL: 'https://api.delirium.ru/anthropic'
});

const response = await client.messages.create({
  model: 'claude-3-7-sonnet-20250219',
  max_tokens: 1024,
  messages: [
    {
      role: 'user',
      content: [
        { type: 'text', text: 'Что изображено на картинке?' },
        {
          type: 'image',
          source: {
            type: 'url',
            url: 'https://domain.com/your_image.jpg'
          }
        }
      ]
    }
  ]
});

Пример c base64 изображением

import base64
from anthropic import Anthropic

client = Anthropic(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/anthropic"
)

def encode_image(image_path):
    with open(image_path, "rb") as image_file:
        return base64.b64encode(image_file.read()).decode("utf-8")

base64_image = encode_image("path_to_your_image.jpg")

response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1024,
    messages=[{
        "role": "user",
        "content": [
            {"type": "text", "text": "Что изображено на картинке?"},
            {
                "type": "image",
                "source": {
                    "type": "base64",
                    "media_type": "image/jpeg",
                    "data": base64_image
                }
            }
        ]
    }]
)

import fs from 'fs';
import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: '<КЛЮЧ>',
  baseURL: 'https://api.delirium.ru/anthropic'
});

function encodeImage(imagePath) {
  return fs.readFileSync(imagePath).toString('base64');
}

const base64Image = encodeImage('path_to_your_image.jpg');

const response = await client.messages.create({
  model: 'claude-3-7-sonnet-20250219',
  max_tokens: 1024,
  messages: [{
    role: 'user',
    content: [
      { type: 'text', text: 'Что изображено на картинке?' },
      {
        type: 'image',
        source: {
          type: 'base64',
          media_type: 'image/jpeg',
          data: base64Image
        }
      }
    ]
  }]
});

Требования к входным изображениям

В одном запросе можно включить до 100 изображений. Claude API анализирует все предоставленные изображения при формулировании ответа. Это полезно для сравнения или сопоставления изображений.

При отправке изображения с разрешением больше 8000x8000 пикселей оно будет отклонено. При отправке более 20 изображений в одном API-запросе предельное допустимое разрешение снижается до 2000x2000 пикселей.

Формат изображения: JPEG, PNG, GIF или WebP.

Генерация текста Anthropic API с веб-поиском

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

Как работает веб-поиск

Когда вы добавляете инструмент веб-поиска в свой API-запрос:

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

Пример

curl "https://api.delirium.ru/anthropic/v1/messages" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -H "anthropic-version: 2023-06-01" \
    -d '{
        "model": "claude-3-7-sonnet-20250219",
        "max_tokens": 1024,
        "tools": [{
            "type": "web_search_20250305",
            "name": "web_search",
            "max_uses": 5
        }],
        "messages": [
            {
                "role": "user",
                "content": "Сколько людей живет в Москве?"
            }
        ]
    }'

from anthropic import Anthropic

client = Anthropic(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/anthropic"
)

response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1024,
    tools=[{
        "type": "web_search_20250305",
        "name": "web_search",
        "max_uses": 5
    }],
    messages=[
        {
            "role": "user",
            "content": "Сколько людей живет в Москве?"
        }
    ]
)

import Anthropic from '@anthropic-ai/sdk';

const client = new Anthropic({
  apiKey: '<КЛЮЧ>',
  baseURL: 'https://api.delirium.ru/anthropic'
});

const response = await client.messages.create({
  model: 'claude-3-7-sonnet-20250219',
  max_tokens: 1024,
  tools: [{
    type: 'web_search_20250305',
    name: 'web_search',
    max_uses: 5
  }],
  messages: [
    {
      role: 'user',
      content: 'Какая сегодня погода?'
    }
  ]
});

Настройки веб-поиска

Инструмент веб-поиска поддерживает следующие параметры:

{
    "type": "web_search_20250305",
    "name": "web_search",
    "max_uses": 5,
    "allowed_domains": ["example.com", "example.org"],
    "blocked_domains": ["blocked.com"],
    "user_location": {
        "type": "approximate",
        "city": "Москва",
        "region": "Москва",
        "country": "RU",
        "timezone": "Europe/Moscow"
    }
}

Максимальное количество поисковых запросов

Параметр max_uses ограничивает количество выполняемых поисков. Если Claude попытается выполнить больше поисков, чем разрешено, web_search_tool_result вернёт ошибку с кодом max_uses_exceeded.

Фильтрация по доменам

При использовании фильтров по доменам:

• Не указывайте схему HTTP/HTTPS (используйте example.com вместо https://example.com)
• Поддомены включаются автоматически (example.com охватывает docs.example.com)
• Поддерживаются подпути (example.com/blog)
• Вы можете использовать либо allowed_domains, либо blocked_domains, но не оба параметра в одном запросе.

Локализация

Параметр user_location позволяет локализовать результаты поиска в зависимости от местоположения пользователя.

• type: Тип местоположения (должен быть approximate)
• city: Название города
• region: Регион или штат
• country: Страна
• timezone: IANA-идентификатор часового пояса

Кэширование

Веб-поиск работает с кэшированием. Чтобы включить кэширование, добавьте хотя бы одну точку останова cache_control в ваш запрос. Система автоматически закэширует всё до последнего блока web_search_tool_result при выполнении инструмента.

Для диалогов с несколькими итерациями установите точку останова cache_control внутри или после последнего блока web_search_tool_result, чтобы повторно использовать закэшированный контент.

Например, чтобы использовать кэширование с веб-поиском в диалоге с несколькими итерациями:

from anthropic import Anthropic

client = Anthropic(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/anthropic"
)

# First request with web_search tool
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1024,
    tools=[{
        "type": "web_search_20250305",
        "name": "web_search",
        "max_uses": 5
    }],
    messages=[{
        "role": "user",
        "content": "Сколько людей живет в Москве?"
    }]
)

# Append response to messages
messages = [
    {"role": "user", "content": "Сколько людей живет в Москве?"},
    {"role": "assistant", "content": response.content}
]

# Second request with cache_control breakpoint after search results
messages.append({
    "role": "user",
    "content": "Будет ли дождь на неделе?",
    "cache_control": {"type": "ephemeral"}
})

response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=1024,
    tools=[{
        "type": "web_search_20250305",
        "name": "web_search",
        "max_uses": 5
    }],
    messages=messages
)

print(f"Cache read tokens: {response.usage.get('cache_read_input_tokens', 0)}")

Тарификация

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

Модели Google

Помимо безусловного превосходства в сфере поиска в интернет, Google — один из мировых лидеров в сфере искусственного интеллекта. Компания известна своими передовыми языковыми моделями семейства Gemini, конкурирующими с ChatGPT от OpenAI и Claude от Anthropic. Пользователи особенно высоко оценивают Gemini за выдающиеся мультимодальные возможности и способность обрабатывать тексты, изображения, аудио и видео в едином контексте. Одной из ключевых особенностей моделей является их большое контекстное окно, достигающее 1 и даже 2 миллионов токенов, что делает их незаменимыми для сложных аналитических задач и работы с длинными документами.

Языковые модели

Генерация изображений

Генерация видео

* RPM — requests per minute (запросов в минуту) / TPM — tokens per minute (токенов в минуту) / RPD — requests per day (запросов в день)

Генерация текста Gemini API

Все методы и форматы запросов и ответов, а также методы авторизации в Delirium API идентичны оригинальным от Gemini API. Таким образом, официальные SDK полностью совместимы с Delirium API.

Для запросов к Gemini в качестве пути к API необходимо использовать:

https://api.delirium.ru/google

Пример простого запроса генерации текста:

Для запросов к Gemini в качестве пути к API необходимо использовать:

curl "https://api.delirium.ru/google/v1beta/models/gemini-2.0-flash:generateContent" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -X POST \
    -d '{
        "contents": [
            {
                "parts": [
                    {"text": "Привет!"}
                ]
            }
        ]
    }'

import requests

response = requests.post(
    "https://api.delirium.ru/google/v1beta/models/gemini-2.0-flash:generateContent",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer <КЛЮЧ>"
    },
    json={
        "contents": [
            {
                "parts": [
                    {"text": "Привет!"}
                ]
            }
        ]
    }
)

print(response.json())

const response = await fetch(
    "https://api.delirium.ru/google/v1beta/models/gemini-2.0-flash:generateContent",
    {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": "Bearer <КЛЮЧ>"
        },
        body: JSON.stringify({
            contents: [
                {
                    parts: [
                        {text: "Привет!"}
                    ]
                }
            ]
        })
    }
);

const data = await response.json();
console.log(data);

Кэширование промптов (Google)

Модели Google Gemini 2.5 и новее поддерживают автоматическое (имплицитное) кэширование. Оно включено по умолчанию — никаких изменений в коде не требуется. Если запрос содержит совпадающий префикс с предыдущими запросами, скидка применяется автоматически.

Как работает

1. Каждый запрос к Gemini 2.5+ автоматически проверяется на совпадение с ранее обработанными запросами
2. Если начало запроса (префикс) совпадает — токены берутся из кэша со скидкой до 90%
3. Запись в кэш бесплатна — дополнительных расходов нет
4. Кэшируется всё содержимое: текст, изображения, аудио, видео, документы

Минимальная длина

Стоимость

• Запись в кэш: бесплатно
• Чтение из кэша: до 90% дешевле обычных входных токенов (зависит от модели и платформы)

У моделей с расширенным контекстом (Pro при >200K токенов) кэшированные токены также тарифицируются по сниженной ставке.

Как увеличить частоту попаданий

• Размещайте неизменяемое содержимое (инструкции, документы) в начале запроса
• Изменяемую часть (вопрос пользователя) — в конце
• Отправляйте запросы с одинаковым префиксом в короткий промежуток времени — это увеличивает вероятность попадания в кэш

Как отслеживать

При работе через нативный API Google информация о кэшировании возвращается в usageMetadata:

{
  "usageMetadata": {
    "promptTokenCount": 10523,
    "candidatesTokenCount": 512,
    "totalTokenCount": 11035,
    "cachedContentTokenCount": 9800
  }
}

Значение cachedContentTokenCount показывает количество токенов, обработанных из кэша.

При работе через OpenAI-совместимый эндпоинт информация доступна в стандартном формате usage.prompt_tokens_details.cached_tokens.

Пример через Delirium API (нативный API)

curl "https://api.delirium.ru/google/v1beta/models/gemini-2.5-flash:generateContent" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -X POST \
    -d '{
        "contents": [
            {
                "role": "user",
                "parts": [
                    {"text": "Длинный контекст (более 1024 токенов)..."},
                    {"text": "Вопрос пользователя"}
                ]
            }
        ]
    }'

import requests

response = requests.post(
    "https://api.delirium.ru/google/v1beta/models/gemini-2.5-flash:generateContent",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer <КЛЮЧ>"
    },
    json={
        "contents": [
            {
                "role": "user",
                "parts": [
                    {"text": "Длинный контекст (более 1024 токенов)..."},
                    {"text": "Вопрос пользователя"}
                ]
            }
        ]
    }
)

print(response.json()["usageMetadata"])

const response = await fetch(
    "https://api.delirium.ru/google/v1beta/models/gemini-2.5-flash:generateContent",
    {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": "Bearer <КЛЮЧ>"
        },
        body: JSON.stringify({
            contents: [
                {
                    role: "user",
                    parts: [
                        {text: "Длинный контекст (более 1024 токенов)..."},
                        {text: "Вопрос пользователя"}
                    ]
                }
            ]
        })
    }
);

const data = await response.json();
console.log(data.usageMetadata);

Отправьте два одинаковых запроса подряд. Во втором ответе cachedContentTokenCount будет больше нуля — кэш сработал.

Генерация текста Gemini API с веб-поиском

Grounding with Google Search (заземление через Google Поиск) — это инструмент Gemini API, который позволяет моделям выполнять поиск в Google для получения актуальной информации из интернета перед генерацией ответа. Модель сама решает, когда выполнить поиск, и указывает использованные источники в метаданных ответа.

Как работает веб-поиск

• Модель сама решает, нужен ли поиск, исходя из запроса. Для актуальных или фактологических вопросов она формирует один или несколько поисковых запросов.
• API выполняет поиск в Google и передаёт модели полученные результаты. В рамках одного запроса может быть выполнено несколько поисков.
• Модель формирует финальный ответ на основе результатов поиска и возвращает метаданные заземления (groundingMetadata) с перечнем выполненных поисковых запросов и источников.

Пример

curl "https://api.delirium.ru/google/v1beta/models/gemini-2.5-flash:generateContent" \
-H 'Content-Type: application/json' \
-H 'Authorization: Bearer <КЛЮЧ>' \
-X POST \
-d '{
  "contents": [{
    "parts": [{"text": "Кто выиграл последнюю гонку Формулы-1?"}]
  }],
  "tools": [{"google_search": {}}]
}'

import requests

response = requests.post(
    "https://api.delirium.ru/google/v1beta/models/gemini-2.5-flash:generateContent",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer <КЛЮЧ>"
    },
    json={
        "contents": [{
            "parts": [{"text": "Кто выиграл последнюю гонку Формулы-1?"}]
        }],
        "tools": [{"google_search": {}}]
    }
)

print(response.json())

const response = await fetch(
    "https://api.delirium.ru/google/v1beta/models/gemini-2.5-flash:generateContent",
    {
        method: "POST",
        headers: {
            "Content-Type": "application/json",
            "Authorization": "Bearer <КЛЮЧ>"
        },
        body: JSON.stringify({
            contents: [{
                parts: [{text: "Кто выиграл последнюю гонку Формулы-1?"}]
            }],
            tools: [{google_search: {}}]
        })
    }
);

const data = await response.json();
console.log(data);

Метаданные заземления

Если модель выполнила поиск, в ответе появляется объект groundingMetadata внутри каждого кандидата. Он содержит:

• webSearchQueries — список поисковых запросов, которые модель фактически выполнила.
• groundingChunks — источники (веб-страницы), использованные для ответа, с их заголовками и URL.
• groundingSupports — соответствие между фрагментами ответа и источниками, на основе которых они сформированы.
• searchEntryPoint — готовый HTML-блок с подсказками поиска (Search Suggestions). По требованиям Google его необходимо отображать пользователю вместе с ответом, если используется заземление.

Тарификация

Потребление токенов тарифицируется как обычно для выбранной модели. Дополнительно тарифицируется каждый поисковый запрос, который фактически выполнила модель: стоимость фиксированная и не зависит от количества потраченных токенов. Если модель не выполняла поиск, дополнительная плата не взимается. Цены здесь.

Компьютерное зрение или запрос по изображению в Gemini API

Базовая информация о том, как в API работает компьютерное зрение доступна здесь.

Gemini API не поддерживает передачу изображений по URL. Если изображение доступно по ссылке, сначала необходимо скачать его на своей стороне, затем закодировать в base64 и только после этого передать в запросе.

Пример c base64 изображением

from google import genai

client = genai.Client(
    api_key="<КЛЮЧ>", 
    http_options={"base_url": "https://api.delirium.ru/google"}
)

# Путь к изображению
image_path = "path_to_your_image.jpg"

# Получение байтов изображения
with open(image_path, 'rb') as f:
    image_bytes = f.read()

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[
        genai.types.Part.from_bytes(
            data=image_bytes,
            mime_type="image/jpeg",
        ),
        "Что изображено на картинке?"
    ]
)

const { GoogleGenAI } = require("@google/genai");

const client = new GoogleGenAI({
    apiKey: "<КЛЮЧ>",
    httpOptions: {
        baseUrl: "https://api.delirium.ru/google"
    }
});

const fs = require("fs");
const path = require("path");
const imagePath = "path_to_your_image.jpg";
const imageBytes = fs.readFileSync(imagePath);
const base64Image = imageBytes.toString("base64");

const response = await client.models.generateContent({
    model: "gemini-2.0-flash",
    contents: [
        {
            inlineData: {
                data: base64Image,
                mimeType: "image/jpeg"
            }
        },
        {text: "Что изображено на картинке?"}
    ]
});

console.log(response.text);

Требования к входным изображениям

Максимальный общий размер запроса — 20 МБ. Он включает текст промпта, системные инструкции и все вложенные файлы.

Запрос с несколькими изображениями

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

from google import genai

client = genai.Client(
    api_key="<КЛЮЧ>", 
    http_options={"base_url": "https://api.delirium.ru/google"}
)

# Пути к изображениям
image_path1 = "path_to_first_image.jpg"
image_path2 = "path_to_second_image.jpg"

# Получение байтов изображений
with open(image_path1, 'rb') as f1:
    image_bytes1 = f1.read()

with open(image_path2, 'rb') as f2:
    image_bytes2 = f2.read()

response = client.models.generate_content(
    model="gemini-2.0-flash",
    contents=[
        genai.types.Part.from_bytes(data=image_bytes1, mime_type="image/jpeg"),
        genai.types.Part.from_bytes(data=image_bytes2, mime_type="image/jpeg"),
        "Сравни эти два изображения"
    ]
)

const { GoogleGenAI } = require("@google/genai");

const client = new GoogleGenAI({
    apiKey: "<КЛЮЧ>",
    httpOptions: {
        baseUrl: "https://api.delirium.ru/google"
    }
});

const fs = require("fs");
const path = require("path");
const imagePath1 = "path_to_first_image.jpg";
const imagePath2 = "path_to_second_image.jpg";
const imageBytes1 = fs.readFileSync(imagePath1);
const imageBytes2 = fs.readFileSync(imagePath2);
const base64Image1 = imageBytes1.toString("base64");
const base64Image2 = imageBytes2.toString("base64");

const response = await client.models.generateContent({
    model: "gemini-2.0-flash",
    contents: [
        {inlineData: {data: base64Image1, mimeType: "image/jpeg"}},
        {inlineData: {data: base64Image2, mimeType: "image/jpeg"}},
        {text: "Сравни эти два изображения"}
    ]
});

console.log(response.text);

Получение рамки объекта

Модели Gemini обучены распознавать объекты на изображении и предоставлять координаты их рамок. Координаты возвращаются относительно размеров изображения, масштабированных в диапазон [0, 1000]. Необходимо преобразовать эти координаты обратно в размеры исходного изображения.

Запросить модель вернуть рамку объекта можно прямо через промпт.

Найди все различимые объекты на изображении. 
Параметр box_2d должен быть в формате [ymin, xmin, ymax, xmax], 
нормализованным в диапазоне от 0 до 1000.

Рамки объекта можно использовать для обнаружения и локализации объектов на изображениях и в видео.

Основные преимущества

• Простота: Легко интегрируйте возможности обнаружения объектов в свои приложения.
• Управляемость: Создавайте рамки объектов на основе пользовательских инструкций.

Технические детали

• Входные данные: Ваш текстовый запрос и связанные изображения или кадры видео.
• Выходные данные: Рамки объектов в формате [y_min, x_min, y_max, x_max]. Начало координат — в верхнем левом углу. Координаты нормализованы в диапазон от 0 до 1000 для каждого изображения.

Нормализация координат

Модель возвращает координаты рамок объекта в формате [y_min, x_min, y_max, x_max]. Чтобы преобразовать эти координаты в пиксельные координаты исходного изображения:

1. Разделить каждую координату на 1000.
2. Умножить x-координату на ширину исходного изображения.
3. Умножить y-координату на высоту исходного изображения.

Сегментация изображений

Начиная с версии Gemini 2.5, модели обучены не только обнаруживать объекты, но и сегментировать их, предоставляя маску их контуров.

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

• рамку объекта (box_2d) в формате [y0, x0, y1, x1] с нормализованными координатами от 0 до 1000,
• метку (label), идентифицирующую объект,
• маску сегментации внутри рамки, в виде PNG, закодированного в base64. Это карта вероятностей со значениями от 0 до 255.

Маску нужно привести к размеру рамки объекта и бинаризовать по порогу уверенности (значение 127 — середина диапазона).

Предоставь маски сегментации для деревянных и стеклянных объектов.
Верни список в формате JSON, где каждый элемент содержит:
рамку объекта "box_2d" (формат [y0, x0, y1, x1], координаты нормализованы от 0 до 1000),
маску сегментации "mask" (PNG, закодированный в base64, карта вероятностей),
текстовую метку "label".

Поддерживаемые форматы изображений

Gemini поддерживает следующие форматы изображений (MIME-типы):

• PNG — image/png
• JPEG — image/jpeg
• WEBP — image/webp
• HEIC — image/heic
• HEIF — image/heif

Технические требования к изображениям

Ограничения по количеству изображений

Gemini 2.5 Pro, 2.0 Flash, 1.5 Pro и 1.5 Flash поддерживают максимум 3600 изображений в одном запросе.

Расчёт токенов

• Gemini 1.5 Flash и 1.5 Pro: 258 токенов, если обе стороны изображения ≤ 384 пикселей. Более крупные изображения разбиваются на плитки, каждая плитка расходует 258 токенов.
• Gemini 2.0 Flash: 258 токенов, если обе стороны ≤ 384 пикселей. Более крупные изображения разбиваются на плитки 768x768 пикселей, каждая плитка — 258 токенов.

Рекомендации

• Убедиться, что изображения корректно повернуты.
• Использовать чёткие, неразмытые изображения.
• При использовании одного изображения с текстовым промптом, помещать текстовую часть после изображения в массиве contents.

Генерация видео через Gemini API

Veo 3 — это современная модель Google для генерации высококачественных 8-секундных видео в разрешении 720p или 1080p с потрясающим реализмом и нативно сгенерированным аудио. Вы можете получить доступ к этой модели программно через Gemini API.

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

• Продолжение видео: создавайте продолжение для видео, которые были ранее сгенерированы с помощью Veo
• Генерация с указанием кадров: создавайте видео, указывая первый и последний кадры
• Управление через изображения: используйте до трех референсных изображений для управления содержимым вашего сгенерированного видео

Генерация видео из текста

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

BASE_URL="https://api.delirium.ru/google/v1beta"

# Отправить запрос на генерацию видео и сохранить имя операции
operation_name=$(curl -s "${BASE_URL}/models/veo-3.1-generate-preview:predictLongRunning" \
  -H "x-goog-api-key: <КЛЮЧ>" \
  -H "Content-Type: application/json" \
  -X "POST" \
  -d '{
    "instances": [{
      "prompt": "Крупный план двух людей, смотрящих на загадочный рисунок на стене, мерцающий свет факела. Мужчина бормочет: \u0022Это должно быть оно. Это секретный код.\u0022 Женщина смотрит на него и взволнованно шепчет: \u0022Что ты нашел?\u0022"
    }]
  }' | jq -r .name)

# Опрашивать статус операции
while true; do
  status_response=$(curl -s -H "x-goog-api-key: <КЛЮЧ>" "${BASE_URL}/${operation_name}")
  is_done=$(echo "${status_response}" | jq .done)
  if [ "${is_done}" = "true" ]; then
    video_uri=$(echo "${status_response}" | jq -r '.response.generateVideoResponse.generatedSamples[0].video.uri')
    echo "Загрузка видео из: ${video_uri}"
    curl -L -o dialogue_example.mp4 -H "x-goog-api-key: <КЛЮЧ>" "${video_uri}"
    break
  fi
  sleep 10
done

from google import genai
import time

client = genai.Client(
    api_key="<КЛЮЧ>",
    http_options={"base_url": "https://api.delirium.ru/google"}
)

prompt = "Крупный план двух людей, смотрящих на загадочный рисунок на стене, мерцающий свет факела."

# Отправить запрос на генерацию видео (асинхронно)
operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt=prompt
)

# Опрашивать статус операции
while not operation.done:
    print("Ожидание завершения генерации видео...")
    time.sleep(10)
    operation = client.operations.get(operation)

# Загрузить видео
video = operation.response.generated_videos[0]
client.files.download(file=video.video)
video.video.save("veo3_text_to_video.mp4")
print("Сгенерированное видео сохранено в veo3_text_to_video.mp4")

const {GoogleGenAI} = require("@google/genai");
const fs = require("fs");

const client = new GoogleGenAI({
    apiKey: "<КЛЮЧ>",
    httpOptions: {baseUrl: "https://api.delirium.ru/google"}
});

const prompt = "Крупный план двух людей, смотрящих на загадочный рисунок на стене, мерцающий свет факела.";

const operation = await client.models.generateVideos({
    model: "veo-3.1-generate-preview",
    prompt: prompt
});

while (!operation.done) {
    console.log("Ожидание завершения генерации видео...");
    await new Promise(r => setTimeout(r, 10000));
    operation = await client.operations.get(operation);
}

const video = operation.response.generatedVideos[0];
const buffer = await client.files.download({file: video.video});
fs.writeFileSync("veo3_text_to_video.mp4", buffer);
console.log("Сгенерированное видео сохранено в veo3_text_to_video.mp4");

Генерация видео из изображения

Следующий код демонстрирует генерацию изображения с помощью Gemini 2.5 Flash Image, а затем использование этого изображения в качестве начального кадра для генерации видео с Veo 3.1.

from google import genai
import time

client = genai.Client(
    api_key="<КЛЮЧ>",
    http_options={"base_url": "https://api.delirium.ru/google"}
)

prompt = "Панорамный широкий кадр спящего на солнце котенка калико"

# Шаг 1: Сгенерировать изображение с Gemini 2.5 Flash Image
image = client.models.generate_content(
    model="gemini-2.5-flash-image",
    contents=prompt,
    config={"response_modalities": ['IMAGE']}
)

# Шаг 2: Сгенерировать видео с Veo 3.1, используя изображение
operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt=prompt,
    image=image.parts[0].as_image(),
)

while not operation.done:
    print("Ожидание завершения генерации видео...")
    time.sleep(10)
    operation = client.operations.get(operation)

video = operation.response.generated_videos[0]
client.files.download(file=video.video)
video.video.save("veo3_with_image_input.mp4")
print("Сгенерированное видео сохранено в veo3_with_image_input.mp4")

const {GoogleGenAI} = require("@google/genai");
const fs = require("fs");

const client = new GoogleGenAI({
    apiKey: "<КЛЮЧ>",
    httpOptions: {baseUrl: "https://api.delirium.ru/google"}
});

const prompt = "Панорамный широкий кадр спящего на солнце котенка калико";

// Шаг 1: Сгенерировать изображение с Gemini 2.5 Flash Image
const imageResp = await client.models.generateContent({
    model: "gemini-2.5-flash-image",
    contents: [{text: prompt}],
    config: {responseModalities: ['IMAGE']}
});

// Шаг 2: Сгенерировать видео с Veo 3.1, используя изображение
const operation = await client.models.generateVideos({
    model: "veo-3.1-generate-preview",
    prompt: prompt,
    image: imageResp.candidates[0].content.parts[0].inlineData
});

while (!operation.done) {
    console.log("Ожидание завершения генерации видео...");
    await new Promise(r => setTimeout(r, 10000));
    operation = await client.operations.get(operation);
}

const video = operation.response.generatedVideos[0];
const buffer = await client.files.download({file: video.video});
fs.writeFileSync("veo3_with_image_input.mp4", buffer);
console.log("Сгенерированное видео сохранено в veo3_with_image_input.mp4");

Использование референсных изображений

Veo 3.1 теперь принимает до 3 референсных изображений для управления содержимым вашего сгенерированного видео. Предоставьте изображения человека, персонажа или продукта, чтобы сохранить внешний вид объекта в выходном видео. Например, использование этих трех изображений, сгенерированных с помощью Gemini 2.5 Flash Image, в качестве референсов с хорошо написанным промптом создает следующее видео.

import time
from google import genai

client = genai.Client(
    api_key="<КЛЮЧ>",
    http_options={"base_url": "https://api.delirium.ru/google"}
)

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

dress_reference = types.VideoGenerationReferenceImage(
  image=dress_image,
  reference_type="asset"
)

sunglasses_reference = types.VideoGenerationReferenceImage(
  image=glasses_image,
  reference_type="asset"
)

woman_reference = types.VideoGenerationReferenceImage(
  image=woman_image,
  reference_type="asset"
)

operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt=prompt,
    config=types.GenerateVideosConfig(
      reference_images=[dress_reference, sunglasses_reference, woman_reference],
    ),
)

while not operation.done:
    print("Ожидание завершения генерации видео...")
    time.sleep(10)
    operation = client.operations.get(operation)

video = operation.response.generated_videos[0]
client.files.download(file=video.video)
video.video.save("veo3.1_with_reference_images.mp4")
print("Сгенерированное видео сохранено в veo3.1_with_reference_images.mp4")

Использование первого и последнего кадров

Veo 3.1 позволяет создавать видео с использованием интерполяции, указывая первый и последний кадры видео.

import time
from google import genai

client = genai.Client(
    api_key="<КЛЮЧ>",
    http_options={"base_url": "https://api.delirium.ru/google"}
)

prompt = """Кинематографическое, жуткое видео. Призрачная женщина с длинными белыми волосами и развевающимся платьем мягко качается на веревочных качелях под массивным, корявым деревом в туманной, освещенной луной поляне. 
Туман сгущается и кружится вокруг нее, и она медленно исчезает, полностью растворяясь. Пустые качели остаются ритмично раскачиваться сами по себе в жуткой тишине."""

operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt=prompt,
    image=first_image,
    config=types.GenerateVideosConfig(
      last_frame=last_image
    ),
)

while not operation.done:
    print("Ожидание завершения генерации видео...")
    time.sleep(10)
    operation = client.operations.get(operation)

video = operation.response.generated_videos[0]
client.files.download(file=video.video)
video.video.save("veo3.1_with_interpolation.mp4")
print("Сгенерированное видео сохранено в veo3.1_with_interpolation.mp4")

Продолжение видео Veo

Используйте Veo 3.1 для создания продолжения видео, которые вы ранее сгенерировали с помощью Veo, на 7 секунд и до 20 раз.

Ограничения входного видео:

• Только видео, сгенерированные Veo, длительностью до 141 секунды
• Gemini API поддерживает продолжение видео только для видео, сгенерированных Veo
• Видео должно быть из предыдущей генерации, например operation.response.generated_videos[0].video
• Ожидается, что входные видео имеют определенную длину, соотношение сторон и размеры:
  • Соотношение сторон: 9:16 или 16:9
  • Разрешение: 720p
  • Длина видео: 141 секунда или меньше

Выходное видео с продолжением — это одно видео, объединяющее входное видео пользователя и сгенерированное продолжение, общей длительностью до 148 секунд.

Этот пример берет видео, сгенерированное Veo, показанное здесь с его оригинальным промптом, и создает для него продолжение, используя параметр video и новый промпт:

import time
from google import genai

client = genai.Client(
    api_key="<КЛЮЧ>",
    http_options={"base_url": "https://api.delirium.ru/google"}
)

prompt = "Проследить за бабочкой в сад, когда она приземляется на оранжевый цветок оригами. Пушистый белый щенок подбегает и нежно трогает цветок."

operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    video=operation.response.generated_videos[0].video,
    prompt=prompt,
    config=types.GenerateVideosConfig(
        number_of_videos=1,
        resolution="720p"
    ),
)

while not operation.done:
    print("Ожидание завершения генерации видео...")
    time.sleep(10)
    operation = client.operations.get(operation)

video = operation.response.generated_videos[0]
client.files.download(file=video.video)
video.video.save("veo3.1_extension.mp4")
print("Сгенерированное видео сохранено в veo3.1_extension.mp4")

Обработка асинхронных операций

Генерация видео — это вычислительно интенсивная задача. Когда вы отправляете запрос в API, он запускает долгосрочное задание и немедленно возвращает объект operation. Затем вы должны опрашивать статус, пока видео не будет готово, что обозначается статусом done равным true.

Суть этого процесса — цикл опроса, который периодически проверяет статус задания.

import time
from google import genai
from google.genai import types

client = genai.Client(
    api_key="<КЛЮЧ>",
    http_options={"base_url": "https://api.delirium.ru/google"}
)

# После запуска задания вы получаете объект operation
operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt="Кинематографический кадр величественного льва в саванне.",
)

# Альтернативно, вы можете использовать operation.name для получения операции
operation = types.GenerateVideosOperation(name=operation.name)

# Этот цикл проверяет статус задания каждые 10 секунд
while not operation.done:
    time.sleep(10)
    # Обновить объект operation для получения последнего статуса
    operation = client.operations.get(operation)

# Когда готово, результат находится в operation.response
# ... обработать и загрузить ваше видео ...

const operation = await client.models.generateVideos({
    model: "veo-3.1-generate-preview",
    prompt: "Кинематографический кадр величественного льва в саванне."
});

while (!operation.done) {
    console.log("Ожидание завершения...");
    await new Promise(r => setTimeout(r, 10000));
    operation = await client.operations.get(operation);
}

if (operation.response.generatedVideos) {
    console.log("Видео готово!");
} else {
    console.error("Ошибка:", operation.error);
}

Параметры и спецификации Veo API

Это параметры, которые вы можете установить в вашем API запросе для управления процессом генерации видео.

Обратите внимание, что параметр seed также доступен для моделей Veo 3. Он не гарантирует детерминизм, но немного улучшает его.

Вы можете настроить вашу генерацию видео, установив параметры в вашем запросе. Например, вы можете указать negativePrompt для управления моделью.

import time
from google import genai
from google.genai import types

client = genai.Client(
    api_key="<КЛЮЧ>",
    http_options={"base_url": "https://api.delirium.ru/google"}
)

operation = client.models.generate_videos(
    model="veo-3.1-generate-preview",
    prompt="Кинематографический кадр величественного льва в саванне.",
    config=types.GenerateVideosConfig(negative_prompt="мультфильм, рисунок, низкое качество"),
)

while not operation.done:
    print("Ожидание завершения генерации видео...")
    time.sleep(10)
    operation = client.operations.get(operation)

generated_video = operation.response.generated_videos[0]
client.files.download(file=generated_video.video)
generated_video.video.save("parameters_example.mp4")
print("Сгенерированное видео сохранено в parameters_example.mp4")

const {GoogleGenAI} = require("@google/genai");
const fs = require("fs");

const client = new GoogleGenAI({
    apiKey: "<КЛЮЧ>",
    httpOptions: {baseUrl: "https://api.delirium.ru/google"}
});

const operation = await client.models.generateVideos({
    model: "veo-3.1-generate-preview",
    prompt: "Кинематографический кадр величественного льва в саванне.",
    config: {
        negativePrompt: "мультфильм, рисунок, низкое качество"
    }
});

while (!operation.done) {
    console.log("Ожидание завершения генерации видео...");
    await new Promise(r => setTimeout(r, 10000));
    operation = await client.operations.get(operation);
}

const video = operation.response.generatedVideos[0];
const buffer = await client.files.download({file: video.video});
fs.writeFileSync("parameters_example.mp4", buffer);
console.log("Сгенерированное видео сохранено в parameters_example.mp4");

Ограничения

• Задержка запроса: Мин: 11 секунд; Макс: 6 минут (в часы пик)
• Региональные ограничения: В регионах EU, UK, CH, MENA для personGeneration доступно только значение allow_adult
• Хранение видео: Сгенерированные видео хранятся на сервере 2 дня, после чего они удаляются. Чтобы сохранить локальную копию, вы должны загрузить ваше видео в течение 2 дней после генерации. Видео с продолжением рассматриваются как новые сгенерированные видео
• Водяные знаки: Видео, созданные Veo, помечаются водяными знаками с использованием SynthID, инструмента Google для нанесения водяных знаков и идентификации контента, сгенерированного ИИ. Видео могут быть проверены с использованием платформы проверки SynthID
• Безопасность: Сгенерированные видео проходят через фильтры безопасности и процессы проверки запоминания, которые помогают снизить риски конфиденциальности, авторских прав и предвзятости
• Ошибка аудио: Veo 3.1 иногда блокирует генерацию видео из-за фильтров безопасности или других проблем обработки аудио. С вас не будет взиматься плата, если ваше видео было заблокировано от генерации

Работа с OpenRouter через Delirium API

Delirium API предоставляет удобный способ взаимодействия с моделями OpenRouter, поддерживая оригинальный API и формат запросов и ответов.

Базовый URL

Для отправки запросов к OpenRouter используйте базовый путь:

https://api.delirium.ru/openrouter/v1

Модели

Вы можете выбрать любую модель из списка поддерживаемых OpenRouter.

Как считается стоимость

OpenRouter автоматически выбирает наиболее выгодного провайдера для каждой модели:

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

Стоимость запроса зависит от выбранного провайдера и возвращается в ответе в поле usage.cost (оригинальная стоимость в USD). Это работает одинаково для всех типов контента — текста, embeddings, изображений и видео.

Комиссии

Delirium API конвертирует сумму в рубли и добавляет 50% комиссии, которая включает:

• 25% — комиссия OpenRouter и налоги в стране назначения.
• 25% — комиссия Delirium API.

Генерация текста (Chat Completions)

OpenRouter использует API, совместимое с OpenAI Chat Completions, что позволяет работать через стандартные SDK.

Эндпоинт

POST https://api.delirium.ru/openrouter/v1/chat/completions

Пример запроса

curl "https://api.delirium.ru/openrouter/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "mistralai/mistral-medium-3.1",
        "messages": [
            {
                "role": "user",
                "content": "Привет!"
            }
        ]
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openrouter/v1"
)

response = client.chat.completions.create(
    model="mistralai/mistral-medium-3.1",
    messages=[{"role": "user", "content": "Привет!"}]
)

print(response.choices[0].message.content)

const { OpenAI } = require("openai");

const client = new OpenAI({
    apiKey: "<КЛЮЧ>",
    baseURL: "https://api.delirium.ru/openrouter/v1"
});

const response = await client.chat.completions.create({
    model: "mistralai/mistral-medium-3.1",
    messages: [{role: "user", content: "Привет!"}]
});

console.log(response.choices[0].message.content);

Embeddings (векторные представления)

Эндпоинты

POST https://api.delirium.ru/openrouter/v1/embeddings         — создать embedding
GET  https://api.delirium.ru/openrouter/v1/embeddings/models   — список доступных моделей

Пример запроса

curl "https://api.delirium.ru/openrouter/v1/embeddings" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "mistralai/mistral-embed-2312",
        "input": "Привет, мир!"
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openrouter/v1"
)

response = client.embeddings.create(
    model="mistralai/mistral-embed-2312",
    input="Привет, мир!"
)

print(response.data[0].embedding)

const { OpenAI } = require("openai");

const client = new OpenAI({
    apiKey: "<КЛЮЧ>",
    baseURL: "https://api.delirium.ru/openrouter/v1"
});

const response = await client.embeddings.create({
    model: "mistralai/mistral-embed-2312",
    input: "Привет, мир!"
});

console.log(response.data[0].embedding);

Генерация изображений

Генерация изображений работает через стандартный /chat/completions. В тело запроса необходимо добавить параметр modalities:

• ["image"] — для моделей, которые генерируют только изображения (Flux, Sourceful, Seedream и другие)
• ["image", "text"] — для мультимодальных моделей, которые возвращают и текст, и изображение

Полный список поддерживаемых моделей доступен на странице Image Generation Models.

Пример запроса

curl "https://api.delirium.ru/openrouter/v1/chat/completions" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "black-forest-labs/flux.2-klein-4b",
        "modalities": ["image"],
        "messages": [
            {
                "role": "user",
                "content": "Рыжий кот на подоконнике"
            }
        ]
    }'

from openai import OpenAI

client = OpenAI(
    api_key="<КЛЮЧ>",
    base_url="https://api.delirium.ru/openrouter/v1"
)

response = client.chat.completions.create(
    model="black-forest-labs/flux.2-klein-4b",
    extra_body={"modalities": ["image"]},
    messages=[{"role": "user", "content": "Рыжий кот на подоконнике"}]
)

print(response.choices[0].message.images)

const response = await fetch("https://api.delirium.ru/openrouter/v1/chat/completions", {
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        "Authorization": "Bearer <КЛЮЧ>"
    },
    body: JSON.stringify({
        model: "black-forest-labs/flux.2-klein-4b",
        modalities: ["image"],
        messages: [
            {role: "user", content: "Рыжий кот на подоконнике"}
        ]
    })
});

const data = await response.json();
console.log(data.choices[0].message.images);

Формат ответа

Сгенерированные изображения возвращаются в поле choices[0].message.images в виде base64 data URL:

{
  "choices": [{
    "message": {
      "role": "assistant",
      "content": null,
      "images": [
        {
          "type": "image_url",
          "image_url": {
            "url": "data:image/png;base64,iVBORw0KGgo..."
          }
        }
      ]
    }
  }]
}

Генерация видео

Генерация видео работает асинхронно: вы отправляете запрос, получаете идентификатор задачи, а затем опрашиваете статус до завершения.

Доступные модели

Среди популярных моделей для генерации видео:

• Kling v3.0 Pro (kwaivgi/kling-v3.0-pro) — премиальная модель от Kuaishou с высоким качеством, клипы от 3 до 15 секунд с генерацией аудио
• Kling v3.0 Standard (kwaivgi/kling-v3.0-std) — стандартная версия Kling, баланс качества и стоимости
• Seedance 2.0 (bytedance/seedance-2.0) — модель от ByteDance с сильным сохранением стиля и движения камеры
• Wan 2.6 (alibaba/wan-2.6) — модель от Alibaba с поддержкой синхронизации звука и видео до 1080p
• Hailuo 2.3 (minimax/hailuo-2.3) — модель от MiniMax с реалистичной анимацией персонажей

Полный и актуальный список доступен через эндпоинт /openrouter/v1/videos/models.

Эндпоинты

POST   https://api.delirium.ru/openrouter/v1/videos             — создать задачу на генерацию
GET    https://api.delirium.ru/openrouter/v1/videos/{id}         — проверить статус задачи
GET    https://api.delirium.ru/openrouter/v1/videos/{id}/content — скачать готовое видео
GET    https://api.delirium.ru/openrouter/v1/videos/models       — список доступных моделей

Создание задачи

Отправьте POST-запрос с указанием модели и промпта. Параметр duration (длительность в секундах) опционален — по умолчанию 5 секунд.

curl -X POST "https://api.delirium.ru/openrouter/v1/videos" \
    -H "Content-Type: application/json" \
    -H "Authorization: Bearer <КЛЮЧ>" \
    -d '{
        "model": "kwaivgi/kling-v3.0-pro",
        "prompt": "Кинематографичный трекинговый кадр: камера плавно следует за поездом, который мчится по горному мосту на рассвете. Внизу — река в утреннем тумане, лучи солнца пробиваются сквозь облака",
        "duration": 10
    }'

import requests

response = requests.post(
    "https://api.delirium.ru/openrouter/v1/videos",
    headers={
        "Content-Type": "application/json",
        "Authorization": "Bearer <КЛЮЧ>"
    },
    json={
        "model": "kwaivgi/kling-v3.0-pro",
        "prompt": "Кинематографичный трекинговый кадр: камера плавно следует за поездом, который мчится по горному мосту на рассвете. Внизу — река в утреннем тумане, лучи солнца пробиваются сквозь облака",
        "duration": 10
    }
)

print(response.json())

const response = await fetch("https://api.delirium.ru/openrouter/v1/videos", {
    method: "POST",
    headers: {
        "Content-Type": "application/json",
        "Authorization": "Bearer <КЛЮЧ>"
    },
    body: JSON.stringify({
        model: "kwaivgi/kling-v3.0-pro",
        prompt: "Кинематографичный трекинговый кадр: камера плавно следует за поездом, который мчится по горному мосту на рассвете. Внизу — река в утреннем тумане, лучи солнца пробиваются сквозь облака",
        duration: 10
    })
});

const data = await response.json();
console.log(data);

В ответе вы получите идентификатор задачи и URL для опроса статуса:

{
  "id": "job-abc123",
  "status": "pending",
  "polling_url": "https://api.delirium.ru/openrouter/v1/videos/job-abc123"
}

Проверка статуса

Опрашивайте polling_url (или GET /openrouter/v1/videos/{id}) до тех пор, пока status не станет completed или failed. Генерация видео обычно занимает от 30 секунд до нескольких минут в зависимости от модели и длительности.

curl "https://api.delirium.ru/openrouter/v1/videos/job-abc123" \
    -H "Authorization: Bearer <КЛЮЧ>" 

import requests
import time

job_id = "job-abc123"
while True:
    response = requests.get(
        f"https://api.delirium.ru/openrouter/v1/videos/{job_id}",
        headers={"Authorization": "Bearer <КЛЮЧ>"}
    )
    data = response.json()
    if data["status"] in ("completed", "failed"):
        print(data)
        break
    time.sleep(5)

const jobId = "job-abc123";
while (true) {
    const response = await fetch(`https://api.delirium.ru/openrouter/v1/videos/${jobId}`, {
        headers: {"Authorization": "Bearer <КЛЮЧ>"}
    });
    const data = await response.json();
    if (data.status === "completed" || data.status === "failed") {
        console.log(data);
        break;
    }
    await new Promise(r => setTimeout(r, 5000));
}

Скачивание видео

Когда статус задачи completed, скачайте результат:

GET https://api.delirium.ru/openrouter/v1/videos/{id}/content

Как настроить работу Claude Code с Delirium API

Claude Code — это официальный AI-ассистент для разработки от Anthropic, работающий в терминале. Умеет читать и редактировать файлы в вашем проекте, выполнять команды, разбирать стек-трейсы и работать с git. По умолчанию обращается напрямую к API Anthropic, но базовый URL и токен можно переопределить через настройки — этим мы и воспользуемся.

Вариант 1: Anthropic напрямую

Используйте этот вариант, если хотите работать с родными моделями Anthropic (Claude Opus, Sonnet, Haiku).

Создайте файл ~/.claude/settings.json со следующим содержимым:

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "<ваш ключ Delirium API>",
    "ANTHROPIC_BASE_URL": "https://api.delirium.ru/anthropic"
  }
}

Если файл уже существует — добавьте блок env к остальным вашим настройкам.

После сохранения перезапустите claude — все запросы пойдут через Delirium API.

Вариант 2: OpenRouter — любая модель, включая open-source

Через интеграцию с OpenRouter вы можете использовать Claude Code с любой моделью из каталога OpenRouter — не только Anthropic, но и open-source модели. Популярные варианты для разработки:

• Qwen3 Coder (moonshotai/kimi-k2.5) — MoE-модель от Alibaba (480B параметров, 35B активных), оптимизированная для кода и агентных задач
• DeepSeek V4 Flash (deepseek/deepseek-v4-flash) — быстрая MoE-модель (284B параметров, 13B активных), контекст 1M токенов
• DeepSeek V4 Pro (deepseek/deepseek-v4-pro) — флагманская MoE-модель (1.6T параметров, 49B активных), контекст 1M токенов

Настройте ~/.claude/settings.json:

{
  "env": {
    "ANTHROPIC_AUTH_TOKEN": "<ваш ключ Delirium API>",
    "ANTHROPIC_BASE_URL": "https://api.delirium.ru/openrouter",
    "ANTHROPIC_DEFAULT_OPUS_MODEL": "moonshotai/kimi-k2.5",
    "ANTHROPIC_DEFAULT_SONNET_MODEL": "moonshotai/kimi-k2.5",
    "ANTHROPIC_DEFAULT_HAIKU_MODEL": "deepseek/deepseek-v4-flash",
    "CLAUDE_CODE_SUBAGENT_MODEL": "moonshotai/kimi-k2.5"
  }
}

Переменные ANTHROPIC_DEFAULT_*_MODEL переопределяют модели для каждого слота Claude Code (Opus, Sonnet, Haiku), а CLAUDE_CODE_SUBAGENT_MODEL — модель для подагентов. Идентификаторы моделей берутся из каталога OpenRouter.

Как настроить работу Codex с Delirium API

Codex — это AI-ассистент для разработки от OpenAI, доступный как утилита для терминала (Codex CLI) и как десктопное приложение. Обе версии используют один и тот же файл конфигурации, поэтому достаточно настроить его один раз.

Настройка

Откройте (или создайте) файл ~/.codex/config.toml и добавьте в него:

model_provider = "delirium"
model = "gpt-5.1-codex"

[model_providers.delirium]
name = "Delirium API"
base_url = "https://api.delirium.ru/openai/v1"
api_key = "<ваш ключ Delirium API>"
wire_api = "responses"
supports_websockets = false

Поле model задаёт модель, которая будет использоваться по умолчанию — поменяйте на любую другую из доступных в OpenAI через Delirium API.

После сохранения файла Codex CLI и десктопное приложение начнут отправлять запросы через Delirium API.

Как настроить работу Gemini CLI с Delirium API

Gemini CLI — это официальный AI-ассистент для разработки от Google, работающий в терминале и использующий модели Gemini. Базовый URL и ключ задаются исключительно через переменные окружения — отдельного файла настроек для этого нет.

Настройка

Добавьте в ~/.zshrc (или ~/.bashrc, в зависимости от вашей оболочки):

export GEMINI_API_KEY="<ваш ключ Delirium API>"
export GOOGLE_GEMINI_BASE_URL="https://api.delirium.ru/google"

После этого перезапустите терминал (или выполните source ~/.zshrc) и запускайте gemini — запросы будут идти через Delirium API.

Как настроить работу Cursor с Delirium API

Cursor — это AI-редактор кода с глубокой интеграцией LLM в рабочий процесс: автодополнение, чат, агентский режим Composer и др. Cursor поддерживает подключение собственных API-ключей (BYOK) — этой возможностью мы и воспользуемся, чтобы направить запросы через Delirium API.

Ограничения

Перед настройкой стоит знать о двух нюансах:

• BYOK работает только в платных тарифах Cursor (Pro и выше).
• Через свой ключ обслуживаются только Ask и Chat. Tab-автодополнение, Apply и Composer продолжают работать через инфраструктуру Cursor — туда ваш ключ не попадает.
• Брендированные модели OpenAI/Anthropic/Gemini в режиме BYOK работают нестабильно. Поэтому удобнее всего подключить через Delirium API gateway OpenRouter и пользоваться открытыми моделями.

Настройка

Откройте Cursor Settings → Models → API Keys и:

1. Включите тумблер OpenAI API Key и вставьте ваш ключ Delirium API.
2. Включите тумблер Override OpenAI Base URL и укажите https://api.delirium.ru/openrouter/v1.

Затем в разделе Add or search model добавьте нужные модели в формате provider/model, например:

• moonshotai/kimi-k2
• moonshotai/kimi-k2.5
• deepseek/deepseek-v3.2

После этого выбранные модели появятся в списке доступных, и чат Cursor начнёт работать через Delirium API.

Как настроить работу Cline с Delirium API

Cline — это open-source AI-ассистент для разработки в виде расширения для VS Code. Умеет читать и редактировать файлы, выполнять команды в терминале, разбираться в структуре проекта и работать в агентском режиме. Поддерживает большое число провайдеров моделей с возможностью подключения собственных ключей.

Настройка

В Cline Settings → API Provider для каждого нужного провайдера:

1. Выберите провайдера в выпадающем списке.
2. Вставьте ваш ключ Delirium API в поле API Key.
3. Укажите соответствующий Base URL из таблицы ниже (для нативных Anthropic и Gemini — в поле под галочкой Use custom base URL; для OpenAI и OpenRouter поле появляется только в режиме OpenAI Compatible).

Для режимов OpenAI Compatible название модели (например, gpt-5.1-codex или deepseek/deepseek-v3.2) указывается вручную в поле Model ID.

Режим Claude Code

Если вы пользуетесь режимом Claude Code в Cline — отдельной настройки в самом Cline не требуется. Сначала настройте Claude Code по инструкции, затем активируйте Claude Code mode в настройках Cline — он подхватит конфигурацию автоматически.

Как настроить работу Roo Code с Delirium API

Roo Code — это open-source AI-ассистент для VS Code со специализированными режимами (Code, Architect, Debug, Ask, Test и др.). Поддерживает множество провайдеров моделей, и для встроенных OpenAI, Anthropic, Google и OpenRouter в настройках есть поле кастомного базового URL — это позволяет подключить каждого провайдера через Delirium API напрямую, без OpenAI-совместимой прослойки.

Настройка

В Roo Code Settings → API Provider для каждого нужного провайдера:

1. Выберите соответствующего провайдера в выпадающем списке.
2. Вставьте ваш ключ Delirium API в поле API Key.
3. Поставьте галочку Use custom base URL и укажите соответствующий адрес из таблицы ниже.

Если хотите параллельно использовать несколько провайдеров, создайте под каждый отдельный профиль (поле Configuration Profile в верхней части настроек) — между ними можно быстро переключаться.

Как настроить работу OpenCode с Delirium API

OpenCode — это open-source AI-ассистент для разработки, аналог Claude Code и Codex CLI. Доступен как утилита для терминала, десктопное приложение и расширение для IDE. Поддерживает работу с большим числом провайдеров моделей (OpenAI, Anthropic, Google, OpenRouter и другие), каждому из которых можно задать собственный ключ и базовый URL.

Настройка

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

1. Конфигурационный файл

Создайте файл ~/.config/opencode/opencode.json и пропишите для нужных провайдеров переопределение baseURL на адреса Delirium API:

{
  "$schema": "https://opencode.ai/config.json",
  "provider": {
    "openai":     { "options": { "baseURL": "https://api.delirium.ru/openai/v1" } },
    "anthropic":  { "options": { "baseURL": "https://api.delirium.ru/anthropic/v1" } },
    "google":     { "options": { "baseURL": "https://api.delirium.ru/google/v1beta" } },
    "openrouter": { "options": { "baseURL": "https://api.delirium.ru/openrouter/v1" } }
  }
}

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

2. Подключение ключа

Запустите opencode и выполните слэш-команду /connect. Откроется список провайдеров — выберите нужный (например, OpenAI).

Дальше opencode спросит способ авторизации — выберите Manually enter API Key и вставьте ваш ключ Delirium API.

Повторите шаг /connect для каждого провайдера, который вы прописали в конфиге. В качестве ключа везде используется один и тот же ключ Delirium API — отдельные ключи провайдеров не нужны.

После этого можно сразу выбирать модель и начинать работу — opencode будет отправлять все запросы через Delirium API.

Как настроить работу Kilo Code с Delirium API

Kilo Code — это open-source AI-ассистент для разработки в виде расширения для VS Code и JetBrains. Поддерживает разные режимы работы (Code, Architect, Debug и др.) и подключение собственных ключей к большому числу провайдеров моделей.

Встроенные провайдеры Anthropic и Google в Kilo Code не позволяют переопределить базовый URL, поэтому подключение к Delirium API делается через универсальный OpenAI-совместимый эндпоинт Delirium API — за ним доступны все провайдеры сразу.

Настройка

1. Подключите кастомного провайдера

Откройте Settings → Providers, прокрутите список до конца и нажмите Connect напротив Custom provider.

Заполните поля:

2. Добавьте модели

Перейдите в раздел Models и добавьте нужные модели в формате provider/model. Если модель поддерживает reasoning (это касается всех современных моделей) — поставьте галочку Reasoning.

Примеры идентификаторов:

• openai/gpt-5.1-codex
• anthropic/claude-sonnet-4-5
• gemini/gemini-3.1-pro-preview
• openrouter/moonshotai/kimi-k2.5

После сохранения модели появятся в общем списке выбора, и Kilo Code начнёт работать через Delirium API.

Как настроить работу Open CoDesign с Delirium API

Open CoDesign — это open-source десктопное приложение для дизайн-задач с AI-агентом внутри. Поддерживает три способа общения с моделями (wire-протокола): OpenAI Chat, OpenAI Responses и Anthropic Messages — для каждого из них можно указать собственный базовый URL, что и позволяет подключить Delirium API.

Настройка

В Settings → Add custom endpoint заведите по одному endpoint на каждого нужного провайдера.

OpenAI

Anthropic

После сохранения добавленные endpoint'ы появятся в общем списке доступных моделей в Open CoDesign.

Как настроить работу Claude Desktop с Delirium API

Claude Desktop — это десктопное приложение от Anthropic для общения с моделями Claude. По умолчанию работает через подписку Anthropic, но в нём есть режим «Gateway», позволяющий направить весь трафик в любой Anthropic-совместимый шлюз — например, в Delirium API.

Настройка

1. Включите режим разработчика

Возможность подключить внешний gateway скрыта за режимом разработчика. Откройте меню Help → Troubleshooting → Enable Developer Mode.

2. Настройте Gateway

После включения режима разработчика в меню появится пункт Developer → Configure Third-Party Inference…. Откройте его и в разделе Connection выберите Gateway (Anthropic-compatible), затем заполните поля:

Сохраните настройки, полностью закройте Claude Desktop и запустите его заново. На стартовом экране выберите Continue with Gateway — приложение начнёт работать через Delirium API.

Как настроить работу Open WebUI с Delirium API

Open WebUI — это open-source self-hosted веб-интерфейс для работы с LLM. Подключается к моделям через Ollama и любые OpenAI-совместимые эндпоинты. Отдельных типов подключения для Anthropic и Google в Open WebUI нет, но это не проблема: можно использовать один OpenAI-коннект, направленный на универсальный OpenAI-совместимый эндпоинт Delirium API — за ним сразу доступны модели всех провайдеров.

Настройка

Откройте Admin Panel → Settings → Connections и добавьте новое подключение типа OpenAI API:

В разделе Model IDs добавьте нужные модели в формате provider/model, например:

• openai/gpt-5.1-codex
• anthropic/claude-sonnet-4-5
• gemini/gemini-2.5-flash

Сохраните подключение — добавленные модели появятся в общем списке выбора в Open WebUI.

Как настроить работу n8n с Delirium API

n8n — это open-source платформа для автоматизации и построения визуальных workflow'ов с большим количеством готовых интеграций, включая узлы для работы с LLM (OpenAI, Anthropic, Google Gemini и др.). У каждой из этих учётных записей есть поле кастомного базового URL — это позволяет подключить их к Delirium API без дополнительных прослоек.

Ограничения

OpenRouter в n8n подключить к Delirium API не получится: у его credential нет поля для переопределения базового URL, и в качестве OpenAI-совместимой замены он тоже не предусмотрен.

Настройка

Создайте отдельный credential для каждого нужного провайдера. В каждом из них:

1. В поле API Key вставьте ваш ключ Delirium API.
2. В поле Base URL укажите соответствующий адрес из таблицы ниже.

После сохранения credential можно использовать в любых workflow-узлах соответствующего провайдера — все запросы пойдут через Delirium API.

Как настроить работу OpenClaw (ClawdBot) с Delirium API

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

В начале 2026 года проект стал вирусным в IT-сообществе: его репозиторий на GitHub за считанные дни собрал более 100 000 звёзд — рекордный темп для open-source AI-агентов. OpenClaw привлёк внимание благодаря возможности локального запуска и выполнения сложных автоматизированных задач.

Для установки и базовой настройки OpenClaw обратитесь к официальной документации. В этой статье мы сосредоточимся только на интеграции с Delirium API.

Почему нативные API, а не OpenAI-совместимый?

OpenClaw поддерживает различные способы подключения к языковым моделям. Мы рекомендуем использовать нативные API провайдеров (OpenAI, Anthropic, Google) вместо единого OpenAI-совместимого интерфейса по нескольким причинам:

• Полная поддержка возможностей — OpenAI-совместимый режим стремится угодить всем провайдерам и часто обрубает специфические возможности отдельных моделей
• Совместимость параметров — OpenClaw иногда отправляет параметры, допустимые в одном провайдере, но недопустимые в другом. Разграничение API помогает избежать ошибок
• Стабильность работы — нативные API обеспечивают более предсказуемое поведение

Настройка

При установке OpenClaw полностью пропустите шаг с выбором моделей и провайдеров. После запуска:

1. Перейдите в раздел Config
2. Переключитесь в режим Raw для работы с конфигурацией в JSON-формате
3. Добавьте конфигурацию для нужных вам моделей

OpenAI

Для работы с моделями OpenAI (GPT-5 и другие) добавьте следующую конфигурацию:

{
  "models": {
    "mode": "merge",
    "providers": {
      "delirium-openai": {
        "baseUrl": "https://api.delirium.ru/openai/v1",
        "apiKey": "<ваш ключ Delirium API>",
        "api": "openai-responses",
        "models": [
          {
            "id": "gpt-5.1-codex",
            "name": "GPT 5.1 Codex",
            "reasoning": true,
            "input": ["text", "image"]
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "delirium-openai/gpt-5.1-codex"
      }
    }
  }
}

Anthropic (Claude)

Для работы с моделями Claude:

{
  "models": {
    "mode": "merge",
    "providers": {
      "delirium-anthropic": {
        "baseUrl": "https://api.delirium.ru/anthropic",
        "apiKey": "<ваш ключ Delirium API>",
        "api": "anthropic-messages",
        "models": [
          {
            "id": "claude-sonnet-4-5",
            "name": "Claude Sonnet 4.5",
            "reasoning": true,
            "input": ["text", "image"]
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "delirium-anthropic/claude-sonnet-4-5"
      }
    }
  }
}

Google (Gemini)

Для работы с моделями Gemini:

{
  "models": {
    "mode": "merge",
    "providers": {
      "delirium-google": {
        "baseUrl": "https://api.delirium.ru/google/v1beta",
        "apiKey": "<ваш ключ Delirium API>",
        "api": "google-generative-ai",
        "models": [
          {
            "id": "gemini-2.5-flash",
            "name": "Gemini 2.5 Flash",
            "reasoning": true,
            "input": ["text", "image"]
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "delirium-google/gemini-2.5-flash"
      }
    }
  }
}

OpenRouter

Через Delirium API вы также можете получить доступ к множеству моделей через OpenRouter, включая DeepSeek, Qwen, Kimi и другие:

{
  "models": {
    "mode": "merge",
    "providers": {
      "delirium-openrouter": {
        "baseUrl": "https://api.delirium.ru/openrouter/v1",
        "apiKey": "<ваш ключ Delirium API>",
        "api": "openai-completions",
        "models": [
          {
            "id": "moonshotai/kimi-k2.5",
            "name": "Kimi K2.5",
            "reasoning": true,
            "input": ["text", "image"]
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "delirium-openrouter/moonshotai/kimi-k2.5"
      }
    }
  }
}

Комбинирование нескольких провайдеров

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

{
  "models": {
    "mode": "merge",
    "providers": {
      "delirium-anthropic": {
        "baseUrl": "https://api.delirium.ru/anthropic",
        "apiKey": "<ваш ключ Delirium API>",
        "api": "anthropic-messages",
        "models": [
          {
            "id": "claude-sonnet-4-5",
            "name": "Claude Sonnet 4.5",
            "reasoning": true,
            "input": ["text", "image"]
          }
        ]
      },
      "delirium-openrouter": {
        "baseUrl": "https://api.delirium.ru/openrouter/v1",
        "apiKey": "<ваш ключ Delirium API>",
        "api": "openai-completions",
        "models": [
          {
            "id": "moonshotai/kimi-k2.5",
            "name": "Kimi K2.5",
            "reasoning": true,
            "input": ["text", "image"]
          }
        ]
      }
    }
  },
  "agents": {
    "defaults": {
      "model": {
        "primary": "delirium-anthropic/claude-sonnet-4-5"
      }
    }
  }
}

В этом случае основной моделью по умолчанию будет Claude Sonnet 4.5, но вы сможете переключаться на любую другую настроенную модель через интерфейс OpenClaw.

Не забудьте заменить <ваш ключ Delirium API> на ваш реальный API-ключ Delirium API во всех конфигурациях!