Создание с расширенным мышлением

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

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

Расширенное мышление поддерживается в следующих моделях:

Claude Opus 4 (claude-opus-4-20250514)
Claude Sonnet 4 (claude-sonnet-4-20250514)
Claude Sonnet 3.7 (claude-3-7-sonnet-20250219)

Поведение API различается между моделями Claude 3.7 и Claude 4, но формы API остаются точно такими же.

Для получения дополнительной информации см. Различия в мышлении между версиями моделей.

Как работает расширенное мышление

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

Ответ API будет включать блоки содержимого thinking, за которыми следуют блоки содержимого text.

Вот пример формата ответа по умолчанию:

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Позвольте мне проанализировать это пошагово...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "text",
      "text": "На основе моего анализа..."
    }
  ]
}

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

Как использовать расширенное мышление

Вот пример использования расширенного мышления в API сообщений:

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Существует ли бесконечное количество простых чисел таких, что n mod 4 == 3?"
        }
    ]
}'

Чтобы включить расширенное мышление, добавьте объект thinking с параметром type, установленным в enabled, и budget_tokens в указанный бюджет токенов для расширенного мышления.

Параметр budget_tokens определяет максимальное количество токенов, которое Claude разрешено использовать для своего внутреннего процесса рассуждения. В моделях Claude 4 этот лимит применяется к полным токенам мышления, а не к суммированному выводу. Большие бюджеты могут улучшить качество ответов, позволяя более тщательный анализ сложных проблем, хотя Claude может не использовать весь выделенный бюджет, особенно в диапазонах выше 32k.

budget_tokens должен быть установлен в значение меньше max_tokens. Однако при использовании чередующегося мышления с инструментами вы можете превысить этот лимит, поскольку лимит токенов становится вашим полным контекстным окном (200k токенов).

Суммированное мышление

При включенном расширенном мышлении API сообщений для моделей Claude 4 возвращает краткое изложение полного мыслительного процесса Claude. Суммированное мышление обеспечивает полные преимущества интеллекта расширенного мышления, предотвращая при этом неправильное использование.

Вот некоторые важные соображения для суммированного мышления:

Вам выставляется счет за полные токены мышления, сгенерированные исходным запросом, а не за токены краткого изложения.
Количество выходных токенов к оплате не будет соответствовать количеству токенов, которые вы видите в ответе.
Первые несколько строк вывода мышления более подробны, предоставляя детальные рассуждения, которые особенно полезны для целей инженерии промптов.
Поскольку Anthropic стремится улучшить функцию расширенного мышления, поведение суммирования может изменяться.
Суммирование сохраняет ключевые идеи мыслительного процесса Claude с минимальной дополнительной задержкой, обеспечивая потоковый пользовательский опыт и легкую миграцию с моделей Claude 3.7 на модели Claude 4.
Суммирование обрабатывается другой моделью, чем та, на которую вы нацеливаетесь в своих запросах. Модель мышления не видит суммированный вывод.

Claude Sonnet 3.7 продолжает возвращать полный вывод мышления.

В редких случаях, когда вам нужен доступ к полному выводу мышления для моделей Claude 4, свяжитесь с нашей командой продаж.

Потоковое мышление

Вы можете передавать ответы расширенного мышления в потоке, используя события, отправляемые сервером (SSE).

Когда потоковая передача включена для расширенного мышления, вы получаете содержимое мышления через события thinking_delta.

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

Вот как обрабатывать потоковую передачу с мышлением:

curl https://api.anthropic.com/v1/messages \
     --header "x-api-key: $ANTHROPIC_API_KEY" \
     --header "anthropic-version: 2023-06-01" \
     --header "content-type: application/json" \
     --data \
'{
    "model": "claude-sonnet-4-20250514",
    "max_tokens": 16000,
    "stream": true,
    "thinking": {
        "type": "enabled",
        "budget_tokens": 10000
    },
    "messages": [
        {
            "role": "user",
            "content": "Сколько будет 27 * 453?"
        }
    ]
}'

Пример потокового вывода:

event: message_start
data: {"type": "message_start", "message": {"id": "msg_01...", "type": "message", "role": "assistant", "content": [], "model": "claude-sonnet-4-20250514", "stop_reason": null, "stop_sequence": null}}

event: content_block_start
data: {"type": "content_block_start", "index": 0, "content_block": {"type": "thinking", "thinking": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "Позвольте мне решить это пошагово:\n\n1. Сначала разложим 27 * 453"}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "thinking_delta", "thinking": "\n2. 453 = 400 + 50 + 3"}}

// Дополнительные дельты мышления...

event: content_block_delta
data: {"type": "content_block_delta", "index": 0, "delta": {"type": "signature_delta", "signature": "EqQBCgIYAhIM1gbcDa9GJwZA2b3hGgxBdjrkzLoky3dl1pkiMOYds..."}}

