Программный вызов инструментов

Программный вызов инструментов позволяет Claude писать код, который вызывает ваши инструменты программно внутри контейнера code execution (выполнения кода), вместо того чтобы требовать обращения к модели для каждого вызова инструмента. Это снижает задержку для рабочих процессов с несколькими инструментами и уменьшает потребление токенов, позволяя Claude фильтровать или обрабатывать данные до того, как они попадут в контекстное окно модели. В бенчмарках агентного поиска, таких как BrowseComp и DeepSearchQA, которые тестируют многоэтапное веб-исследование и сложный поиск информации, добавление программного вызова инструментов поверх базовых инструментов поиска улучшило производительность в среднем на 11% при использовании на 24% меньше входных токенов (см. Improved web search with dynamic filtering).

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



Совместимость с моделями

Программный вызов инструментов требует code_execution_20260120 или более поздней версии, которая поддерживается в следующих моделях:

Полную матрицу версий инструмента выполнения кода см. в таблице совместимости моделей с инструментом выполнения кода. Программный вызов инструментов доступен в Claude API, Claude Platform on AWS и Microsoft Foundry. В Microsoft Foundry программный вызов инструментов требует развёртывания Hosted on Anthropic. В настоящее время он недоступен в Amazon Bedrock или Google Cloud.



Быстрый старт

Вот пример, в котором Claude программно запрашивает базу данных несколько раз и агрегирует результаты:

client = anthropic.Anthropic()

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=4096,
    messages=[
        {
            "role": "user",
            "content": "Query sales data for the West, East, and Central regions, then tell me which region had the highest revenue",
        }
    ],
    tools=[
        {"type": "code_execution_20260120", "name": "code_execution"},
        {
            "name": "query_database",
            "description": "Execute a SQL query against the sales database. Returns a list of rows as JSON objects.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "sql": {"type": "string", "description": "SQL query to execute"}
                },
                "required": ["sql"],
            },
            "allowed_callers": ["code_execution_20260120"],
        },
    ],
)

print(response)

Ответ останавливается с stop_reason: "tool_use", идентификатором container и блоком tool_use для query_database, поле caller которого идентифицирует запуск выполнения кода, вызвавший его. Верните результат, как показано в Шаге 3 примера рабочего процесса, чтобы код мог завершиться.



Как работает программный вызов инструментов

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

1. Claude пишет код на Python, который вызывает инструмент как функцию, потенциально включая несколько вызовов инструментов и логику пред- и постобработки
2. Claude запускает этот код в изолированном контейнере через выполнение кода
3. Когда вызывается функция инструмента, выполнение кода приостанавливается, и API возвращает блок tool_use
4. Вы предоставляете результат инструмента, и выполнение кода продолжается (промежуточные результаты не загружаются в контекстное окно Claude)
5. После завершения всего выполнения кода Claude получает финальный вывод и продолжает работу над задачей

Этот подход особенно полезен для:

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



Основные концепции



Поле allowed_callers

Поле allowed_callers указывает, какие контексты могут вызывать инструмент:

{
  "name": "query_database",
  "description": "Execute a SQL query against the database",
  "input_schema": {
    // ...
  },
  "allowed_callers": ["code_execution_20260120"]
}

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

• ["direct"] — Claude направляется на прямой вызов этого инструмента (по умолчанию, если опущено)
• ["code_execution_20260120"] — Claude направляется на вызов этого инструмента только из выполнения кода
• ["direct", "code_execution_20260120"] — Claude может вызывать этот инструмент напрямую или из выполнения кода

Как "code_execution_20260120", так и "code_execution_20260521" принимаются в allowed_callers и взаимозаменяемы: запрос, использующий любую версию инструмента выполнения кода, удовлетворяет инструментам, в которых указан любой из этих вызывающих контекстов. Блоки ответа всегда помечают вызывающий контекст как code_execution_20260120 независимо от того, какая версия была объявлена в запросе.



Поле caller в ответах

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

Прямой вызов (традиционное использование инструментов):

{
  "type": "tool_use",
  "id": "toolu_abc123",
  "name": "query_database",
  "input": { "sql": "<sql>" },
  "caller": { "type": "direct" }
}

Программный вызов:

