Tool calling: как ИИ вызывает инструменты

Когда вы спрашиваете у чат-бота «какая погода в Москве», языковая модель сама по себе ответить не может: у неё нет доступа к прогнозу, она лишь предсказывает текст. Чтобы получить реальные данные, модель должна вызвать внешнюю функцию — обратиться к погодному сервису, к базе данных, к вашей CRM. Механизм, который это позволяет, называется tool calling (вызов инструментов). Именно он превращает «болтливую» нейросеть в рабочий инструмент, который умеет действовать, а не только рассуждать.

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

Что такое tool calling простыми словами

Tool calling (в документации OpenAI исторически — function calling) — это способность модели во время генерации ответа не писать текст, а вернуть структурированный запрос: «вызови такую-то функцию с такими-то аргументами». Важно понять ключевую деталь: модель сама инструмент не выполняет. Она не ходит в интернет и не лезет в вашу базу. Она лишь формирует корректный JSON с именем функции и параметрами, а фактический вызов делает ваш код. Затем результат возвращается модели, и она формулирует человеческий ответ.

Такое разделение ответственности удобно и безопасно: вы полностью контролируете, что именно и с какими правами исполняется. Модель предлагает — приложение решает. Этот же принцип лежит в основе AI-агентов: агент — это цикл, в котором модель раз за разом вызывает инструменты, получает результаты и двигается к цели.

Как это работает: цикл запрос — ответ

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

Шаг 1. Вы описываете инструменты

В запрос к модели вы кладёте список доступных инструментов. Каждый инструмент описывается тремя вещами: имя (name), описание (description — когда и зачем его применять) и схема входных параметров в формате JSON Schema. Описание критически важно: именно по нему модель понимает, какой инструмент подходит под запрос пользователя. Плохое описание — и модель либо не вызовет функцию, либо вызовет не ту.

Шаг 2. Модель решает вызвать инструмент

Получив вопрос пользователя и список инструментов, модель сама выбирает: ответить текстом или запросить вызов. Если нужен инструмент, ответ приходит в особом виде. У Claude это блок с типом tool_use, а поле stop_reason равно "tool_use"; блок содержит id, name и input (аргументы). У OpenAI ответ содержит массив tool calls, где у каждого есть id, type: "function" и объект function с полями name и arguments (JSON-строка).

Шаг 3. Ваш код выполняет функцию

Приложение разбирает имя и аргументы, выполняет реальное действие — запрос к API погоды, SQL-выборку, отправку письма — и получает результат. На этом шаге вы вольны проверить аргументы, наложить лимиты и права. Модель не имеет доступа ни к чему, кроме того, что вы ей сами вернёте.

Шаг 4. Результат возвращается модели

Результат отправляется обратно тем же запросом, но с добавленной историей. У Claude вы добавляете сообщение роли user с блоком tool_result, где указываете tool_use_id (тот самый id из шага 2) и содержимое. У OpenAI добавляется сообщение роли tool с полями tool_call_id и content. Модель видит результат и выдаёт финальный текст — либо запрашивает следующий инструмент, и цикл повторяется.

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

Вот минимальная схема инструмента «узнать погоду» в стиле Claude:

{
  "name": "get_weather",
  "description": "Вернуть текущую погоду для города",
  "input_schema": {
    "type": "object",
    "properties": {
      "location": {
        "type": "string",
        "description": "Город, например: Москва"
      }
    },
    "required": ["location"]
  }
}

У OpenAI структура почти такая же, но обёрнута иначе: на верхнем уровне указывается "type": "function", а схема параметров лежит в поле parameters (у Claude — input_schema). И там, и там рекомендуется включать strict-режим (strict: true) — он заставляет модель строго соблюдать схему и не выдумывать лишних полей, что резко снижает число ошибок парсинга.

OpenAI и Claude: различия в терминах