event: content_block_stop
data: {"type": "content_block_stop", "index": 0}

event: content_block_start
data: {"type": "content_block_start", "index": 1, "content_block": {"type": "text", "text": ""}}

event: content_block_delta
data: {"type": "content_block_delta", "index": 1, "delta": {"type": "text_delta", "text": "27 * 453 = 12,231"}}

// Дополнительные текстовые дельты...

event: content_block_stop
data: {"type": "content_block_stop", "index": 1}

event: message_delta
data: {"type": "message_delta", "delta": {"stop_reason": "end_turn", "stop_sequence": null}}

event: message_stop
data: {"type": "message_stop"}

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

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

Расширенное мышление с использованием инструментов

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

При использовании расширенного мышления с использованием инструментов учитывайте следующие ограничения:

Ограничение выбора инструмента: Использование инструментов с мышлением поддерживает только tool_choice: {"type": "auto"} (по умолчанию) или tool_choice: {"type": "none"}. Использование tool_choice: {"type": "any"} или tool_choice: {"type": "tool", "name": "..."} приведет к ошибке, поскольку эти опции принуждают к использованию инструментов, что несовместимо с расширенным мышлением.
Сохранение блоков мышления: Во время использования инструментов вы должны передавать блоки thinking обратно в API для последнего сообщения ассистента. Включите полный неизмененный блок обратно в API для поддержания непрерывности рассуждений.

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

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

weather_tool = {
    "name": "get_weather",
    "description": "Получить текущую погоду для местоположения",
    "input_schema": {
        "type": "object",
        "properties": {
            "location": {"type": "string"}
        },
        "required": ["location"]
    }
}

# Первый запрос - Claude отвечает с мышлением и запросом инструмента
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Какая погода в Париже?"}
    ]
)

Ответ API будет включать блоки мышления, текста и использования инструментов:

{
    "content": [
        {
            "type": "thinking",
            "thinking": "Пользователь хочет знать текущую погоду в Париже. У меня есть доступ к функции `get_weather`...",
            "signature": "BDaL4VrbR2Oj0hO4XpJxT28J5TILnCrrUXoKiiNBZW9P+nr8XSj1zuZzAl4egiCCpQNvfyUuFFJP5CncdYZEQPPmLxYsNrcs...."
        },
        {
            "type": "text",
            "text": "Я могу помочь вам получить текущую информацию о погоде для Парижа. Позвольте мне проверить это для вас"
        },
        {
            "type": "tool_use",
            "id": "toolu_01CswdEQBMshySk6Y9DFKrfq",
            "name": "get_weather",
            "input": {
                "location": "Париж"
            }
        }
    ]
}

Теперь давайте продолжим разговор и используем инструмент

# Извлечь блок мышления и блок использования инструмента
thinking_block = next((block for block in response.content
                      if block.type == 'thinking'), None)
tool_use_block = next((block for block in response.content
                      if block.type == 'tool_use'), None)

# Вызвать ваш фактический API погоды, здесь будет ваш фактический вызов API
# давайте представим, что мы получили это обратно
weather_data = {"temperature": 88}

# Второй запрос - Включить блок мышления и результат инструмента
# Новые блоки мышления не будут сгенерированы в ответе
continuation = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[weather_tool],
    messages=[
        {"role": "user", "content": "Какая погода в Париже?"},
        # обратите внимание, что thinking_block передается вместе с tool_use_block
        # если это не передается, возникает ошибка
        {"role": "assistant", "content": [thinking_block, tool_use_block]},
        {"role": "user", "content": [{
            "type": "tool_result",
            "tool_use_id": tool_use_block.id,
            "content": f"Текущая температура: {weather_data['temperature']}°F"
        }]}
    ]
)

Ответ API теперь будет включать только текст

{
    "content": [
        {
            "type": "text",
            "text": "В настоящее время в Париже температура составляет 88°F (31°C)"
        }
    ]
}

Сохранение блоков мышления

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

Хотя вы можете опустить блоки thinking из предыдущих ходов assistant, мы предлагаем всегда передавать обратно все блоки мышления в API для любого многоходового разговора. API будет:

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

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

Непрерывность рассуждений: Блоки мышления фиксируют пошаговые рассуждения Claude, которые привели к запросам инструментов. Когда вы публикуете результаты инструментов, включение исходного мышления гарантирует, что Claude может продолжить свои рассуждения с того места, где остановился.
Поддержание контекста: Хотя результаты инструментов появляются как сообщения пользователя в структуре API, они являются частью непрерывного потока рассуждений. Сохранение блоков мышления поддерживает этот концептуальный поток через несколько вызовов API. Для получения дополнительной информации об управлении контекстом см. наше руководство по контекстным окнам.