{
  "type": "tool_use",
  "id": "toolu_xyz789",
  "name": "query_database",
  "input": { "sql": "<sql>" },
  "caller": {
    "type": "code_execution_20260120",
    "tool_id": "srvtoolu_abc123"
  }
}

tool_id — это id блока server_tool_use выполнения кода, который сделал вызов, поэтому вы можете сопоставить каждый программный tool_use с запуском выполнения кода, который его произвёл.



Жизненный цикл контейнера

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

• Создание контейнера: новый контейнер создаётся для каждого запроса, если вы не переиспользуете существующий
• Идентификатор контейнера: возвращается в ответах в поле container вместе с временной меткой expires_at
• Переиспользование: передайте идентификатор контейнера обратно в следующем запросе, чтобы сохранить состояние. Пока программный вызов инструмента ожидает вашего результата, идентификатор контейнера в этом запросе обязателен, а не опционален: API отклоняет запрос без него.
• Истечение срока: expires_at сообщает, сколько времени осталось у контейнера. Простаивающие контейнеры в настоящее время освобождаются примерно через 5 минут, и ни один контейнер не может быть переиспользован более чем через 30 дней после его создания.



Пример рабочего процесса

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



Шаг 1: Начальный запрос

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

Форма запроса идентична примеру из раздела Быстрый старт: включите code_execution в ваш список инструментов, добавьте allowed_callers: ["code_execution_20260120"] к любому инструменту, который вы хотите, чтобы Claude вызывал из кода, и отправьте ваше пользовательское сообщение. Остальные шаги в этом рабочем процессе используют пользовательское сообщение "Query customer purchase history from the last quarter and identify our top 5 customers by revenue".



Шаг 2: Ответ API с вызовом инструмента

Claude пишет код, который вызывает ваш инструмент. API приостанавливается и возвращает:

{
  "role": "assistant",
  "content": [
    {
      "type": "text",
      "text": "I'll query the purchase history and analyze the results."
    },
    {
      "type": "server_tool_use",
      "id": "srvtoolu_abc123",
      "name": "code_execution",
      "input": {
        "code": "import json\n\nrows = json.loads(await query_database({'sql': '<sql>'}))\ntop_customers = sorted(rows, key=lambda x: x['revenue'], reverse=True)[:5]\nprint(f'Top 5 customers: {top_customers}')"
      }
    },
    {
      "type": "tool_use",
      "id": "toolu_def456",
      "name": "query_database",
      "input": { "sql": "<sql>" },
      "caller": {
        "type": "code_execution_20260120",
        "tool_id": "srvtoolu_abc123"
      }
    }
  ],
  "container": {
    "id": "container_xyz789",
    "expires_at": "2026-01-20T14:30:00Z"
  },
  "stop_reason": "tool_use"
}



Шаг 3: Предоставление результата инструмента

Отправьте полную историю разговора плюс результат вашего инструмента. В этом запросе важны три детали:

• Пользовательское сообщение, которое несёт ваш результат, может содержать только блоки tool_result. См. Ограничения форматирования сообщений.
• Передайте идентификатор container из приостановленного ответа. API отклоняет продолжение, в котором есть ожидающие программные вызовы инструментов, но нет идентификатора контейнера.
• Отправьте тот же массив tools, что и в исходном запросе. Инструмент выполнения кода должен по-прежнему присутствовать, чтобы приостановленный код мог возобновиться, а инструменты, которые вы отправляете в этом запросе, — это определения, которые Claude и выполняющийся код могут использовать до конца хода.