Концепция одна, но названия полей отличаются, и это частый источник путаницы при переносе кода. Коротко о главных расхождениях: у OpenAI инструмент оборачивается в type: "function", схема параметров — parameters, ответ модели — массив tool_calls, результат возвращается ролью tool с tool_call_id. У Claude инструмент описывается плоско, схема — input_schema, ответ — блоки tool_use внутри контента ассистента, результат — блок tool_result с tool_use_id в сообщении роли user. Логика идентична, отличается «упаковка». Если вы только начинаете, полезно сперва пройти базовый старт по каждому провайдеру: OpenAI API и Claude API.

Параллельные вызовы и управление выбором

Современные модели умеют за один ответ запросить сразу несколько инструментов — например, узнать погоду в трёх городах одновременно. Это параллельный вызов инструментов: вы выполняете все функции и возвращаете все результаты в одном следующем запросе. У Claude это поведение по умолчанию (отключается флагом disable_parallel_tool_use).

Отдельно есть управление тем, должна ли модель вообще вызывать инструмент. Параметр tool_choice позволяет задать режим: auto — модель решает сама; можно принудительно потребовать вызвать какой-то инструмент или, наоборот, запретить вызовы и заставить ответить текстом. Это удобно, когда сценарий жёстко детерминирован и вы точно знаете, что на этом шаге нужен конкретный инструмент.

Что нового к 2026 году

По мере роста числа инструментов у разработчиков появились новые проблемы: описания десятков функций съедают контекст, а результаты промежуточных вызовов засоряют историю. В ответ Anthropic представила несколько продвинутых механизмов (на момент выхода — в статусе беты).

Tool Search Tool. Вместо того чтобы грузить в контекст все определения инструментов сразу (для крупных наборов это десятки тысяч токенов), модель ищет нужный инструмент по запросу и подключает его «на лету». По данным Anthropic, это даёт до 85% экономии токенов и заметно повышает точность выбора инструмента.

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

Tool Use Examples. К JSON-схеме можно приложить примеры реальных вызовов. Схема задаёт структуру, но не показывает как ей пользоваться; примеры закрывают этот пробел и повышают точность на непростых параметрах.

Tool calling и MCP: в чём связь

Tool calling отвечает на вопрос «как модель вызывает функцию», а MCP (Model Context Protocol) — на вопрос «откуда берутся эти функции и как их подключать единообразно». MCP-сервер публикует набор инструментов по стандартному протоколу, а клиент (Claude, редактор кода, ваш агент) их подхватывает. Под капотом всё равно работает тот же цикл tool calling, просто описания инструментов приходят не из вашего кода, а от сервера. Если хотите разобраться в экосистеме — посмотрите обзор MCP-серверов.

Частые ошибки новичков

Первая и главная — слабые описания инструментов. Модель выбирает функцию по описанию; если оно расплывчатое, вызовы будут мимо. Пишите description так, будто объясняете коллеге, когда именно нажимать эту кнопку. Вторая ошибка — не возвращать результат в правильном формате: перепутанный tool_use_id/tool_call_id ломает диалог. Третья — доверять аргументам без проверки: модель может передать некорректные или опасные значения, поэтому валидируйте вход и ограничивайте права, особенно если инструмент что-то меняет или удаляет. Четвёртая — забыть про strict-режим и потом бороться с невалидным JSON. И, наконец, качество вызовов сильно зависит от формулировок — здесь помогут приёмы из заметки про промпт-инжиниринг.

Вывод

Tool calling — это мост между рассуждающей моделью и реальным миром. Модель не выполняет действия сама: она возвращает структурированный запрос на вызов функции, ваш код исполняет его и отдаёт результат обратно. Весь механизм умещается в простой цикл из четырёх шагов, одинаковый по сути у OpenAI и Anthropic и отличающийся лишь именами полей. Освоив этот цикл, вы получаете основу для всего остального — от простого чат-бота с доступом к базе до полноценного автономного агента. Начните с одного инструмента, добейтесь стабильных вызовов, включите strict-режим — и постепенно наращивайте набор функций.