Важно: При предоставлении блоков thinking вся последовательность последовательных блоков thinking должна соответствовать выводам, сгенерированным моделью во время исходного запроса; вы не можете переставлять или изменять последовательность этих блоков.

Чередующееся мышление

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

С чередующимся мышлением Claude может:

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

Чтобы включить чередующееся мышление, добавьте бета-заголовок interleaved-thinking-2025-05-14 к вашему запросу API.

Вот некоторые важные соображения для чередующегося мышления:

С чередующимся мышлением budget_tokens может превышать параметр max_tokens, поскольку он представляет общий бюджет для всех блоков мышления в рамках одного хода ассистента.
Чередующееся мышление поддерживается только для инструментов, используемых через API сообщений.
Чередующееся мышление поддерживается только для моделей Claude 4 с бета-заголовком interleaved-thinking-2025-05-14.
Прямые вызовы к API Anthropic позволяют передавать interleaved-thinking-2025-05-14 в запросах к любой модели без эффекта.
На сторонних платформах (например, Amazon Bedrock и Vertex AI), если вы передаете interleaved-thinking-2025-05-14 любой модели, кроме Claude Opus 4 или Sonnet 4, ваш запрос завершится неудачей.

Использование инструментов без чередующегося мышления

import anthropic

client = anthropic.Anthropic()

# Определить инструменты
calculator_tool = {
    "name": "calculator",
    "description": "Выполнить математические вычисления",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Математическое выражение для вычисления"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Запрос к базе данных продуктов",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "SQL-запрос для выполнения"
            }
        },
        "required": ["query"]
    }
}

# Первый запрос - Claude думает один раз перед всеми вызовами инструментов
response = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    messages=[{
        "role": "user",
        "content": "Какой общий доход, если мы продали 150 единиц продукта A по $50 за штуку, и как это сравнивается с нашим средним месячным доходом из базы данных?"
    }]
)

# Ответ включает мышление, за которым следуют использования инструментов
# Примечание: Claude думает один раз в начале, затем принимает все решения об инструментах
print("Первый ответ:")
for block in response.content:
    if block.type == "thinking":
        print(f"Мышление (суммированное): {block.thinking}")
    elif block.type == "tool_use":
        print(f"Использование инструмента: {block.name} с входом {block.input}")
    elif block.type == "text":
        print(f"Текст: {block.text}")

# Вы бы выполнили инструменты и вернули результаты...
# После получения обоих результатов инструментов Claude напрямую отвечает без дополнительного мышления

В этом примере без чередующегося мышления:

Claude думает один раз в начале, чтобы понять задачу
Принимает все решения об использовании инструментов заранее
Когда возвращаются результаты инструментов, Claude немедленно предоставляет ответ без дополнительного мышления

Использование инструментов с чередующимся мышлением

import anthropic

client = anthropic.Anthropic()

# Те же определения инструментов, что и раньше
calculator_tool = {
    "name": "calculator",
    "description": "Выполнить математические вычисления",
    "input_schema": {
        "type": "object",
        "properties": {
            "expression": {
                "type": "string",
                "description": "Математическое выражение для вычисления"
            }
        },
        "required": ["expression"]
    }
}

database_tool = {
    "name": "database_query",
    "description": "Запрос к базе данных продуктов",
    "input_schema": {
        "type": "object",
        "properties": {
            "query": {
                "type": "string",
                "description": "SQL-запрос для выполнения"
            }
        },
        "required": ["query"]
    }
}

# Первый запрос с включенным чередующимся мышлением
response = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[{
        "role": "user",
        "content": "Какой общий доход, если мы продали 150 единиц продукта A по $50 за штуку, и как это сравнивается с нашим средним месячным доходом из базы данных?"
    }]
)

print("Начальный ответ:")
thinking_blocks = []
tool_use_blocks = []

for block in response.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Мышление: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Использование инструмента: {block.name} с входом {block.input}")
    elif block.type == "text":
        print(f"Текст: {block.text}")

# Первый результат инструмента (калькулятор)
calculator_result = "7500"  # 150 * 50

# Продолжить с первым результатом инструмента
response2 = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "Какой общий доход, если мы продали 150 единиц продукта A по $50 за штуку, и как это сравнивается с нашим средним месячным доходом из базы данных?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        }
    ]
)

print("\nПосле результата калькулятора:")
# С чередующимся мышлением Claude может думать о результате калькулятора
# перед принятием решения о запросе к базе данных
for block in response2.content:
    if block.type == "thinking":
        thinking_blocks.append(block)
        print(f"Чередующееся мышление: {block.thinking}")
    elif block.type == "tool_use":
        tool_use_blocks.append(block)
        print(f"Использование инструмента: {block.name} с входом {block.input}")

