Знакомство с языком MQL5 (Часть 33): Освоение API и функции WebRequest в языке MQL5 (VII)

Введение

И снова приветствуем вас в Части 33 серии "Знакомство с языком MQL5"! В предыдущих частях этой серии мы сосредоточились на том, как язык MQL5 может взаимодействовать с внешними платформами, используя API и функцию WebRequest. Вы научились отправлять HTTP-запросы, получать и интерпретировать ответы сервера, организовывать свечные данные, сохранять их в файлы и визуализировать эти данные в пользовательских индикаторах. Эти шаги помогли создать прочную основу для работы с внешними данными в MetaTrader 5.

В этой статье мы подключаем MetaTrader 5 к API Google Generative AI, чтобы разобрать более сложный и практичный сценарий использования. Мы рассмотрим отправку текстовых запросов, получение интеллектуальных ответов, корректное форматирование тела запроса, разбор ответов сервера, извлечение ценной информации из JSON и управление лимитами API (запросы в минуту, запросы в день и токены в минуту).

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

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

Частота, с которой вы можете отправлять запросы к API (например, к API Google), ограничена установленными лимитами. Эти ограничения введены для поддержания стабильности системы и обеспечения равного доступа для всех пользователей. Без них слишком большое число запросов может перегрузить сервер, что приведет к ошибкам или замедлениям и повлияет не только на вашу программу, но и на других пользователей. Цель ограничений по частоте запросов – контролировать трафик API и предотвращать злоупотребления. Они задают точные лимиты на частоту взаимодействия между вашей программой и сервером – в минуту или в день. Благодаря этому подходу все пользователи сохраняют равный доступ, и ни один пользователь не может контролировать все ресурсы сервера.

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

Аналогия:

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

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

Запросы в минуту

Понимание того, как на самом деле работают ограничения по частоте запросов, – следующий шаг после осознания того, что запросы не безграничны. RPM – первое и самое значимое ограничение. Количество отдельных API-запросов, которые ваша программа может отправить на сервер за минуту, называется requests per minute (запросы в минуту, RPM). Каждый раз, когда ваша программа на языке MQL5 взаимодействует с API через WebRequest, это засчитывается как один запрос в счет этого лимита. Использование RPM увеличивается независимо от того, насколько простым или сложным является запрос. Например, если для вашей программы установлен лимит 60 RPM, она может отправлять до 60 запросов в минуту. Вы можете отправлять больше одного запроса одновременно, и вам не нужно ждать ровно одну секунду между запросами. Любые дополнительные запросы могут быть отклонены или отложены до начала следующей минуты, как только будет достигнуто значение 60.

Цель – не допустить, чтобы ваша программа отправляла слишком много запросов на сервер за короткий промежуток времени. Сервер может замедлиться, возвращать ошибки или на короткое время блокировать новые запросы, если их приходит одновременно слишком много. Устанавливая ограничения, поставщики API гарантируют, что все пользователи смогут надежно получать доступ к сервису. На практике важно следить за тем, как часто ваша программа на языке MQL5 отправляет запросы. Лимит RPM можно легко превысить, отправив несколько запросов одновременно или быстро один за другим.

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

Запросы в день

RPD – еще один значимый лимит. RPD указывает максимальное количество запросов, которые ваша программа может отправить за один день, в отличие от RPM, который регулирует количество запросов в минуту. Контроль ежедневного расхода важен для разработчиков на языке MQL5, которые работают с частыми вызовами API. Работа программы может быть затруднена, если будет достигнут лимит RPD, так как дальнейшие запросы могут быть отклонены до сброса дневного лимита, который обычно происходит в полночь по UTC. Чтобы не превышать ограничения RPD, оптимизируйте программу: отправляйте только необходимые запросы и, когда это возможно, повторно используйте ранее полученные данные. Сокращение лишних вызовов, кэширование результатов и объединение нескольких запросов в один – эффективные способы обеспечить работу сервиса в течение всего дня и при этом соблюдать суточный лимит запросов.

Токены в минуту