response = client.messages.create(
    model="claude-opus-4-8",
    max_tokens=4096,
    container="container_xyz789",  # Reuse the container
    messages=[
        {
            "role": "user",
            "content": "Query customer purchase history from the last quarter and identify our top 5 customers by revenue",
        },
        {
            "role": "assistant",
            "content": [
                {
                    "type": "text",
                    "text": "I'll query the purchase history and analyze the results.",
                },
                {
                    "type": "server_tool_use",
                    "id": "srvtoolu_abc123",
                    "name": "code_execution",
                    "input": {"code": "..."},
                },
                {
                    "type": "tool_use",
                    "id": "toolu_def456",
                    "name": "query_database",
                    "input": {"sql": "<sql>"},
                    "caller": {
                        "type": "code_execution_20260120",
                        "tool_id": "srvtoolu_abc123",
                    },
                },
            ],
        },
        {
            "role": "user",
            "content": [
                {
                    "type": "tool_result",
                    "tool_use_id": "toolu_def456",
                    "content": '[{"customer_id": "C1", "revenue": 45000}, {"customer_id": "C2", "revenue": 38000}, ...]',
                }
            ],
        },
    ],
    # Тот же массив инструментов, что и в исходном запросе
    tools=[
        {"type": "code_execution_20260120", "name": "code_execution"},
        {
            "name": "query_database",
            "description": "Execute a SQL query against the sales database. Returns a list of rows as JSON objects.",
            "input_schema": {
                "type": "object",
                "properties": {
                    "sql": {"type": "string", "description": "SQL query to execute"}
                },
                "required": ["sql"],
            },
            "allowed_callers": ["code_execution_20260120"],
        },
    ],
)

print(response)



Шаг 4: Следующий вызов инструмента или завершение

Код продолжает с того места, где он приостановился, и обрабатывает ваш результат. Каждый ответ продолжения либо снова приостанавливается с дополнительными программными блоками tool_use, либо завершает выполнение кода и позволяет Claude продолжить ход (Шаг 5). Проверьте stop_reason и поле caller каждого блока tool_use, чтобы различить эти два случая: ответ, который приостанавливается для вас, имеет stop_reason: "tool_use" и блок tool_use, чей caller указывает версию выполнения кода, и вы повторяете Шаг 3 с tool_result для каждого ожидающего программного вызова в одном пользовательском сообщении.



Шаг 5: Финальный ответ

После завершения выполнения кода Claude предоставляет финальный ответ:

{
  "content": [
    {
      "type": "code_execution_tool_result",
      "tool_use_id": "srvtoolu_abc123",
      "content": {
        "type": "code_execution_result",
        "stdout": "Top 5 customers: [{'customer_id': 'C1', 'revenue': 45000}, {'customer_id': 'C2', 'revenue': 38000}, {'customer_id': 'C5', 'revenue': 32000}, {'customer_id': 'C8', 'revenue': 28500}, {'customer_id': 'C3', 'revenue': 24000}]",
        "stderr": "",
        "return_code": 0,
        "content": []
      }
    },
    {
      "type": "text",
      "text": "I've analyzed the purchase history from last quarter. Your top 5 customers generated $167,500 in total revenue, with Customer C1 leading at $45,000."
    }
  ],
  "stop_reason": "end_turn"
}



Продвинутые паттерны



Пакетная обработка с циклами

Claude может писать код, который эффективно обрабатывает несколько элементов:

regions = ["West", "East", "Central", "North", "South"]
results = {}
for region in regions:
    rows = json.loads(await query_database({"sql": f"<sql for {region}>"}))
    results[region] = sum(row["revenue"] for row in rows)

# Программная обработка результатов
top_region = max(results.items(), key=lambda x: x[1])
print(f"Top region: {top_region[0]} with ${top_region[1]:,} in revenue")

Этот паттерн:

• Сокращает количество обращений к модели с N (по одному на регион) до 1
• Обрабатывает большие наборы результатов программно перед возвратом к Claude
• Экономит токены, возвращая только агрегированные выводы вместо сырых данных



Досрочное завершение

Claude может прекратить обработку, как только критерии успеха выполнены:

endpoints = ["us-east", "eu-west", "apac"]
for endpoint in endpoints:
    status = await check_health({"endpoint": endpoint})
    if status == "healthy":
        print(f"Found healthy endpoint: {endpoint}")
        break  # Stop early, don't check remaining



Условный выбор инструмента

path = "/tmp/example.txt"
file_info = json.loads(await get_file_info({"path": path}))
if file_info["size"] < 10000:
    content = await read_full_file({"path": path})
else:
    content = await read_file_summary({"path": path})
print(content)



Фильтрация данных

server_id = "srv-01"
log_text = await fetch_logs({"server_id": server_id})
errors = [line for line in log_text.splitlines() if "ERROR" in line]
print(f"Found {len(errors)} errors")
for error in errors[-10:]:  # Only return last 10 errors
    print(error)



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



Программный вызов инструмента

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