# Второй результат инструмента (база данных)
database_result = "5200"  # Пример среднего месячного дохода

# Продолжить со вторым результатом инструмента
response3 = client.beta.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    tools=[calculator_tool, database_tool],
    betas=["interleaved-thinking-2025-05-14"],
    messages=[
        {
            "role": "user",
            "content": "Какой общий доход, если мы продали 150 единиц продукта A по $50 за штуку, и как это сравнивается с нашим средним месячным доходом из базы данных?"
        },
        {
            "role": "assistant",
            "content": [thinking_blocks[0], tool_use_blocks[0]]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[0].id,
                "content": calculator_result
            }]
        },
        {
            "role": "assistant",
            "content": thinking_blocks[1:] + tool_use_blocks[1:]
        },
        {
            "role": "user",
            "content": [{
                "type": "tool_result",
                "tool_use_id": tool_use_blocks[1].id,
                "content": database_result
            }]
        }
    ]
)

print("\nПосле результата базы данных:")
# С чередующимся мышлением Claude может думать об обоих результатах
# перед формулированием окончательного ответа
for block in response3.content:
    if block.type == "thinking":
        print(f"Окончательное мышление: {block.thinking}")
    elif block.type == "text":
        print(f"Окончательный ответ: {block.text}")

В этом примере с чередующимся мышлением:

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

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

Расширенное мышление с кэшированием промптов

Кэширование промптов с мышлением имеет несколько важных соображений:

Задачи расширенного мышления часто занимают больше 5 минут для завершения. Рассмотрите использование 1-часовой продолжительности кэша для поддержания попаданий в кэш через более длинные сессии мышления и многошаговые рабочие процессы.

Удаление контекста блоков мышления

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

Паттерны инвалидации кэша

Изменения параметров мышления (включено/отключено или распределение бюджета) инвалидируют точки разрыва кэша сообщений
Чередующееся мышление усиливает инвалидацию кэша, поскольку блоки мышления могут происходить между несколькими вызовами инструментов
Системные промпты и инструменты остаются кэшированными несмотря на изменения параметров мышления или удаление блоков

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

Понимание поведения кэширования блоков мышления

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

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

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

Подробный пример потока:

Запрос 1:

Пользователь: "Какая погода в Париже?"

Ответ 1:

[thinking_block_1] + [tool_use block 1]

Запрос 2:

Пользователь: ["Какая погода в Париже?"], 
Ассистент: [thinking_block_1] + [tool_use block 1], 
Пользователь: [tool_result_1, cache=True]

Ответ 2:

[thinking_block_2] + [text block 2]

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

Запрос 3:

Пользователь: ["Какая погода в Париже?"], 
Ассистент: [thinking_block_1] + [tool_use block 1], 
Пользователь: [tool_result_1, cache=True], 
Ассистент: [thinking_block_2] + [text block 2], 
Пользователь: [Текстовый ответ, cache=True]

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

Пользователь: ["Какая погода в Париже?"], 
Ассистент: [tool_use block 1], 
Пользователь: [tool_result_1, cache=True], 
Ассистент: [text block 2], 
Пользователь: [Текстовый ответ, cache=True]

Ключевые моменты:

Это поведение кэширования происходит автоматически, даже без явных маркеров cache_control
Это поведение согласовано независимо от того, используете ли вы обычное мышление или чередующееся мышление

Кэширование системного промпта (сохраняется при изменениях мышления)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Удалить элементы script и style
    for script in soup(["script", "style"]):
        script.decompose()

    # Получить текст
    text = soup.get_text()

    # Разбить на строки и удалить ведущие и завершающие пробелы в каждой
    lines = (line.strip() for line in text.splitlines())
    # Разбить многозаголовки на строку каждый
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Удалить пустые строки
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Получить содержимое статьи
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Использовать достаточно текста для кэширования (первые несколько глав)
LARGE_TEXT = book_content[:5000]

SYSTEM_PROMPT=[
    {
        "type": "text",
        "text": "Вы - ИИ-ассистент, которому поручен литературный анализ. Внимательно проанализируйте следующий текст.",
    },
    {
        "type": "text",
        "text": LARGE_TEXT,
        "cache_control": {"type": "ephemeral"}
    }
]

MESSAGES = [
    {
        "role": "user",
        "content": "Проанализируйте тон этого отрывка."
    }
]

# Первый запрос - установить кэш
print("Первый запрос - установка кэша")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Использование первого ответа: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Проанализируйте персонажей в этом отрывке."
})
# Второй запрос - те же параметры мышления (ожидается попадание в кэш)
print("\nВторой запрос - те же параметры мышления (ожидается попадание в кэш)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    system=SYSTEM_PROMPT,
    messages=MESSAGES
)