Еще один важный аспект использования API – ограничения по количеству токенов, особенно для API на основе ИИ, таких как API Google Generative AI. TPM учитывает объем вычислительного или текстового контента, обрабатываемого в минуту, в отличие от RPM или RPD, которые учитывают запросы. На самом деле каждый запрос использует определенное количество токенов – по сути, это текстовые сегменты, которые включают и отправленный вами запрос, и ответ, сгенерированный API. Это помогает обеспечить, чтобы сложные или объемные запросы не перегружали API‑сервер. Отправка длинных промптов или запрос больших ответов быстро исчерпают квоту TPM, даже если ваша программа соблюдает ограничения RPM и RPD. Крайне важно отслеживать использование токенов, так как после достижения лимита дополнительные запросы будут отложены или отклонены до следующей минуты.

Чтобы эффективно управлять лимитом в языке MQL5, вы можете уменьшить размер промптов, ограничить создание лишнего текста и, если это возможно, повторно использовать или сокращать ранее полученные ответы. Отслеживая потребление токенов и оптимизируя его, вы можете поддерживать бесперебойное взаимодействие с API и избегать сбоев из‑за превышения лимита токенов в минуту. Потребление токенов рассчитывается путем подсчета всех токенов, которые API обрабатывает за минуту. Токен в API искусственного интеллекта может быть знаком препинания, целым словом или частью слова. Например, фраза "Hello, world!" представляет собой четыре токена: "Hello,", "world" и "!". Этот общий объем включает как текст запроса, который вы отправляете, так и ответ, сгенерированный ИИ.

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

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

Генерация API-ключа

Прежде чем использовать API, важно понимать, что такое API‑ключ, и как он работает. API‑ключ – это специальный код, который поставщик API назначает вашему приложению, чтобы идентифицировать его. Это позволяет серверу отслеживать использование и аутентифицировать запросы. API обычно отклоняет запросы без действительного ключа, потому что не может проверить источник или контролировать лимиты. Кроме того, API-ключ помогает поставщику услуг отслеживать использование, применять ограничения по частоте запросов и предотвращать нежелательный доступ к API. Сервер может применять ограничения (RPM, RPD и TPM) именно к вашей учетной записи, потому что каждый запрос, который вы отправляете, содержит этот ключ. Проще говоря, этот ключ позволяет серверу реагировать корректно, сообщая API: "Этот запрос исходит от меня".

Как уже упоминалось в этой статье, наши примеры будут использовать бесплатный API Google. Чтобы взаимодействовать с API Gemini от Google, используя язык MQL5, сначала нужно создать API‑ключ. В зависимости от требований API этот ключ будет находиться либо в теле запроса, либо в заголовках WebRequest. В следующем разделе вы узнаете, как пошагово создать этот ключ и подготовить его к использованию в программах на языке MQL5.

Аналогия:

Представьте себе библиотеку, где посетители должны предъявить действующую библиотечную карту, чтобы получить доступ к книгам. Карта подтверждает личность посетителя и помогает библиотекарю отслеживать количество и частоту выдачи книг. Доступ к книгам без нее запрещен. В этом случае книги – это ответы, которые возвращает API, библиотечная карта служит API‑ключом, а библиотекаря представляет API‑сервер.

Чтобы использовать API Google Generative AI, сначала нужно создать API‑ключ. Этот ключ позволит серверам Google идентифицировать ваше приложение и аутентифицировать ваши запросы из кода MQL5. Для начала откройте браузер и перейдите на aistudio.google.com. Когда страница загрузится, найдите и нажмите "Get API Key". Это перенаправит вас в раздел, где можно создавать API‑ключи для AI‑сервисов Google и управлять ими.

После этого выберите "Create API Key". Появится окно с просьбой указать имя ключа. Это имя нужно в первую очередь для вас: оно помогает понимать назначение ключа, особенно если в будущем вы планируете создать несколько ключей. Создайте ключ после того, как введете подходящее имя. После генерации Google покажет ключ на экране. На этом этапе крайне важно сразу скопировать и сохранить API‑ключ. Храните ключ в безопасном месте, например, в менеджере паролей или защищенном текстовом файле. Позже, при выполнении запросов WebRequest из кода MQL5, вам понадобится этот ключ; если он будет утерян или скомпрометирован, возможно, придется создать новый.

Отправка запросов к Google AI в языке MQL5

