--- title: Управление размышлениями url: https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost description: Управляйте тем, как часто и насколько глубоко Claude думает, с помощью уровней усилия, указаний в системной подсказке и управления на уровне отдельных сообщений, а также разберитесь в стоимости и ценообразовании размышлений. --- Чтобы узнать, как «zero data retention» (нулевое хранение данных), или ZDR, применяется к этой функции, см. раздел [API и хранение данных](https://platform.claude.com/docs/ru/manage-claude/api-and-data-retention). «Thinking» (размышления) Claude адаптивны: модель оценивает каждый запрос и определяет, нужно ли размышлять и насколько. Вы задаёте намерение, при необходимости указываете «effort» (усилие), а модель распределяет рассуждения там, где, по её оценке, они помогут. Это делает размышления отличным выбором для рабочих нагрузок, в которых смешаны тривиальные и сложные запросы, а также для долгосрочных агентных рабочих процессов, где нужный объём рассуждений меняется от шага к шагу. Чтобы узнать, как включить размышления, как читать вывод размышлений, а также о [выводе размышлений в Claude Fable 5 и Claude Mythos 5](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-output-on-claude-fable-5-and-claude-mythos-5), см. обзор [Размышления](https://platform.claude.com/docs/ru/build-with-claude/thinking). На этой странице рассматривается, как Claude определяет, когда размышлять, как управлять размышлениями, а также вытекающие из этого механизмы кэширования, стоимости и ценообразования. ## Как Claude определяет, когда размышлять Размышления для модели необязательны. При каждом запросе Claude оценивает сложность входных данных и определяет, улучшит ли ответ более глубокое рассуждение. Простой фактический вопрос может получить прямой ответ вообще без блока размышлений; многошаговая математическая задача или сложная задача отладки запускает более глубокое рассуждение. Решение принимается для каждого запроса отдельно. Один и тот же разговор может содержать ходы с размышлениями и без них, и ход, в котором Claude решил не думать, не содержит блока размышлений. Не стройте логику приложения, предполагающую, что каждый ход ассистента начинается с такого блока. Основной элемент управления этим решением — параметр [effort](https://platform.claude.com/docs/ru/build-with-claude/effort) (усилие), который действует как мягкое указание на то, насколько охотно Claude должен думать и насколько глубоко; см. раздел [Уровни усилия](https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost#effort-levels) на этой странице, чтобы узнать, что делает каждый уровень. Если вы хотите, чтобы Claude думал реже, понизьте уровень усилия, прежде чем прибегать к управлению через подсказки. Размышления также автоматически чередуются с «tool use» (использованием инструментов): Claude может размышлять между вызовами инструментов, анализируя каждый результат инструмента, прежде чем определить дальнейшие действия ([чередующиеся размышления](https://platform.claude.com/docs/ru/build-with-claude/thinking#interleaved-thinking)). Для этого не нужен бета-заголовок или какая-либо дополнительная настройка. Полную картину того, как взаимодействуют конфигурация размышлений и параметр effort, см. в разделе [Размышления и усилие](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-and-effort). ## Управление тем, как часто Claude думает То, думает ли Claude на данном ходе, поддаётся управлению через подсказки. Усилие задаёт общую установку, но вы также можете формировать решение напрямую с помощью указаний на естественном языке — либо глобально в «system prompt» (системной подсказке), либо для отдельного сообщения из хода пользователя. Используйте оба рычага вместе в таком порядке: 1. Установите уровень усилия, соответствующий стандартному балансу качества и задержки для вашей рабочей нагрузки. 2. Добавляйте указания в подсказке только в том случае, если срабатывание размышлений Claude на этом уровне всё ещё не соответствует вашим потребностям. Чтобы уменьшить объём размышлений в Claude Sonnet 5.5 и Claude Haiku 5.5, понизьте уровень усилий. Просьба в системной подсказке к Claude Sonnet 5.5 размышлять меньше не всегда надёжно сокращает его размышления, а в тестах Anthropic указание Claude Haiku 5.5 в подсказке отвечать напрямую не останавливало его размышления. См. [Подсказки для Claude Sonnet 5.5](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-sonnet-5-5#calibrate-effort) и [Составление подсказок для Claude Haiku 5.5](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/prompting-claude-haiku-5-5#use-effort-to-control-thinking). Более общие рекомендации по составлению подсказок с размышлениями см. в разделе [использование возможностей размышлений и чередующихся размышлений](https://platform.claude.com/docs/ru/build-with-claude/prompt-engineering/claude-prompting-best-practices#leverage-thinking-and-interleaved-thinking-capabilities). ### Уровни усилия Уровень усилий — основной рычаг управления размышлениями. Каждый уровень задаёт своё поведение по умолчанию в отношении того, как часто и насколько глубоко думает Claude: | Уровень усилия | Поведение размышлений | | -------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------- | | `max` | Claude думает наиболее охотно и с наибольшей глубиной, без ограничений на длину размышлений. | | `xhigh` | Claude думает охотнее и глубже, чем на уровне `high`; подходит для развёрнутого исследования. | | `high` (по умолчанию на большинстве моделей) | Claude думает в большинстве запросов, где это полезно. Обеспечивает глубокое рассуждение в сложных задачах. | | `medium` (по умолчанию для Claude Opus 5.5 и Claude Haiku 5.5) | Claude использует умеренные размышления. Может пропускать размышления для простых запросов. | | `low` | Claude сводит размышления к минимуму. Пропускает размышления для простых задач, где важнее всего скорость. | На каждом уровне Claude определяет для каждого запроса, размышлять ли. В цикле использования инструментов первый запрос после нового ввода пользователя обычно содержит основную часть рассуждений, а последующие запросы, которые лишь обрабатывают результаты инструментов, могут пропускать размышления, в том числе на уровнях `xhigh` и `max`. Объём размышлений на запрос также имеет тенденцию уменьшаться по мере удлинения разговора. Ни один уровень не гарантирует наличие блока размышлений в каждом запросе. В этой таблице описано, как каждый уровень меняет поведение размышлений. Рекомендации по выбору уровня для конкретной рабочей нагрузки, включая рекомендации для отдельных моделей, см. в разделе [Когда настраивать параметр effort](https://platform.claude.com/docs/ru/build-with-claude/effort#when-to-adjust-the-effort-parameter) на странице об уровне усилий. Уровень усилий задаётся в `output_config.effort`, а не внутри объекта `thinking`; полные примеры для каждого языка см. на странице [Усилие](https://platform.claude.com/docs/ru/build-with-claude/effort#basic-usage). ```json { "model": "claude-opus-5-5", "max_tokens": 4096, "output_config": { "effort": "medium" }, "messages": [{ "role": "user", "content": "..." }] } ``` Доступность уровней зависит от модели; какие уровни поддерживает каждая модель, определяет [таблица доступности уровней усилий](https://platform.claude.com/docs/ru/build-with-claude/effort#effort-levels) на странице об уровне усилий. ### Указания в системной подсказке Указания в системной подсказке смещают порог размышлений Claude для каждого запроса в разговоре. Если Claude думает чаще, чем нужно вашей рабочей нагрузке, добавьте в системную подсказку указание вроде этого: ```text wrap Extended thinking adds latency and should only be used when it will meaningfully improve answer quality, typically for problems that require multistep reasoning. When in doubt, respond directly. ``` Чтобы, наоборот, поощрять размышления, используйте фразу вроде: ```text wrap This task involves multistep reasoning. Think carefully before responding. ``` Эффективность управления может быть чувствительна к точной формулировке. Если одна формулировка не даёт желаемого поведения, попробуйте более прямой вариант. ### Управление на уровне отдельных сообщений Вы также можете управлять размышлениями для каждого сообщения отдельно из хода пользователя, независимо от системной подсказки. Добавление `"Please think hard before responding."` к сообщению пользователя побуждает Claude размышлять на этом ходе; `"Answer directly without deliberating."` сдерживает размышления. Управление на уровне отдельных сообщений полезно, когда развёрнутое рассуждение требуется лишь для некоторых запросов в диалоге. Например, агентная обвязка может добавлять поощряющую фразу на шагах планирования и сдерживающую фразу при рутинных подтверждениях, не затрагивая системную подсказку и не меняя параметры запроса между ходами. В Claude Haiku 5.5 сдерживающая фраза не всегда надёжно сокращает размышления. В Claude API и Google Cloud выполняйте рутинные ходы на этой модели с меньшим объёмом размышлений, используя вместо этого [изменение уровня усилий для отдельного сообщения](https://platform.claude.com/docs/ru/build-with-claude/effort#change-effort-mid-conversation-beta) (бета), что также сохраняет кэш подсказок. ### Проверьте управление на своей рабочей нагрузке Управление через подсказки меняет поведение модели, поэтому относитесь к нему как к любому другому изменению подсказки: измеряйте перед выпуском. Прогоните репрезентативную выборку вашего трафика с указаниями и без них и сравните, как часто срабатывают размышления (наличие блоков размышлений в ответах), использование выходных токенов, задержку и качество ответов в важных для вас случаях. Управление Claude так, чтобы он думал реже, может снизить качество в задачах, которые выигрывают от рассуждений. Понижение уровня [effort](https://platform.claude.com/docs/ru/build-with-claude/effort) обычно является лучшим первым рычагом, поскольку это откалиброванный элемент управления, а не чувствительная к формулировке инструкция. Измерьте влияние на ваши конкретные рабочие нагрузки, прежде чем развёртывать настройку через подсказки в продакшене. ## Механика Из того, что Claude сам управляет своими размышлениями, следуют три механики: валидация ходов, кэширование подсказок и способ ограничения стоимости. ### Валидация ходов Ходы ассистента не обязаны начинаться с блока размышлений. (Модели, использующие устаревший ручной бюджет размышлений, требуют, чтобы последний ход ассистента в запросе с включёнными размышлениями начинался с такого блока; см. [Структура ходов в ручном режиме](https://platform.claude.com/docs/ru/build-with-claude/extended-thinking#turn-structure-in-manual-mode).) Для многоходовых приложений это означает, что вы можете передавать историю разговора обратно в том виде, в каком она у вас есть: * Ходы ассистента, в которых Claude решил не думать, являются допустимой историей как есть. * Вы можете возобновить разговор, который начался без размышлений или использовал другую конфигурацию размышлений, не переписывая его историю. * В историю, собранную из смешанных источников, не нужно заново вставлять блоки размышлений в начало каждого хода ассистента, чтобы она прошла валидацию. Это ослабление касается валидации, а не того, что вам следует отправлять. Когда у вас есть блоки размышлений, передавайте их обратно без изменений, особенно при использовании инструментов, где они несут рассуждения, стоящие за вызовами инструментов Claude. Полные правила см. в обзоре [Размышления](https://platform.claude.com/docs/ru/build-with-claude/thinking). ### Кэширование подсказок Если последовательные запросы используют одну и ту же конфигурацию размышлений и один и тот же уровень усилий, кэширование подсказок продолжает работать; полные правила см. в разделе [Размышления и кэширование подсказок](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-and-prompt-caching). Итоговое значение уровня усилий встраивается в подсказку, поэтому его изменение между запросами делает недействительными «cache breakpoints» (точки останова кэша) — так же, как изменение устаревшего параметра [`budget_tokens`](https://platform.claude.com/docs/ru/build-with-claude/extended-thinking#extended-thinking-with-prompt-caching) в моделях, которые его используют. Явная установка `effort` в значение по умолчанию для модели равносильна его отсутствию и не нарушает кэш. Практическое следствие: выберите конфигурацию размышлений и уровень усилий верхнего уровня для каждого диалога и придерживайтесь их. Если некоторым ходам нужно больше или меньше размышлений, используйте [изменение уровня усилий для отдельного сообщения](https://platform.claude.com/docs/ru/build-with-claude/effort#change-effort-mid-conversation-beta) (бета) в моделях, которые его поддерживают, или управляйте размышлениями с помощью [подсказок на уровне отдельных сообщений](https://platform.claude.com/docs/ru/build-with-claude/thinking-steering-and-cost#tuning-thinking-behavior). Оба способа сохраняют более ранние точки останова кэша, тогда как изменение конфигурации размышлений или уровня усилий верхнего уровня — нет. Следующий пример демонстрирует инвалидацию кэша с помощью многоходового скрипта, который вы можете запустить самостоятельно: Этот рабочий процесс плохо укладывается в разовую команду оболочки. Многоходовый шаблон см. на вкладках SDK; HTTP-запросы для каждого хода строятся по примерам на странице [Кэширование подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching). Этот рабочий процесс плохо укладывается в разовую команду оболочки. Многоходовый шаблон см. на вкладках SDK; вызовы CLI для каждого хода строятся по примерам на странице [Кэширование подсказок](https://platform.claude.com/docs/ru/build-with-claude/prompt-caching). ```python import requests client = Anthropic() def fetch_article_content(url): text = requests.get(url).text lines = (line.strip() for line in text.splitlines()) return "\n".join(line for line in lines if line) # Получаем содержимое статьи book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt" book_content = fetch_article_content(book_url) # Берём ровно столько текста, сколько нужно для кэширования (первые несколько глав) LARGE_TEXT = book_content[:10000] # Без системной подсказки — вместо этого кэширование в сообщениях MESSAGES = [ { "role": "user", "content": [ { "type": "text", "text": LARGE_TEXT, "cache_control": {"type": "ephemeral"}, }, {"type": "text", "text": "Analyze the tone of this passage."}, ], } ] # Первый запрос — создаём кэш print("First request - establishing cache") response1 = client.messages.create( model="claude-opus-5-5", max_tokens=16000, thinking={"type": "adaptive"}, messages=MESSAGES, ) print(f"First response usage: {response1.usage}") MESSAGES.append({"role": "assistant", "content": response1.content}) MESSAGES.append({"role": "user", "content": "Analyze the characters in this passage."}) # Второй запрос — та же конфигурация (ожидается попадание в кэш) print("\nSecond request - same configuration (cache hit expected)") response2 = client.messages.create( model="claude-opus-5-5", max_tokens=16000, thinking={"type": "adaptive"}, messages=MESSAGES, ) print(f"Second response usage: {response2.usage}") MESSAGES.append({"role": "assistant", "content": response2.content}) MESSAGES.append({"role": "user", "content": "Analyze the setting in this passage."}) # Третий запрос — другой уровень effort (ожидается промах кэша) print("\nThird request - different effort level (cache miss expected)") response3 = client.messages.create( model="claude-opus-5-5", max_tokens=16000, thinking={"type": "adaptive"}, output_config={"effort": "low"}, messages=MESSAGES, ) print(f"Third response usage: {response3.usage}") ``` ```typescript const client = new Anthropic(); async function fetchArticleContent(url: string): Promise { const response = await fetch(url); const text = await response.text(); const lines = text.split("\n").map((line) => line.trim()); return lines.filter((line) => line).join("\n"); } const bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"; const bookContent = await fetchArticleContent(bookUrl); const LARGE_TEXT = bookContent.substring(0, 10000); // Без системной подсказки — вместо этого кэширование в сообщениях const messages: Anthropic.MessageParam[] = [ { role: "user", content: [ { type: "text", text: LARGE_TEXT, cache_control: { type: "ephemeral" } }, { type: "text", text: "Analyze the tone of this passage." } ] } ]; // Первый запрос — создание кэша console.log("First request - establishing cache"); const response1 = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive" }, messages }); console.log("First response usage: ", response1.usage); messages.push( { role: "assistant", content: response1.content }, { role: "user", content: "Analyze the characters in this passage." } ); // Второй запрос — та же конфигурация (ожидается попадание в кэш) console.log("\nSecond request - same configuration (cache hit expected)"); const response2 = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive" }, messages }); console.log("Second response usage: ", response2.usage); messages.push( { role: "assistant", content: response2.content }, { role: "user", content: "Analyze the setting in this passage." } ); // Третий запрос — другой уровень effort (ожидается промах кэша) console.log("\nThird request - different effort level (cache miss expected)"); const response3 = await client.messages.create({ model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive" }, output_config: { effort: "low" }, messages }); console.log("Third response usage: ", response3.usage); ``` ```csharp AnthropicClient client = new(); string bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"; string bookContent = await FetchArticleContent(bookUrl); string largeText = bookContent.Substring(0, Math.Min(10000, bookContent.Length)); Console.WriteLine("First request - establishing cache"); var parameters1 = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 16000, Thinking = new ThinkingConfigAdaptive(), Messages = [ new() { Role = Role.User, Content = new MessageParamContent(new List { new ContentBlockParam(new TextBlockParam() { Text = largeText, CacheControl = new CacheControlEphemeral(), }), new ContentBlockParam(new TextBlockParam() { Text = "Analyze the tone of this passage." }), }) } ] }; var response1 = await client.Messages.Create(parameters1); Console.WriteLine($"First response usage: {response1.Usage}"); Console.WriteLine("\nSecond request - same configuration (cache hit expected)"); var parameters2 = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 16000, Thinking = new ThinkingConfigAdaptive(), Messages = [ new() { Role = Role.User, Content = new MessageParamContent(new List { new ContentBlockParam(new TextBlockParam() { Text = largeText, CacheControl = new CacheControlEphemeral(), }), new ContentBlockParam(new TextBlockParam() { Text = "Analyze the tone of this passage." }), }) }, new() { Role = Role.Assistant, Content = response1.Content.Select(block => new ContentBlockParam(block.Json)).ToList() }, new() { Role = Role.User, Content = "Analyze the characters in this passage." } ] }; var response2 = await client.Messages.Create(parameters2); Console.WriteLine($"Second response usage: {response2.Usage}"); Console.WriteLine("\nThird request - different effort level (cache miss expected)"); var parameters3 = new MessageCreateParams { Model = Model.ClaudeOpus5_5, MaxTokens = 16000, Thinking = new ThinkingConfigAdaptive(), OutputConfig = new OutputConfig { Effort = Effort.Low }, Messages = [ new() { Role = Role.User, Content = new MessageParamContent(new List { new ContentBlockParam(new TextBlockParam() { Text = largeText, CacheControl = new CacheControlEphemeral(), }), new ContentBlockParam(new TextBlockParam() { Text = "Analyze the tone of this passage." }), }) }, new() { Role = Role.Assistant, Content = response1.Content.Select(block => new ContentBlockParam(block.Json)).ToList() }, new() { Role = Role.User, Content = "Analyze the characters in this passage." }, new() { Role = Role.Assistant, Content = response2.Content.Select(block => new ContentBlockParam(block.Json)).ToList() }, new() { Role = Role.User, Content = "Analyze the setting in this passage." } ] }; var response3 = await client.Messages.Create(parameters3); Console.WriteLine($"Third response usage: {response3.Usage}"); static async Task FetchArticleContent(string url) { using HttpClient httpClient = new(); string content = await httpClient.GetStringAsync(url); return content; } ``` ```go client := anthropic.NewClient() bookURL := "https://www.gutenberg.org/cache/epub/1342/pg1342.txt" bookContent, err := fetchArticleContent(bookURL) if err != nil { log.Fatal(err) } largeText := bookContent if len(largeText) > 10000 { largeText = largeText[:10000] } // Без системной подсказки — вместо этого кэширование в сообщениях messages := []anthropic.MessageParam{ anthropic.NewUserMessage( anthropic.ContentBlockParamUnion{OfText: &anthropic.TextBlockParam{ Text: largeText, CacheControl: anthropic.NewCacheControlEphemeralParam(), }}, anthropic.NewTextBlock("Analyze the tone of this passage."), ), } // Первый запрос — создание кэша fmt.Println("First request - establishing cache") response1, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 16000, Thinking: anthropic.ThinkingConfigParamUnion{ OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{}, }, Messages: messages, }) if err != nil { log.Fatal(err) } fmt.Printf("First response usage: %s\n", response1.Usage.RawJSON()) messages = append(messages, response1.ToParam()) messages = append(messages, anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the characters in this passage."))) // Второй запрос — та же конфигурация (ожидается попадание в кэш) fmt.Println("\nSecond request - same configuration (cache hit expected)") response2, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 16000, Thinking: anthropic.ThinkingConfigParamUnion{ OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{}, }, Messages: messages, }) if err != nil { log.Fatal(err) } fmt.Printf("Second response usage: %s\n", response2.Usage.RawJSON()) messages = append(messages, response2.ToParam()) messages = append(messages, anthropic.NewUserMessage(anthropic.NewTextBlock("Analyze the setting in this passage."))) // Третий запрос — другой уровень effort (ожидается промах кэша) fmt.Println("\nThird request - different effort level (cache miss expected)") response3, err := client.Messages.New(context.TODO(), anthropic.MessageNewParams{ Model: anthropic.ModelClaudeOpus5_5, MaxTokens: 16000, Thinking: anthropic.ThinkingConfigParamUnion{ OfAdaptive: &anthropic.ThinkingConfigAdaptiveParam{}, }, OutputConfig: anthropic.OutputConfigParam{ Effort: anthropic.OutputConfigEffortLow, }, Messages: messages, }) if err != nil { log.Fatal(err) } fmt.Printf("Third response usage: %s\n", response3.Usage.RawJSON()) ``` ```java import com.anthropic.models.messages.CacheControlEphemeral; // ... void main() throws Exception { AnthropicClient client = AnthropicOkHttpClient.fromEnv(); String bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"; String bookContent = fetchArticleContent(bookUrl); String largeText = bookContent.substring(0, Math.min(10000, bookContent.length())); // Первый запрос — создание кэша IO.println("First request - establishing cache"); MessageCreateParams params1 = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(16000L) .thinking(ThinkingConfigAdaptive.builder().build()) .addUserMessageOfBlockParams(List.of( ContentBlockParam.ofText(TextBlockParam.builder() .text(largeText) .cacheControl(CacheControlEphemeral.builder().build()) .build()), ContentBlockParam.ofText(TextBlockParam.builder() .text("Analyze the tone of this passage.") .build()) )) .build(); Message response1 = client.messages().create(params1); IO.println("First response usage: " + response1.usage()); // Второй запрос — та же конфигурация (ожидается попадание в кэш) IO.println("\nSecond request - same configuration (cache hit expected)"); MessageCreateParams params2 = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(16000L) .thinking(ThinkingConfigAdaptive.builder().build()) .addUserMessageOfBlockParams(List.of( ContentBlockParam.ofText(TextBlockParam.builder() .text(largeText) .cacheControl(CacheControlEphemeral.builder().build()) .build()), ContentBlockParam.ofText(TextBlockParam.builder() .text("Analyze the tone of this passage.") .build()) )) .addAssistantMessageOfBlockParams(response1.content().stream() .map(block -> block.toParam()) .collect(java.util.stream.Collectors.toList())) .addUserMessage("Analyze the characters in this passage.") .build(); Message response2 = client.messages().create(params2); IO.println("Second response usage: " + response2.usage()); // Третий запрос — другой уровень effort (ожидается промах кэша) IO.println("\nThird request - different effort level (cache miss expected)"); MessageCreateParams params3 = MessageCreateParams.builder() .model(Model.CLAUDE_OPUS_5_5) .maxTokens(16000L) .thinking(ThinkingConfigAdaptive.builder().build()) .outputConfig(OutputConfig.builder() .effort(OutputConfig.Effort.LOW) .build()) .addUserMessageOfBlockParams(List.of( ContentBlockParam.ofText(TextBlockParam.builder() .text(largeText) .cacheControl(CacheControlEphemeral.builder().build()) .build()), ContentBlockParam.ofText(TextBlockParam.builder() .text("Analyze the tone of this passage.") .build()) )) .addAssistantMessageOfBlockParams(response1.content().stream() .map(block -> block.toParam()) .collect(java.util.stream.Collectors.toList())) .addUserMessage("Analyze the characters in this passage.") .addAssistantMessageOfBlockParams(response2.content().stream() .map(block -> block.toParam()) .collect(java.util.stream.Collectors.toList())) .addUserMessage("Analyze the setting in this passage.") .build(); Message response3 = client.messages().create(params3); IO.println("Third response usage: " + response3.usage()); } String fetchArticleContent(String url) throws Exception { HttpClient client = HttpClient.newHttpClient(); HttpRequest request = HttpRequest.newBuilder() .uri(URI.create(url)) .build(); HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString()); return response.body(); } ``` ```php function fetchArticleContent($url) { $content = file_get_contents($url); $lines = explode("\n", $content); $cleanedLines = array_filter(array_map('trim', $lines)); return implode("\n", $cleanedLines); } $client = new Client(); $bookUrl = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"; $bookContent = fetchArticleContent($bookUrl); $largeText = substr($bookContent, 0, 10000); echo "First request - establishing cache\n"; $response1 = $client->messages->create( maxTokens: 16000, messages: [[ 'role' => 'user', 'content' => [ [ 'type' => 'text', 'text' => $largeText, 'cache_control' => ['type' => 'ephemeral'] ], [ 'type' => 'text', 'text' => 'Analyze the tone of this passage.' ] ] ]], model: 'claude-opus-5-5', thinking: ['type' => 'adaptive'], ); echo "First response usage: " . json_encode($response1->usage) . "\n"; echo "\nSecond request - same configuration (cache hit expected)\n"; $response2 = $client->messages->create( maxTokens: 16000, messages: [ [ 'role' => 'user', 'content' => [ [ 'type' => 'text', 'text' => $largeText, 'cache_control' => ['type' => 'ephemeral'] ], [ 'type' => 'text', 'text' => 'Analyze the tone of this passage.' ] ] ], [ 'role' => 'assistant', 'content' => $response1->content ], [ 'role' => 'user', 'content' => 'Analyze the characters in this passage.' ] ], model: 'claude-opus-5-5', thinking: ['type' => 'adaptive'], ); echo "Second response usage: " . json_encode($response2->usage) . "\n"; echo "\nThird request - different effort level (cache miss expected)\n"; $response3 = $client->messages->create( maxTokens: 16000, messages: [ [ 'role' => 'user', 'content' => [ [ 'type' => 'text', 'text' => $largeText, 'cache_control' => ['type' => 'ephemeral'] ], [ 'type' => 'text', 'text' => 'Analyze the tone of this passage.' ] ] ], [ 'role' => 'assistant', 'content' => $response1->content ], [ 'role' => 'user', 'content' => 'Analyze the characters in this passage.' ], [ 'role' => 'assistant', 'content' => $response2->content ], [ 'role' => 'user', 'content' => 'Analyze the setting in this passage.' ] ], model: 'claude-opus-5-5', thinking: ['type' => 'adaptive'], outputConfig: ['effort' => 'low'], ); echo "Third response usage: " . json_encode($response3->usage) . "\n"; ``` ```ruby require "net/http" require "uri" def fetch_article_content(url) uri = URI.parse(url) response = Net::HTTP.get_response(uri) text = response.body lines = text.split("\n").map(&:strip) lines.reject(&:empty?).join("\n") end client = Anthropic::Client.new book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt" book_content = fetch_article_content(book_url) large_text = book_content[0...10000] puts "First request - establishing cache" response1 = client.messages.create( model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive" }, messages: [{ role: "user", content: [ { type: "text", text: large_text, cache_control: { type: "ephemeral" } }, { type: "text", text: "Analyze the tone of this passage." } ] }] ) puts "First response usage: #{response1.usage}" puts "\nSecond request - same configuration (cache hit expected)" response2 = client.messages.create( model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive" }, messages: [ { role: "user", content: [ { type: "text", text: large_text, cache_control: { type: "ephemeral" } }, { type: "text", text: "Analyze the tone of this passage." } ] }, { role: "assistant", content: response1.content }, { role: "user", content: "Analyze the characters in this passage." } ] ) puts "Second response usage: #{response2.usage}" puts "\nThird request - different effort level (cache miss expected)" response3 = client.messages.create( model: "claude-opus-5-5", max_tokens: 16000, thinking: { type: "adaptive" }, output_config: { effort: "low" }, messages: [ { role: "user", content: [ { type: "text", text: large_text, cache_control: { type: "ephemeral" } }, { type: "text", text: "Analyze the tone of this passage." } ] }, { role: "assistant", content: response1.content }, { role: "user", content: "Analyze the characters in this passage." }, { role: "assistant", content: response2.content }, { role: "user", content: "Analyze the setting in this passage." } ] ) puts "Third response usage: #{response3.usage}" ``` Вот вывод скрипта (числа у вас могут немного отличаться): ```text Output wrap First request - establishing cache First response usage: { cache_creation_input_tokens: 3546, cache_read_input_tokens: 0, input_tokens: 15, output_tokens: 1033 } Second request - same configuration (cache hit expected) Second response usage: { cache_creation_input_tokens: 0, cache_read_input_tokens: 3546, input_tokens: 1062, output_tokens: 1630 } Third request - different effort level (cache miss expected) Third response usage: { cache_creation_input_tokens: 3546, cache_read_input_tokens: 0, input_tokens: 2706, output_tokens: 1468 } ``` Когда точка останова кэша находится в массиве сообщений, изменение усилия с `medium` (значение по умолчанию на Claude Opus 5.5) на `low` делает её недействительной: третий запрос показывает `cache_creation_input_tokens=3546` и `cache_read_input_tokens=0`, тогда как второй показал полное чтение из кэша. ### Контроль стоимости Вы не задаёте бюджет токенов размышлений. Стоимость ограничивают два элемента управления: * `max_tokens` — жёсткий предел общего вывода для запроса, размышлений и текста ответа вместе. Claude никогда не генерирует сверх него. В цикле использования инструментов у каждого запроса в ходе свой `max_tokens`, поэтому он не ограничивает расходы всего хода. * `effort` — мягкое указание на то, какую часть этого вывода Claude выделяет на размышления. Оно формирует поведение, но не гарантирует количество токенов. Поскольку размышления учитываются в `max_tokens`, установите его достаточно высоким, чтобы оставить место и для рассуждений, и для ответа. Значение `max_tokens`, рассчитанное на ответ без размышлений, часто оказывается слишком маленьким, когда Claude начинает думать над сложными запросами. При усилии `high` и выше Claude может думать обширно и с большей вероятностью исчерпает бюджет. Если вы видите в ответах [`stop_reason: "max_tokens"`](https://platform.claude.com/docs/ru/build-with-claude/thinking-troubleshooting#stopped-at-max-tokens), у вас есть два средства: * Повысьте `max_tokens`, чтобы дать модели больше места для размышлений плюс ответа. * Понизьте уровень усилия, чтобы Claude думал меньше и оставлял большую часть бюджета для текста ответа. Какое из них правильное, зависит от того, нуждались ли усечённые ответы в рассуждениях. Если качество этих запросов важно, повысьте предел; если они были чрезмерно обдуманы, понизьте усилие. ## Ценообразование Размышления влекут за собой плату за: * Токены, которые Claude использует во время размышлений (тарифицируются как выходные токены) * Блоки размышлений из предыдущих ходов ассистента, остающиеся в контексте, согласно [правилу сохранения по умолчанию](https://platform.claude.com/docs/ru/build-with-claude/thinking#thinking-block-preservation-by-model): все ходы по умолчанию на моделях, сохраняющих всё, и только последний ход в остальных случаях (тарифицируются как входные токены) * Стандартные выходные токены текста Когда размышления активны, для поддержки этой функции автоматически включается специализированная системная подсказка. То, за что вам выставляется счёт, одинаково независимо от настройки `display`; меняется только то, что вы видите: | | `display: "summarized"` | `display: "omitted"` | | ------------------------------------ | ---------------------------------------------------------------- | ------------------------------------------------- | | **Входные токены** | Токены в вашем исходном запросе | То же, что и для summarized | | **Выходные токены (тарифицируемые)** | Полные токены размышлений, которые Claude сгенерировал внутренне | То же, что и для summarized | | **Выходные токены (видимые)** | Суммаризированный текст размышлений | Ноль токенов размышлений (поле `thinking` пустое) | | **Генерация сводки** | Бесплатно | Неприменимо | Тарифицируемое количество выходных токенов **не** совпадает с видимым количеством токенов в ответе. Вам выставляется счёт за полный процесс размышлений, а не за содержимое размышлений, видимое в ответе. Чтобы увидеть, сколько тарифицируемых выходных токенов было потрачено на внутренние рассуждения, прочитайте `usage.output_tokens_details.thinking_tokens` в ответе. Это значение отражает исходные рассуждения, сгенерированные моделью (а не суммаризированный текст, возвращённый в теле), и всегда меньше или равно `output_tokens`. Вычтите его из `output_tokens`, чтобы приблизительно оценить часть вывода, не относящуюся к рассуждениям. При потоковой передаче эта разбивка появляется только в финальном событии `message_delta`. ```json { "usage": { "input_tokens": 25, "output_tokens": 348, "output_tokens_details": { "thinking_tokens": 312 } } } ``` `output_tokens` остаётся включающим всё авторитетным итогом, используемым для выставления счетов. `output_tokens_details` — это разбивка только для чтения, предназначенная для наблюдаемости. Полную информацию о ценах, включая базовые тарифы, записи в кэш, попадания в кэш и выходные токены, см. в разделе [Цены](https://platform.claude.com/docs/ru/about-claude/pricing). ## Следующие шаги Включите размышления, читайте вывод размышлений и проверьте поддержку для каждой модели. Сохраняйте блоки размышлений между вызовами инструментов и управляйте размышлениями в многоходовых разговорах. Контролируйте, сколько размышлений и вывода Claude выделяет на каждый запрос.