print(f"Использование второго ответа: {response2.usage}")

# Третий запрос - разные параметры мышления (промах кэша для сообщений)
print("\nТретий запрос - разные параметры мышления (промах кэша для сообщений)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Изменен бюджет мышления
    },
    system=SYSTEM_PROMPT,  # Системный промпт остается кэшированным
    messages=MESSAGES  # Кэш сообщений инвалидирован
)

print(f"Использование третьего ответа: {response3.usage}")

Кэширование сообщений (инвалидируется при изменениях мышления)

from anthropic import Anthropic
import requests
from bs4 import BeautifulSoup

client = Anthropic()

def fetch_article_content(url):
    response = requests.get(url)
    soup = BeautifulSoup(response.content, 'html.parser')

    # Удалить элементы script и style
    for script in soup(["script", "style"]):
        script.decompose()

    # Получить текст
    text = soup.get_text()

    # Разбить на строки и удалить ведущие и завершающие пробелы в каждой
    lines = (line.strip() for line in text.splitlines())
    # Разбить многозаголовки на строку каждый
    chunks = (phrase.strip() for line in lines for phrase in line.split("  "))
    # Удалить пустые строки
    text = '\n'.join(chunk for chunk in chunks if chunk)

    return text

# Получить содержимое статьи
book_url = "https://www.gutenberg.org/cache/epub/1342/pg1342.txt"
book_content = fetch_article_content(book_url)
# Использовать достаточно текста для кэширования (первые несколько глав)
LARGE_TEXT = book_content[:5000]

# Нет системного промпта - кэширование в сообщениях вместо этого
MESSAGES = [
    {
        "role": "user",
        "content": [
            {
                "type": "text",
                "text": LARGE_TEXT,
                "cache_control": {"type": "ephemeral"},
            },
            {
                "type": "text",
                "text": "Проанализируйте тон этого отрывка."
            }
        ]
    }
]

# Первый запрос - установить кэш
print("Первый запрос - установка кэша")
response1 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000
    },
    messages=MESSAGES
)

print(f"Использование первого ответа: {response1.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response1.content
})
MESSAGES.append({
    "role": "user",
    "content": "Проанализируйте персонажей в этом отрывке."
})
# Второй запрос - те же параметры мышления (ожидается попадание в кэш)
print("\nВторой запрос - те же параметры мышления (ожидается попадание в кэш)")
response2 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 4000  # Тот же бюджет мышления
    },
    messages=MESSAGES
)

print(f"Использование второго ответа: {response2.usage}")

MESSAGES.append({
    "role": "assistant",
    "content": response2.content
})
MESSAGES.append({
    "role": "user",
    "content": "Проанализируйте обстановку в этом отрывке."
})

# Третий запрос - другой бюджет мышления (ожидается промах кэша)
print("\nТретий запрос - другой бюджет мышления (ожидается промах кэша)")
response3 = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=20000,
    thinking={
        "type": "enabled",
        "budget_tokens": 8000  # Другой бюджет мышления нарушает кэш
    },
    messages=MESSAGES
)

print(f"Использование третьего ответа: {response3.usage}")

Вот вывод скрипта (вы можете увидеть немного разные числа)

Первый запрос - установка кэша
Использование первого ответа: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 17, output_tokens: 700 }

Второй запрос - те же параметры мышления (ожидается попадание в кэш)

Использование второго ответа: { cache_creation_input_tokens: 0, cache_read_input_tokens: 1370, input_tokens: 303, output_tokens: 874 }

Третий запрос - другой бюджет мышления (ожидается промах кэша)
Использование третьего ответа: { cache_creation_input_tokens: 1370, cache_read_input_tokens: 0, input_tokens: 747, output_tokens: 619 }

Этот пример демонстрирует, что когда кэширование настроено в массиве сообщений, изменение параметров мышления (budget_tokens увеличен с 4000 до 8000) инвалидирует кэш. Третий запрос показывает отсутствие попадания в кэш с cache_creation_input_tokens=1370 и cache_read_input_tokens=0, доказывая, что кэширование на основе сообщений инвалидируется при изменении параметров мышления.

Максимальные токены и размер контекстного окна с расширенным мышлением

В старых моделях Claude (до Claude Sonnet 3.7), если сумма токенов промпта и max_tokens превышала контекстное окно модели, система автоматически корректировала max_tokens для соответствия лимиту контекста. Это означало, что вы могли установить большое значение max_tokens, и система молча уменьшала его по мере необходимости.

С моделями Claude 3.7 и 4 max_tokens (который включает ваш бюджет мышления при включенном мышлении) применяется как строгий лимит. Система теперь вернет ошибку валидации, если токены промпта + max_tokens превышают размер контекстного окна.

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

Контекстное окно с расширенным мышлением

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