Следующий шаг после получения API‑ключа – включить отправку запросов из языка MQL5 в API Google Generative AI. Для этого нужно предоставить MetaTrader 5 доступ к эндпоинту API. Перед продолжением нажмите Ctrl + O, чтобы открыть окно "Настройки", выберите вкладку "Советники" и в поле "Разрешить WebRequest для следующих URL" добавьте URL API. 

https://generativelanguage.googleapis.com

Поскольку MetaTrader 5 автоматически ограничивает внешние веб-запросы по соображениям безопасности, этот шаг крайне важен. Добавляя этот URL, вы явно сообщаете MetaTrader 5, что вашей программе на языке MQL5 разрешено отправлять запросы к API Google. После этого вы можете написать код на языке MQL5, который использует WebRequest для отправки и получения данных. Следующий шаг после генерации API‑ключа и добавления URL в список разрешенных в MetaTrader 5 – написать MQL5‑скрипт, который отправляет запрос WebRequest. Этот скрипт будет создавать запрос, прикреплять API‑ключ, передавать данные в API Google Generative AI и получать ответ сервера.

Пример:

string API_KEY = "AbcdefCKJXiFPdvvM6f4ivPZ-zA2Qnoq6gabcde";
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   string url =  "https://generativelanguage.googleapis.com/v1beta/models/"
                 "gemini-2.5-flash-lite:generateContent?key=" + API_KEY;

  }

Пояснение:

Первый шаг – определить API-ключ: это учетные данные Google, которые вы создали ранее. Этот ключ необходим для аутентификации каждого запроса к API Google Generative AI. Поскольку он идентифицирует вашу учетную запись или проект, сервер может отслеживать использование и применять ограничения (токены в минуту, запросы в минуту и запросы в день). Если хранить API-ключ в переменной, его легко повторно использовать каждый раз, когда ваша программа на языке MQL5 отправляет запрос. Еще одна важная идея – понимать, как формируется URL API-запроса. Полный URL состоит из домена, пути и строки запроса. Домен указывает целевой сервер и показывает, что используется защищенное соединение. В нашем случае он направляет запросы на сервер Google Generative AI, который обрабатывает входящие запросы.

Путь, который идет сразу после домена, описывает конкретный ресурс или действие, которое должен выполнить сервер. Он указывает конкретную модель ИИ и выполняемую операцию, а также содержит версию API. Эта часть URL явно указывает серверу, что нужно сделать при получении запроса. Строка запроса, которая содержит дополнительную информацию, необходимую для выполнения запроса, – последняя часть. Здесь передается API-ключ, чтобы сервер мог подтвердить запрос. Строка запроса позволяет передавать несколько параметров и настраивать запрос.

Когда эти компоненты объединяются, получается полный URL, который позволяет MetaTrader 5 взаимодействовать с API Google Generative AI. Путь задает действие, строка запроса обеспечивает идентификацию, а домен определяет, куда отправляется запрос. Эта структура гарантирует точное и безопасное взаимодействие между функцией WebRequest и API.

Аналогия:

API-ключ работает аналогично библиотечной карте. API-ключ идентифицирует ваше приложение на сервере Google и дает доступ к его AI-сервисам – так же, как библиотечная карта подтверждает вашу личность и позволяет брать книги. Без карты или ключа доступ ограничен, и ответы не предоставляются. Путь в URL можно сравнить с некой определенной областью библиотеки. Когда вы ищете конкретную тему, вы переходите прямо в нужный раздел, где находятся требуемые книги. Аналогичным образом, путь направляет запрос к конкретной модели ИИ и точно указывает, что нужно сделать.

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

Следующий этап – добавить все необходимые параметры WebRequest. Это включает определение тела запроса, заголовков и метода запроса. Эти параметры задают для MetaTrader 5, какие данные отправлять, как интерпретировать ответ и как взаимодействовать с API Google Generative AI. Если эти параметры указаны корректно, ваш скрипт на языке MQL5 сможет отправлять запросы, получать ответы и управлять данными, которые возвращает API.

Пример:

string API_KEY = "AbcdyCKJXiFPdvvM6f4ivPZ-zA2Qnoq6gabcde";
//+------------------------------------------------------------------+
//| Script program start function                                    |
//+------------------------------------------------------------------+
void OnStart()
  {
//---
   string url =  "https://generativelanguage.googleapis.com/v1beta/models/"
                 "gemini-2.5-flash-lite:generateContent?key=" + API_KEY;

   string headers = "Content-Type: application/json\r\n";
   string body = "{"
                 "\"contents\": ["
                 "{"
                 "\"parts\": ["
                 "{"
                 "\"text\": \"Tell me about MQL5\""
                 "}"
                 "]"
                 "}"
                 "]"
                 "}";

   char data[];
   int copied = StringToCharArray(body, data, 0, WHOLE_ARRAY, CP_UTF8);

   if(copied > 0)
      ArrayResize(data, copied - 1);

   char result[];
   string result_headers;
   int timeout = 15000;

   int response = WebRequest("POST",url,headers,timeout,data,result,result_headers);

   if(response == -1)
     {
      Print("WebRequest failed. Error: ", GetLastError());
      return;
     }

   string response_text = CharArrayToString(result);
   Print(response_text);

  }

Пояснение:

Первый этап отправки WebRequest – определить заголовки запроса. Здесь заголовок сообщает серверу, что данные представлены в формате JSON, и тем самым задает способ их интерпретации. Это гарантирует, что сервер сможет корректно обработать запрос, поскольку API Google Generative AI принимает запросы в формате JSON. По сути, заголовки содержат метаданные, которые управляют обработкой входящих данных на сервере. Данные подготавливаются в соответствии с требованиями API и отправляются в тело запроса. В Gemini AI используется JSON-объект с массивом "contents", элементы которого содержат массив "parts" с полем "text" для промпта к ИИ.

'{
"contents":
[
   {
 "parts": [
      {
 "text": "How does AI work?"
      }
    ]
  }
]
  }'

Такая структура гарантирует, что сервер сможет корректно прочитать сообщение и ответить. Чтобы API мог обработать тело запроса, оно должно строго соответствовать формату. Поскольку функция WebRequest в языке MQL5 требует, чтобы тело было массивом символов, строка преобразуется в массив, закодированный в UTF-8, чтобы все символы, включая специальные, передавались корректно. После преобразования удаляется нулевой символ, добавляемый по умолчанию, путем изменения размера массива символов. Выполняя этот шаг, вы гарантируете, что сервер получит корректные данные без лишних символов, которые могли бы сделать JSON некорректным.

Для хранения информации, которую возвращает сервер, инициализируются переменные. Задается таймаут для регулирования времени ожидания. Заголовки хранятся по-отдельности, а тело ответа – в массиве символов. Эти действия гарантируют, что скрипт сможет точно записать всю информацию, возвращаемую сервером. Функция WebRequest использует настроенные заголовки, содержимое и таймаут, чтобы выполнить запрос по URL. Возвращается код состояния, показывающий, был ли запрос успешным. Если запрос не выполнится, приложение остановится и выведет код последней ошибки – это важная информация для отладки и предотвращения использования некорректных данных.

Наконец, ответ сервера, полученный как массив символов, преобразуется обратно в строку. Благодаря этому преобразованию приложение теперь может читать, обрабатывать или отображать контент, созданный ИИ. Процесс отправки и получения WebRequest в языке MQL5 завершен, поскольку ответ включает данные, созданные ИИ на основе промпта, переданного в запросе.

Аналогия:

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

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

Это похоже на то, как вы преобразуете записку в формат, понятный библиотечной системе, превращая тело запроса в массив символов. В MQL5 строка преобразуется в массив, закодированный в UTF-8, чтобы сервер мог ее понять, – как если бы библиотекарь отсканировал QR‑код или ввел текст в компьютер для обработки. Удаление лишнего нулевого символа похоже на то, как вы проверяете, что записка не содержит ошибок или лишних пометок, которые могут запутать библиотекаря.

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

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

Вывод:

Извлечение ответа ИИ из данных, полученных от сервера

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

Пример:

string pattern = "\"text\": ";
int pattern_lenght = StringFind(response_text,pattern);
pattern_lenght += StringLen(pattern);

int end = StringFind(response_text,"}",pattern_lenght + 1);
string ai_response = StringSubstr(response_text,pattern_lenght,end - pattern_lenght);