{
  "type": "tool_use",
  "id": "toolu_abc123",
  "name": "query_database",
  "input": { "sql": "<sql>" },
  "caller": {
    "type": "code_execution_20260120",
    "tool_id": "srvtoolu_xyz789"
  }
}



Обработка результата инструмента

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

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_abc123",
      "content": "[{\"customer_id\": \"C1\", \"revenue\": 45000, \"orders\": 23}, {\"customer_id\": \"C2\", \"revenue\": 38000, \"orders\": 18}, ...]"
    }
  ]
}



Завершение выполнения кода

Когда все вызовы инструментов удовлетворены и код завершается:

{
  "type": "code_execution_tool_result",
  "tool_use_id": "srvtoolu_xyz789",
  "content": {
    "type": "code_execution_result",
    "stdout": "Analysis complete. Top 5 customers identified from 847 total records.",
    "stderr": "",
    "return_code": 0,
    "content": []
  }
}



Обработка ошибок



Распространённые ошибки



Истечение срока контейнера во время вызова инструмента

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

{
  "type": "code_execution_tool_result",
  "tool_use_id": "srvtoolu_abc123",
  "content": {
    "type": "code_execution_result",
    "stdout": "",
    "stderr": "TimeoutError: Calling tool ['query_database'] timed out (no response after 270s).",
    "return_code": 0,
    "content": []
  }
}

Чтобы предотвратить тайм-ауты:

• Отслеживайте поле expires_at в ответах
• Реализуйте тайм-ауты для выполнения ваших инструментов
• Рассмотрите возможность разбиения длительных операций на более мелкие части



Ошибки выполнения инструмента

Если ваш инструмент возвращает ошибку:

{
  "type": "tool_result",
  "tool_use_id": "toolu_abc123",
  "content": "Error: Query timeout - table lock exceeded 30 seconds"
}

Код Claude получает эту ошибку и может обработать её соответствующим образом.



Ограничения и лимиты



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

• Структурированные выводы: инструменты с strict: true не поддерживаются с программным вызовом
• Выбор инструмента: вы не можете принудительно вызвать программный вызов конкретного инструмента через tool_choice
• Параллельное использование инструментов: disable_parallel_tool_use: true не поддерживается с программным вызовом



Ограничения схемы ввода

Пользовательские инструменты, чья input_schema содержит рекурсивный $ref (цикл ссылок, например схема, которая ссылается сама на себя), не могут быть включены для программного вызова. Включение версии инструмента выполнения кода в allowed_callers для такого инструмента приводит к сбою запроса с ошибкой 400 invalid_request_error, сообщение которой содержит Circular $ref detected. Та же схема принимается для прямого вызова инструмента.

Чтобы обойти это, выполните одно из следующих действий:

• Оставьте инструмент только для прямого вызова, опустив allowed_callers (или установив его в ["direct"]). Другие инструменты в том же запросе по-прежнему могут использовать программный вызов.
• Удалите цикл из схемы. Например, разверните рекурсию до фиксированной глубины и опишите любую более глубокую вложенность в description самого внутреннего уровня, или замените рекурсивное свойство на обычный {"type": "object"}, чей description объясняет ожидаемую форму.



Ограничения инструментов

Следующие инструменты не могут быть вызваны программно:

• Инструменты, предоставляемые коннектором MCP



Ограничения форматирования сообщений

При ответе на программные вызовы инструментов существуют строгие требования к форматированию:

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

Недопустимо — нельзя включать текст при ответе на программные вызовы инструментов:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01",
      "content": "[{\"customer_id\": \"C1\", \"revenue\": 45000}]"
    },
    { "type": "text", "text": "What should I do next?" }
  ]
}

Допустимо — только результаты инструментов при ответе на программные вызовы инструментов:

{
  "role": "user",
  "content": [
    {
      "type": "tool_result",
      "tool_use_id": "toolu_01",
      "content": "[{\"customer_id\": \"C1\", \"revenue\": 45000}]"
    }
  ]
}

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

Содержимое результата инструмента только в виде текста: content каждого tool_result, отвечающего на программный вызов, должен быть строкой или блоками text. Блоки изображений, документов и других типов контента отклоняются.



Ограничения скорости

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



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

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

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



Эффективность токенов

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

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

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

Во внутренних оценках Anthropic на производственной модели Claude:

• В бенчмарке агента управления проектами с 75 инструментами включение программного вызова инструментов сократило тарифицируемые входные токены примерно на 38% без изменения точности выполнения задач.
• В τ²-bench (домены авиаперевозок, розничной торговли и телекоммуникаций), где каждый ход делает один или два последовательных вызова инструментов, программный вызов инструментов оставил оценки без изменений и стоил примерно на 8% больше. Последовательные рабочие процессы с одиночными вызовами не получают выгоды.
• По всему производственному трафику API запросы, чей массив tools содержит от 10 до 49 определений инструментов, показывают типичную экономию токенов от 20% до 40% при включённом программном вызове инструментов.

Фактическая экономия варьируется в зависимости от формы рабочей нагрузки. См. Когда использовать программный вызов.



Использование и цены

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



Лучшие практики



Проектирование инструментов

• Предоставляйте подробные описания вывода: поскольку Claude десериализует результаты инструментов в коде, документируйте формат (структуру JSON и типы полей)
• Возвращайте структурированные данные: JSON или другие машиночитаемые форматы лучше всего подходят для программной обработки
• Делайте ответы краткими: возвращайте только необходимые данные, чтобы минимизировать накладные расходы на обработку



Когда использовать программный вызов

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

Хорошо подходит:

• Веерные или параллельные операции над многими элементами (например, проверка 50 конечных точек или поиск 20 записей)
• Большие результаты инструментов, которые можно отфильтровать, агрегировать или суммировать до попадания в контекст Claude
• Агентный поиск и извлечение, где итеративные запросы и фильтрация результатов доминируют в рабочем процессе

Плохо подходит:

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

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



Оптимизация производительности

• Переиспользуйте контейнеры при выполнении нескольких связанных запросов для сохранения состояния
• Группируйте похожие операции в одном выполнении кода, когда это возможно



Устранение неполадок



Распространённые проблемы

invalid_request_error при установке tool_choice

• tool_choice не может указывать инструмент, чей allowed_callers не содержит "direct". Либо добавьте "direct" в allowed_callers этого инструмента, либо удалите инструмент из tool_choice и позвольте Claude вызывать его из кода.

Истечение срока контейнера

• Отвечайте на каждый программный вызов инструмента задолго до временной метки expires_at приостановленного ответа. Код Claude прекращает ожидание результата примерно через 4 минуты, а простаивающие контейнеры в настоящее время освобождаются примерно через 5 минут.
• Рассмотрите возможность реализации более быстрого выполнения инструментов

Результат инструмента не разбирается корректно

• Убедитесь, что ваш инструмент возвращает строковые данные, которые Claude может десериализовать
• Предоставьте чёткую документацию формата вывода в описании вашего инструмента



Советы по отладке

1. Логируйте все вызовы инструментов и результаты, чтобы отслеживать поток
2. Проверяйте поле caller, чтобы подтвердить программный вызов
3. Отслеживайте идентификаторы контейнеров, чтобы обеспечить правильное переиспользование
4. Тестируйте инструменты независимо перед включением программного вызова



Почему программный вызов инструментов работает

Claude обучен на больших объёмах кода, поэтому представление инструментов как вызываемых функций Python позволяет ему использовать эту сильную сторону:

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



Альтернативные реализации

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



Прямое выполнение на стороне клиента

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

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

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

Недостатки:

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

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



Самоуправляемое изолированное выполнение

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

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

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

Недостатки:

• Сложно построить и поддерживать
• Требует управления как инфраструктурой, так и межпроцессным взаимодействием

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



Управляемое выполнение от Anthropic

Программный вызов инструментов от Anthropic — это управляемая версия изолированного выполнения с предопределённой средой Python, настроенной для Claude. Anthropic берёт на себя управление контейнерами, выполнение кода и безопасную коммуникацию вызовов инструментов.

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

• Безопасно и защищено по умолчанию
• Включается определением инструмента, без инфраструктуры для запуска
• Среда и инструкции оптимизированы для Claude

Рассмотрите использование управляемого решения Anthropic, если вы используете Claude API, Claude Platform on AWS или Microsoft Foundry. В Microsoft Foundry программный вызов инструментов требует развёртывания Hosted on Anthropic.



Хранение данных

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

О соответствии требованиям ZDR для всех функций см. API и хранение данных.



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