Блоки мышления из предыдущих ходов удаляются и не считаются в вашем контекстном окне
Мышление текущего хода считается в вашем лимите max_tokens для этого хода

Диаграмма ниже демонстрирует специализированное управление токенами при включенном расширенном мышлении:

Эффективное контекстное окно рассчитывается как:

контекстное окно =
  (текущие входные токены - предыдущие токены мышления) +
  (токены мышления + зашифрованные токены мышления + токены текстового вывода)

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

Контекстное окно с расширенным мышлением и использованием инструментов

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

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

контекстное окно =
  (текущие входные токены + предыдущие токены мышления + токены использования инструментов) +
  (токены мышления + зашифрованные токены мышления + токены текстового вывода)

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

Управление токенами с расширенным мышлением

Учитывая поведение контекстного окна и max_tokens с расширенным мышлением в моделях Claude 3.7 и 4, вам может потребоваться:

Более активно отслеживать и управлять использованием токенов
Корректировать значения max_tokens по мере изменения длины промпта
Потенциально использовать конечные точки подсчета токенов чаще
Помнить, что предыдущие блоки мышления не накапливаются в вашем контекстном окне

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

Шифрование мышления

Полное содержимое мышления зашифровано и возвращается в поле signature. Это поле используется для проверки того, что блоки мышления были сгенерированы Claude при передаче обратно в API.

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

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

Вот некоторые важные соображения по шифрованию мышления:

При потоковых ответах подпись добавляется через signature_delta внутри события content_block_delta непосредственно перед событием content_block_stop.
Значения signature значительно длиннее в Claude 4, чем в предыдущих моделях.
Поле signature является непрозрачным полем и не должно интерпретироваться или анализироваться - оно существует исключительно для целей проверки.
Значения signature совместимы между платформами (API Anthropic, Amazon Bedrock и Vertex AI). Значения, сгенерированные на одной платформе, будут совместимы с другой.

Редактирование мышления

Иногда внутренние рассуждения Claude будут помечены нашими системами безопасности. Когда это происходит, мы шифруем часть или все блоки thinking и возвращаем их вам как блоки redacted_thinking. Блоки redacted_thinking расшифровываются при передаче обратно в API, позволяя Claude продолжить свой ответ без потери контекста.

При создании клиентских приложений, использующих расширенное мышление:

Помните, что редактированные блоки мышления содержат зашифрованное содержимое, которое не читается человеком
Рассмотрите предоставление простого объяснения, например: “Часть внутренних рассуждений Claude была автоматически зашифрована по соображениям безопасности. Это не влияет на качество ответов.”
Если показываете блоки мышления пользователям, вы можете отфильтровать редактированные блоки, сохраняя обычные блоки мышления
Будьте прозрачны в том, что использование функций расширенного мышления может иногда приводить к шифрованию некоторых рассуждений
Реализуйте соответствующую обработку ошибок для изящного управления редактированным мышлением без нарушения вашего пользовательского интерфейса

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

{
  "content": [
    {
      "type": "thinking",
      "thinking": "Позвольте мне проанализировать это пошагово...",
      "signature": "WaUjzkypQ2mUEVM36O2TxuC06KN8xyfbJwyem2dw3URve/op91XWHOEBLLqIOMfFG/UvLEczmEsUjavL...."
    },
    {
      "type": "redacted_thinking",
      "data": "EmwKAhgBEgy3va3pzix/LafPsn4aDFIT2Xlxh0L5L8rLVyIwxtE3rAFBa8cr3qpPkNRj2YfWXGmKDxH4mPnZ5sQ7vB9URj2pLmN3kF8/dW5hR7xJ0aP1oLs9yTcMnKVf2wRpEGjH9XZaBt4UvDcPrQ..."
    },
    {
      "type": "text",
      "text": "На основе моего анализа..."
    }
  ]
}

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

Если вам нужно протестировать обработку редактированного мышления в вашем приложении, вы можете использовать эту специальную тестовую строку в качестве промпта: ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB

При передаче блоков thinking и redacted_thinking обратно в API в многоходовом разговоре вы должны включить полный неизмененный блок обратно в API для последнего хода ассистента. Это критически важно для поддержания потока рассуждений модели. Мы предлагаем всегда передавать обратно все блоки мышления в API. Для получения дополнительной информации см. раздел Сохранение блоков мышления выше.

Пример: Работа с редактированными блоками мышления

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

import anthropic

client = anthropic.Anthropic()

# Использование специального промпта, который вызывает редактированное мышление (только для демонстрационных целей)
response = client.messages.create(
    model="claude-3-7-sonnet-20250219",
    max_tokens=16000,
    thinking={
        "type": "enabled",
        "budget_tokens": 10000
    },
    messages=[{
        "role": "user",
        "content": "ANTHROPIC_MAGIC_STRING_TRIGGER_REDACTED_THINKING_46C9A13E193C177646C7398A98432ECCCE4C1253D5E2D82641AC0E52CC2876CB"
    }]
)