Print(ai_response);

Вывод:

Пояснение:

Сначала задается строковая переменная "pattern" со значением "text". Это часть JSON-ответа, которая идет непосредственно перед текстом, сгенерированным ИИ. Этот паттерн помогает определить, где начинается контент ИИ, поскольку вывод ИИ находится в поле "text" в ответе сервера. Затем код использует функцию, чтобы найти этот паттерн во всем ответе сервера. После поиска в "response_text" функция возвращает индекс, с которого начинается паттерн. Чтобы указать позицию паттерна, этот индекс сохраняется в переменной. Затем к этому значению прибавляется длина самого паттерна. Это сдвигает индекс к началу текста, сгенерированного ИИ, сразу после "text":.". Индекс теперь указывает на первый символ ответа ИИ.

Следующий этап – определить конец текста ИИ. Чтобы получить первую закрывающую фигурную скобку } после начального индекса, используется другая функция. Этот индекс указывает на конец поля "text" в структуре JSON. После определения начальной и конечной позиции из исходного текста ответа извлекается подстрока. Извлечение выполняется от позиции, следующей за найденным шаблоном, до указанного конечного индекса. Это гарантирует, что будет извлечен только текст ИИ между начальной и конечной позициями. Для отображения извлеченного текста используется функция Print, а сам текст хранится в переменной ai_response. В результате лишние метаданные и форматирование JSON игнорируются, и из полного ответа сервера отображается только контент, сгенерированный ИИ.

Аналогия:

Полный ответ сервера похож на коробку из библиотеки: помимо нужной вам книги в ней есть заметки, закладки и квитанции. Книга, которая вас действительно интересует, – это текст, созданный ИИ. Поиск метки на корешке книги похож на первый этап, когда паттерн определяется как "text":.". Эта метка указывает, где в коробке начинается книга. Чтобы понять, с чего начать чтение, аналогия такая: поиск этого паттерна похож на то, как вы перебираете содержимое коробки, пока не найдете эту метку.

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

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

Вы можете заметить, что после вывода извлеченного ответа ИИ отображается не весь текст. Это связано с ограничением на отображение текста в окне "Эксперты" MetaTrader 5. Мы запишем ответ ИИ в текстовый файл, чтобы обойти это ограничение. Если сохранять ответ в файл, его проще оценивать, анализировать и хранить для последующего использования: вы сможете открывать его отдельно и читать полный текст без ограничений.

Пример:

string filename = "AI_RESPONSE.txt";
int handle = FileOpen(filename, FILE_WRITE|FILE_TXT|FILE_SHARE_READ|FILE_ANSI);

if(handle != INVALID_HANDLE)
  {

   FileWrite(handle, ai_response);
   FileClose(handle);
   Print("EA successfully wrote the data to " + filename);
  }
else
  {
   Print("Error opening file for writing. Error code: ", + GetLastError());
  }

Пояснение:

Первый шаг – выбрать имя файла для ответа ИИ. Выбирая имя файла, вы задаете название текстового файла и место, где MetaTrader 5 будет его хранить. По умолчанию файл будет находиться в папке Files терминала, поэтому его будет легко найти позже. После этого файл открывается с параметрами, которые определяют режим его работы. Другие программы могут одновременно получать доступ к файлу; запись в него разрешена; файл создается как обычный текстовый документ, а кодировка гарантирует корректное чтение. В процессе создается хэндл, представляющий этот файл.

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

Аналогия:

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

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

 

Заключение

В этой статье вы узнали, как подключить MetaTrader 5 к API Google Generative AI с помощью языка MQL5: от понимания лимитов API и генерации API‑ключа до подготовки среды, отправки запросов через WebRequest, корректного формирования тела запроса, извлечения только ответа ИИ из серверных данных и сохранения этого ответа в текстовый файл. Это позволяет обойти ограничения отображения текста в окне "Эксперты". В совокупности эти шаги показывают, как API искусственного интеллекта можно на практике встраивать в программы на языке MQL5, закладывая прочную основу для создания интеллектуальных инструментов – помощников, анализаторов и других функций, выходящих за рамки традиционной торговой логики.