# Идентифицировать редактированные блоки мышления
has_redacted_thinking = any(
    block.type == "redacted_thinking" for block in response.content
)

if has_redacted_thinking:
    print("Ответ содержит редактированные блоки мышления")
    # Эти блоки все еще используемы в последующих запросах

    # Извлечь все блоки (как редактированные, так и нередактированные)
    all_thinking_blocks = [
        block for block in response.content
        if block.type in ["thinking", "redacted_thinking"]
    ]

    # При передаче в последующие запросы включите все блоки без изменений
    # Это сохраняет целостность рассуждений Claude

    print(f"Найдено {len(all_thinking_blocks)} блоков мышления всего")
    print(f"Эти блоки все еще оплачиваются как выходные токены")

Различия в мышлении между версиями моделей

API сообщений обрабатывает мышление по-разному в моделях Claude Sonnet 3.7 и Claude 4, в основном в поведении редактирования и суммирования.

См. таблицу ниже для сжатого сравнения:

Функция	Claude Sonnet 3.7	Модели Claude 4
Вывод мышления	Возвращает полный вывод мышления	Возвращает суммированное мышление
Чередующееся мышление	Не поддерживается	Поддерживается с бета-заголовком `interleaved-thinking-2025-05-14`

Ценообразование

Расширенное мышление использует стандартную схему ценообразования токенов:

Модель	Базовые входные токены	Записи кэша	Попадания в кэш	Выходные токены
Claude Opus 4	$15 / MTok	$18.75 / MTok	$1.50 / MTok	$75 / MTok
Claude Sonnet 4	$3 / MTok	$3.75 / MTok	$0.30 / MTok	$15 / MTok
Claude Sonnet 3.7	$3 / MTok	$3.75 / MTok	$0.30 / MTok	$15 / MTok

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

Токены, используемые во время мышления (выходные токены)
Блоки мышления из последнего хода ассистента, включенные в последующие запросы (входные токены)
Стандартные токены текстового вывода

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

При использовании суммированного мышления:

Входные токены: Токены в вашем исходном запросе (исключает токены мышления из предыдущих ходов)
Выходные токены (к оплате): Исходные токены мышления, которые Claude сгенерировал внутренне
Выходные токены (видимые): Суммированные токены мышления, которые вы видите в ответе
Без платы: Токены, используемые для генерации краткого изложения

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

Лучшие практики и соображения для расширенного мышления

Работа с бюджетами мышления

Оптимизация бюджета: Минимальный бюджет составляет 1,024 токена. Мы предлагаем начинать с минимума и увеличивать бюджет мышления постепенно, чтобы найти оптимальный диапазон для вашего случая использования. Более высокие количества токенов обеспечивают более всестороннее рассуждение, но с убывающей отдачей в зависимости от задачи. Увеличение бюджета может улучшить качество ответов за счет увеличения задержки. Для критических задач тестируйте разные настройки, чтобы найти оптимальный баланс. Обратите внимание, что бюджет мышления является целью, а не строгим лимитом - фактическое использование токенов может варьироваться в зависимости от задачи.
Отправные точки: Начинайте с больших бюджетов мышления (16k+ токенов) для сложных задач и корректируйте в зависимости от ваших потребностей.
Большие бюджеты: Для бюджетов мышления выше 32k мы рекомендуем использовать пакетную обработку, чтобы избежать проблем с сетью. Запросы, заставляющие модель думать выше 32k токенов, вызывают долго выполняющиеся запросы, которые могут столкнуться с системными таймаутами и лимитами открытых соединений.
Отслеживание использования токенов: Отслеживайте использование токенов мышления для оптимизации затрат и производительности.

Соображения производительности

Время ответа: Будьте готовы к потенциально более длительному времени ответа из-за дополнительной обработки, необходимой для процесса рассуждения. Учитывайте, что генерация блоков мышления может увеличить общее время ответа.
Требования к потоковой передаче: Потоковая передача требуется, когда max_tokens больше 21,333. При потоковой передаче будьте готовы обрабатывать как блоки содержимого мышления, так и текстовые блоки по мере их поступления.

Совместимость функций

Мышление несовместимо с модификациями temperature или top_k, а также с принудительным использованием инструментов.
Когда мышление включено, вы можете установить top_p в значения между 1 и 0.95.
Вы не можете предварительно заполнять ответы при включенном мышлении.
Изменения бюджета мышления инвалидируют кэшированные префиксы промптов, которые включают сообщения. Однако кэшированные системные промпты и определения инструментов будут продолжать работать при изменении параметров мышления.

Руководящие принципы использования

Выбор задач: Используйте расширенное мышление для особенно сложных задач, которые выигрывают от пошагового рассуждения, таких как математика, кодирование и анализ.
Обработка контекста: Вам не нужно удалять предыдущие блоки мышления самостоятельно. API Anthropic автоматически игнорирует блоки мышления из предыдущих ходов, и они не включаются при расчете использования контекста.
Инженерия промптов: Просмотрите наши советы по промптингу расширенного мышления, если вы хотите максимизировать возможности мышления Claude.

Следующие шаги

Попробуйте кулинарную книгу расширенного мышления

Изучите практические примеры мышления в нашей кулинарной книге.

Советы по промптингу расширенного мышления

Изучите лучшие практики инженерии промптов для расширенного мышления.

Кэширование промптов Потоковые сообщения

On this page

Поддерживаемые модели
Как работает расширенное мышление
Как использовать расширенное мышление
Суммированное мышление
Потоковое мышление
Расширенное мышление с использованием инструментов
Сохранение блоков мышления
Чередующееся мышление
Расширенное мышление с кэшированием промптов
Понимание поведения кэширования блоков мышления
Максимальные токены и размер контекстного окна с расширенным мышлением
Контекстное окно с расширенным мышлением
Контекстное окно с расширенным мышлением и использованием инструментов
Управление токенами с расширенным мышлением
Шифрование мышления
Редактирование мышления
Различия в мышлении между версиями моделей
Ценообразование
Лучшие практики и соображения для расширенного мышления
Работа с бюджетами мышления
Соображения производительности
Совместимость функций
Руководящие принципы использования
Следующие шаги

Первые шаги

Модели и цены

Узнать о Claude

Возможности

Инструменты

Протокол контекста модели (MCP)

Варианты использования

Инженерия промптов

Тестирование и оценка

Усилить защитные меры

Юридический центр

Создание с расширенным мышлением

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

Как работает расширенное мышление

Как использовать расширенное мышление

Суммированное мышление

Потоковое мышление

Расширенное мышление с использованием инструментов

Сохранение блоков мышления

Чередующееся мышление

Расширенное мышление с кэшированием промптов

Понимание поведения кэширования блоков мышления

Максимальные токены и размер контекстного окна с расширенным мышлением

Контекстное окно с расширенным мышлением

Контекстное окно с расширенным мышлением и использованием инструментов

Управление токенами с расширенным мышлением

Шифрование мышления

Редактирование мышления

Различия в мышлении между версиями моделей

Ценообразование

Лучшие практики и соображения для расширенного мышления

Работа с бюджетами мышления

Соображения производительности

Совместимость функций

Руководящие принципы использования

Следующие шаги

Попробуйте кулинарную книгу расширенного мышления

Советы по промптингу расширенного мышления

Первые шаги

Модели и цены

Узнать о Claude

Возможности

Инструменты

Протокол контекста модели (MCP)

Варианты использования

Инженерия промптов

Тестирование и оценка

Усилить защитные меры

Юридический центр

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

​Как работает расширенное мышление

​Как использовать расширенное мышление

​Суммированное мышление

​Потоковое мышление

​Расширенное мышление с использованием инструментов

​Сохранение блоков мышления

​Чередующееся мышление

​Расширенное мышление с кэшированием промптов

​Понимание поведения кэширования блоков мышления

​Максимальные токены и размер контекстного окна с расширенным мышлением

​Контекстное окно с расширенным мышлением

​Контекстное окно с расширенным мышлением и использованием инструментов

​Управление токенами с расширенным мышлением

​Шифрование мышления

​Редактирование мышления

​Различия в мышлении между версиями моделей

​Ценообразование

​Лучшие практики и соображения для расширенного мышления

​Работа с бюджетами мышления

​Соображения производительности

​Совместимость функций

​Руководящие принципы использования

​Следующие шаги

Попробуйте кулинарную книгу расширенного мышления

Советы по промптингу расширенного мышления

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

Как работает расширенное мышление

Как использовать расширенное мышление

Суммированное мышление

Потоковое мышление

Расширенное мышление с использованием инструментов

Сохранение блоков мышления

Чередующееся мышление

Расширенное мышление с кэшированием промптов

Понимание поведения кэширования блоков мышления

Максимальные токены и размер контекстного окна с расширенным мышлением

Контекстное окно с расширенным мышлением

Контекстное окно с расширенным мышлением и использованием инструментов

Управление токенами с расширенным мышлением

Шифрование мышления

Редактирование мышления

Различия в мышлении между версиями моделей

Ценообразование

Лучшие практики и соображения для расширенного мышления

Работа с бюджетами мышления

Соображения производительности

Совместимость функций

Руководящие принципы использования

Следующие шаги