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

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

🔍 Что такое протокол контекстной модели (MCP)?

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

Рассматривайте MCP как порт USB-C для приложений с искусственным интеллектом. Точно так же, как USB-C обеспечивает стандартизированный способ подключения устройств к различным периферийным устройствам и аксессуарам, MCP обеспечивает стандартизированный способ подключения моделей ИИ к различным источникам данных и инструментам.

🎯 Почему стандартизация в сфере ИИ имеет значение

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

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

💡 Почему протокол Model Context Protocol (MCP) меняет правила игры

🔗 MCP устраняет фрагментацию при взаимодействии с ИИ

До появления MCP интеграция модели с инструментами включала следующие этапы:

• Индивидуальный код для каждой пары инструмент-модель
• Нестандартные API для каждого поставщика
• Частые сбои из-за обновлений
• Плохая масштабируемость при использовании большего количества инструментов

✅ Преимущества стандартизации MCP

• Совместимость. LLM-модели легко интегрируются с инструментами разных производителей
• Согласованность. Единое поведение на разных платформах и в разных инструментах
• Возможность повторного использования. Инструменты, созданные один раз, можно использовать в разных проектах и системах
• Ускоренная разработка. Сократите время разработки, используя стандартизированные интерфейсы «подключи и работай»

🧱 Обзор архитектуры MCP на высоком уровне

По своей сути MCP представляет собой клиент-серверную архитектуру, в которой хост-приложение может подключаться к нескольким серверам:

• Хосты MCP (MCP Hosts): Такие программы, как Claude Desktop, IDE или инструменты искусственного интеллекта, которым требуется доступ к данным через MCP
• Клиенты MCP (MCP Clients): инициируют запросы, клиенты, поддерживающие индивидуальные соединения с серверами
• Серверы MCP (MCP Servers): Легковесные программы, каждая из которых предоставляет определённые возможности через стандартизированный протокол Model Context
• Локальные источники данных: файлы, базы данных и сервисы вашего компьютера, к которым серверы MCP могут получить безопасный доступ
• Удаленные сервисы: внешние системы, доступные через Интернет (например, через API), к которым могут подключаться серверы MCP

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

• Ресурсы (Resources) — статические или динамические данные для моделей
• Промты (Prompts) — готовые рабочие процессы для управляемой генерации
• Инструменты (Tools) — выполняемые функции, такие как поиск, вычисления
• Выборка (Sampling) — агентное поведение посредством рекурсивных взаимодействий

🌍 Реальные примеры использования MCP

MCP обеспечивает широкий спектр возможностей за счет расширения потенциала ИИ:

• Интеграция корпоративных данных. Подключение LLM к базам данных, CRM или внутренним инструментам
• Агентные системы искусственного интеллекта. Обеспечивают автономных агентов доступом к инструментам и рабочими процессами принятия решений
• Мультимодальные приложения. Объедините текстовые, графические и аудиоинструменты в одном унифицированном приложении с искусственным интеллектом
• Интеграция данных в режиме реального времени. Используйте данные в реальном времени для более точных и актуальных результатов

🧠 MCP = универсальный стандарт взаимодействия с искусственным интеллектом

Model Context Protocol (MCP) выступает в качестве универсального стандарта для взаимодействия с ИИ, подобно тому, как USB-C стандартизирует физические подключения устройств. В мире ИИ MCP обеспечивает согласованный интерфейс, позволяющий моделям (клиентам) легко интегрироваться с внешними инструментами и поставщиками данных (серверами). Это устраняет необходимость в различных пользовательских протоколах для каждого API или источника данных.

В рамках MCP инструмент, совместимый с MCP (называемый сервером MCP), соответствует единому стандарту. Эти серверы могут перечислять предлагаемые ими инструменты или действия и выполнять эти действия по запросу агента ИИ. Платформы агентов ИИ, поддерживающие MCP, могут находить доступные инструменты на серверах и вызывать их с помощью этого стандартного протокола.

💡 Облегчает доступ к знаниям

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

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

Такая оптимизированная интеграция соответствует схеме, изображённой на диаграмме «русалка», где серверы предоставляют как инструменты, так и знания, обеспечивая бесперебойное взаимодействие между системами.

✨Основной Telegram-канал со всеми обновлениями✨

📎 Присоединиться к закрытому клубу

Вам также может понравиться:

• LangGraph. Делаем State для LLM
• Запуск Llama 3.1 70b и 3.1 8b через Yandex облако
• Введение в Haystack

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

В этой статье мы разберем, как установить Docker на Ubuntu – шаг за шагом, без лишних сложностей. Независимо от того, создаете ли вы локальную среду для разработки или готовитесь к production, следуйте этому руководству, и через несколько минут у вас будет готовый к работе Docker. 🚀

Шаг 1. Установка Docker и Docker Compose

Для установки достаточно выполнить следующие 2 команды:

curl -fsSL https://get.docker.com -o get-docker.sh

sudo sh ./get-docker.sh

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

docker -v

docker compose version

Это подтвердит успешную установку и покажет версии установленных программ.

Шаг 2. Разрешаем Docker вызывать без sudo (необязательно)

По умолчанию команда docker может быть запущена только пользователем root или пользователем из группы docker, которая автоматически создается в процессе установки Docker. Если вы попытаетесь запустить команду docker без префикса sudo или не входя в группу docker, вы получите результат, подобный этому:

docker: Cannot connect to the Docker daemon.
Is the docker daemon running on this host?.
See 'docker run --help'.

Если вы хотите избежать ввода sudo при каждом запуске команды docker, добавьте своё имя пользователя в группу docker:

sudo usermod -aG docker ${USER}

Далее просто перелогиньтесь к своему пользователю (можно перезайти в терминал) и сможете использовать команду docker без sudo.

✨Основной Telegram-канал со всеми обновлениями✨

Вам также может понравиться:

• Первоначальная настройка сервера Ubuntu
• Как найти наиболее используемое дисковое пространство в Linux Ubuntu
• Введение в библиотеку LangGraph

✔️ Обучение Python с нуля за 9 месяцев 🔝

Часто многие LLM требуют историю сообщений, чтобы лучше понимать контекст.

Так как передача истории сообщений довольно частая ситуация, то рассмотрим на примере:

1. Как использовать State для определения схемы графа
2. Как использовать reducers для управления обработкой обновлений состояния.

Сперва установим библиотеки

pip install -U langgraph langchain

Пример простого графа

Состоянием (State) в LangGraph может быть TypedDict, Pydantic model или dataclass. Ниже мы будем использовать TypedDict.

Определим State

from langchain_core.messages import AnyMessage
from typing_extensions import TypedDict


class State(TypedDict):
    messages: list[AnyMessage]
    extra_field: int

В состоянии будем хранить историю сообщений.

Определим структуру графа

Давайте построим пример графа с одним узлом (node). Наш node - это просто функция Python, которая считывает состояние нашего графа и вносит в него изменения. Первым аргументом этой функции всегда будет состояние:

from langchain_core.messages import AIMessage


def node(state: State):
    messages = state["messages"]
    new_message = AIMessage("Hello!")
    return {"messages": messages + [new_message], "extra_field": 10}

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

Давайте далее определим простой граф, содержащий этот узел. Мы используем StateGraph для определения графа, который работает с этим состоянием. Затем мы используем add_node для заполнения нашего графа.

from langgraph.graph import StateGraph

graph_builder = StateGraph(State)
graph_builder.add_node(node)
graph_builder.set_entry_point("node")
graph = graph_builder.compile()

LangGraph предоставляет встроенные утилиты для визуализации вашего графа. Давайте рассмотрим наш граф.

from IPython.display import Image, display

display(Image(graph.get_graph().draw_mermaid_png()))

Использование графа

from langchain_core.messages import HumanMessage

result = graph.invoke({"messages": [HumanMessage("Hi")]})
print(result)

{'messages': [
HumanMessage(content='Hi', additional_kwargs={}, response_metadata={}),
AIMessage(content='Hello!', additional_kwargs={}, response_metadata={})
], 'extra_field': 10}

Для удобства мы часто проверяем содержимое объектов сообщений с помощью pretty-print:

for message in result["messages"]:
    message.pretty_print()

========================== Human Message ============================

Hi
=========================== Ai Message ==============================

Hello!

Обновление состояния графа с помощью редьюсеров (reducers)

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

Для схем состояний TypedDict мы можем определить reducer, снабдив соответствующее поле состояния аннотацией с помощью функции reducer.

В предыдущем примере наш узел обновил ключ "сообщения" в состоянии, добавив к нему сообщение. Ниже мы добавим к этому ключу reducer, чтобы обновления добавлялись автоматически:

from typing_extensions import Annotated


def add(left: list[AnyMessage], right: list[AnyMessage]):
    return left + right


class State(TypedDict):
    messages: Annotated[list[AnyMessage], add]
    extra_field: int

Теперь наш узел можно упростить:

def node(state: State):
    new_message = AIMessage("Hello!")
    return {"messages": [new_message], "extra_field": 10}

Теперь наша объявленная функция add будет сама делать конкатенацию списков.

from langgraph.graph import START


graph_builder = StateGraph(State)
graph = graph_builder.add_node(node).add_edge(START, "node").compile()

result = graph.invoke({"messages": [HumanMessage("Hi")]})

for message in result["messages"]:
    message.pretty_print()

========================== Human Message ============================

Hi
=========================== Ai Message ==============================

Hello!

MessagesState

LangGraph имеет встроенный reducer add_messages, который обрабатывает эти соображения:

from langgraph.graph.message import add_messages


class State(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]
    extra_field: int


def node(state: State):
    new_message = AIMessage("Hello!")
    return {"messages": [new_message], "extra_field": 10}


graph_builder = StateGraph(State)
graph = graph_builder.add_node(node).set_entry_point("node").compile()

input_message = {"role": "user", "content": "Hi"}

result = graph.invoke({"messages": [input_message]})

for message in result["messages"]:
    message.pretty_print()

========================== Human Message ============================

Hi
=========================== Ai Message ==============================

Hello!

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

from langgraph.graph import MessagesState


class State(MessagesState):
    extra_field: int

Таким образом, данный MessageState сам делает структуру:

class State(TypedDict):
    messages: Annotated[list[AnyMessage], add_messages]

А мы лишь дальше от него наследуемся и можем переиспользовать функционал. Чтобы вручную самим не объявлять.

✨Основной Telegram-канал со всеми обновлениями✨

Вам также может понравиться:

• Введение в Haystack
• Агенты искусственного интеллекта: что это такое, зачем нужны и почему за ними будущее
• Введение в библиотеку LangGraph

✔️ Обучение Python с нуля за 9 месяцев 🔝

Чтобы найти самые забитые папки в системе Ubuntu (или любой другой Linux-системе), можно использовать команду du (disk usage).

🔍 1. Найти топ-10 самых больших папок в /

sudo du -ahx / | sort -rh | head -10

Объяснение:

• du -ahx / — считает размер всех файлов и папок (-a показывает файлы, -h делает вывод в удобочитаемом формате, -x ограничивает поиск одним файловым системой).
• sort -rh — сортирует по размеру (-r по убыванию, -h в человекочитаемом формате).
• head -10 — выводит только топ-10 самых больших папок/файлов.

📁 2. Найти самые большие папки в /var (или другом каталоге)

sudo du -ahx /var | sort -rh | head -10

Это полезно, если хотите проверить /var (где часто накапливаются логи, кэши и базы данных).

📂 3. Найти самые большие каталоги без файлов (по папкам)

Если вас интересуют только папки, без отдельных файлов:

sudo du -hx --max-depth=1 / | sort -rh | head -10

Здесь:

• --max-depth=1 показывает только прямые подкаталоги, без вложенных.

🛠 4. Графическое отображение дискового пространства

Если у вас есть доступ к графическому интерфейсу, можно установить ncdu — удобный терминальный инструмент:

sudo apt install ncdu -y

Запустите его:

sudo ncdu /

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

🚀 5. Найти большие файлы (>1 ГБ)

Если хотите искать только файлы, больше 1 ГБ, используйте:

sudo find / -type f -size +1G -exec ls -lh {} + | awk '{ print $9 ": " $5 }'

Выведет список файлов и их размер.

❗ Полезные команды для поиска и очистки "мусора":

• Логи, кеши и временные файлы:

sudo du -sh /var/log /var/tmp /var/cache

• Docker-контейнеры и образы (если используете Docker):

docker system df

docker system prune -a # Очищает ненужные образы и контейнеры

• Неиспользуемые пакеты и кеши APT:

sudo apt autoremove -y
sudo apt clean

• Проверка папки пользователя (/home часто содержит много мусора):

sudo du -sh /home/*

💡 Вывод:
Лучший способ быстро найти забитые папки — du -ahx / | sort -rh | head -10.
Если вам нужна интерактивность, используйте ncdu.

На этом всё :) Подписывайтесь на телеграм канал, чтобы не пропускать обновления. Также там публикую ссылки на воркшопы и вебинары.

Вам также может понравиться:

• Первоначальная настройка сервера Ubuntu
• Агенты искусственного интеллекта: что это такое, зачем нужны и почему за ними будущее
• Введение в библиотеку LangGraph

Я уже ранее делал обзор библиотеки Yandex Cloud ML SDK для работы с YandexGPT и прочими инструментами. И Yandex облако добавили возможность использовать Llama 3.1 двух версий через их API.

Компания Meta признана в России экстремистской организацией и запрещены в РФ 21.03.2022

Я не буду вдаваться сильно в подробности работы с библиотекой, так как обзор уже делал ни раз. Вам потребуется знать id каталога внутри Yandex Cloud и API ключ для работы с AI.

Сначала импортируем нужные библиотеки и прочитаем ключи.

import asyncio
import os

from dotenv import load_dotenv
from yandex_cloud_ml_sdk import AsyncYCloudML


load_dotenv()


yandex_folder_id = os.getenv('YANDEX_FOLDER_ID')
yandex_api_key = os.getenv('YANDEX_AI_API_KEY')


# Создание экземпляра SDK
sdk = AsyncYCloudML(folder_id=yandex_folder_id, auth=yandex_api_key)

Далее просто сделаем функцию, которая будет в консоли симулировать чат:

async def main():
    model = sdk.models.completions('llama')
    model = model.configure(temperature=0.5)

    messages: list[dict[str, str] | str] = [
        {'role': 'system', 'text': 'Ты - Заботливый помощник'}
    ]

    while True:
        message = input('User: ')
        if message == 'стоп':
            break
        messages.append(message)
        result = await model.run(messages)
        messages.append(result[0])
        print('AI: ', result[0].text, '\n')


if __name__ == '__main__':
    asyncio.run(main())

• 'llama' — отвечает за Llama 3.1 70b
• 'llama-lite' — отвечает за Llama 3.1 8b

Меняя модель можно провести эксперименты, какая отвечает лучше.

На этом всё :) Подписывайтесь на телеграм канал, чтобы не пропускать обновления.

Вам также может понравиться:

• Запуск моделей ChatGPT, Gemini, LLama без VPN через AITunnel
• Агенты искусственного интеллекта: что это такое, зачем нужны и почему за ними будущее
• Введение в библиотеку LangGraph

Всем, привет! В этой статье расскажу как я получал ключи доступа к Pinterest API, а именно accessToken и refreshToken. Ведь именно accessToken используется во всех эндпоинтах для авторизации и проверки валидности запросов.

Данная статья будет полезна тем, кто хочет автоматизировать свой аккаунт Pinterest и управлять им через API.

Все примеры будут на языке Python, но эти шаги легко повторить на любом другом языке. Так как примеры очень легко читать и понимать.

Регистрация приложения

Сперва Вам необходимо создать бизнес аккаунт и зарегистрировать приложение внутри Pinterest. После создания приложения у Вас будет доступно CLIENT ID и CLIENT SECRET.

Как это сделать написано в инструкции:

https://developers.pinterest.com/docs/getting-started/connect-app

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

После создания приложения, у Вас будет отображаться примерно вот так:

Нажимаете на кнопку "Управление" и внутри найдёте нужные данные:

• "Идентификатор приложения" — CLIENT ID
• "Секретный ключ приложения" — CLIENT SECRET

Получение ключей (токенов) доступа

Получение ключей происходит в 3 этапа:

1. Генерация ссылки на авторизацию, где обязательно необходимо передать redirect_uri, куда будет перенаправляться пользователь после успешной авторизации.
2. Сервер, который будет доступен для redirect_uri. То есть именно здесь будет дальше приниматься запрос с кодом подтверждения
3. После получения специального кода необходимо сделать последний запрос на получение ключей.

Этап 1

На этой этапе необходимо просто сформировать URL, по которому будет происходить авторизация через Pinterest.

Здесь нам понадобится только CLIENT ID.

Сперва создадим конфиг с нужными данными:

class PinterestConfig:
    def __init__(self):
        load_dotenv()  # Загружаем переменные окружения
        self.client_id = os.getenv('PINTEREST_CLIENT_ID')
        self.client_secret = os.getenv('PINTEREST_CLIENT_SECRET')
        self.redirect_uri = os.getenv('PINTEREST_REDIRECT_URI', 'http://localhost:8000/callback')


config = PinterestConfig()

В моём примере PINTEREST_REDIRECT_URI = 'http://localhost:8000/callback'

Так как я тестирую всё локально.

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

Аналогично заходит в Управление своим приложением и ищем пункт "URI перенаправления" и добавляем новый:

Далее формируем URL авторизации:

client_id = config.client_id
redirect_uri = config.redirect_uri

print(f'https://www.pinterest.com/oauth/?response_type=code&client_id={client_id}&redirect_uri={urllib.parse.quote(redirect_uri)}&scope=pins:read,pins:write,boards:read')

• response_type=code — говорит нам о том, что нам нужен код для авторизации. Это просто будет некоторая рандомная строка, где мы будем подтверждать, что это мы всё запросили.
• Обратите внимание на scope. Он отвечает за то, на какие права мы рассчитываем. Собираемся мы управлять пинами, или досками, или ещё чем. Здесь надо это всё указать.

Полный список значений для scope можно прочитать по ссылке:

https://developers.pinterest.com/docs/getting-started/set-up-authentication-and-authorization/#choose-scopes

Этап 2. Сервер для redirect_uri

Ссылка для авторизации у нас есть. Но теперь после авторизации мы будем куда-то перенаправляться. Я для примера написал простой сервер на FastAPI, который будет доступен для принятия данных:

import aiohttp
import base64
import os
import uvicorn

from dotenv import load_dotenv
from fastapi import FastAPI, Request
from fastapi.middleware.cors import CORSMiddleware


class PinterestConfig:
    def __init__(self):
        load_dotenv()  # Загружаем переменные окружения
        self.client_id = os.getenv('PINTEREST_CLIENT_ID')
        self.client_secret = os.getenv('PINTEREST_CLIENT_SECRET')
        self.redirect_uri = os.getenv('PINTEREST_REDIRECT_URI', 'http://localhost:8000/callback')
        self.api_version = 'v5'  # Актуальная версия API
        self.base_url = f'https://api.pinterest.com/{self.api_version}/'


config = PinterestConfig()


app = FastAPI()

@app.get("/callback")
async def cb(request: Request):
    code = request.query_params.get('code', None)
	print('Полученный код: ', code)
    return {"status": "ok"}


app.add_middleware(
    CORSMiddleware,
    allow_origins=["*"],
    allow_credentials=True,
    allow_methods=["*"],
    allow_headers=["*"],
    expose_headers=["set-cookie"]
)


if __name__ == "__main__":
    try:
        uvicorn.run(app, host="0.0.0.0", port=8000)
    except Exception as err:
        print('Error starting server', err)
        exit(1)

Как видим, наш сервер будет запущен на порту 8000 и у него есть соответствующий /callback роут.

Теперь у нас 2 этапа позади и Вы сможете перейти по ссылке, сгенерированной на шаге 1, запустив предварительно сервер на шаге 2. И в итоге видите присланный код.

Осталось дело за малым. Нам надо получить ключи (токены доступа). Переходим к финальному шагу.

Этап 3. Получение ключей доступа

Основные шаги расписаны в документации:

https://developers.pinterest.com/docs/getting-started/set-up-authentication-and-authorization/#generate-an-access-token

В зависимости от метода авторизации выбирается один из вариантов. Мы выбрали получение кода авторизации.

Давайте теперь его получим:

@app.get("/callback")
async def cb(request: Request):
    code = request.query_params.get('code', None)
	print('Полученный код: ', code)

    if code:
	    auth_secret = f"{config.client_id}:{config.client_secret}"
	    auth_header = f'Basic {base64.b64encode(auth_secret.encode("utf-8")).decode()}'

        async with aiohttp.ClientSession(headers={'Authorization': auth_header}) as session:
            form_data = aiohttp.FormData()
            form_data.add_field('grant_type', 'authorization_code')
            form_data.add_field('code', code)
            form_data.add_field('redirect_uri', config.redirect_uri)

            async with session.post(f'https://api.pinterest.com/v5/oauth/token', data=form_data) as response:
                try:
                    response.raise_for_status()
                    response_data = await response.json()
                    print('response_data', response_data)
                except Exception as err:
                    print('auth error', err)

    return {"status": "ok"}

• auth_secret — Сначала формируем специальную строку, состоящую из CLIENT ID и CLIENT SECRET
• auth_header — потом преобразовываем наш auth_secret в base64 закодированную строку
• Данные передаём как FormData. Указываем:
• grant_type — метод авторизации. Мы выбрали получение кода. 'authorization_code'
• code — полученный код авторизации
• redirect_uri — URL перенаправления, который мы указывали, когда формировали строку авторизации на этапе 1. Важно его сюда передавать.

В результате Вы получите в ответ вот такой JSON:

{
  'access_token': 'pina_....',
  'refresh_token': 'pinr......',
  'response_type': 'authorization_code',
  'token_type': 'bearer',
  'expires_in': 2592000,
  'refresh_token_expires_in': 31536000,
  'scope': 'boards:read pins:read pins:write'
}

На этом всё :)

Друзья, подписывайтесь на мой основной Telegram-канал и не пропускайте всех обновлений :)

✨Основной Telegram-канал со всеми обновлениями✨

Вам также может быть полезно:

• Агенты искусственного интеллекта: что это такое, зачем нужны и почему за ними будущее
• Введение в Haystack
• Руководство по Pandas Series

Другие соц. сети:

• Dzen
• Вконтакте
• Youtube
• Rutube

Haystack — это платформа с открытым исходным кодом для создания готовых к работе приложений LLM, конвейеров генерации с расширенным поиском (RAG) и современных поисковых систем, которые интеллектуально работают с большими коллекциями документов.

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

Разработка с Haystack

Haystack предлагает полный набор инструментов для разработки самых современных систем искусственного интеллекта, использующих LLM.

• Использование моделей, размещенных на таких платформах, как Hugging Face, OpenAI, Cohere, Mistral и других.
• Использование моделей, развернутых в SageMaker, Bedrock, Azure …
• Встроенные хранилища документов: OpenSearch, Pinecone, Weaviate, QDrant и другие.
• Растущая экосистема интеграции с сообществом предоставляет инструменты для оценки, мониторинга, обработки данных и всех уровней вашего приложения LLM.

Некоторые примеры того, что вы можете создать, включают:

• Усовершенствованный RAG на основе вашего собственного источника данных, основанный на новейших технологиях поиска и генерации
• Чат-боты и агенты, работающие на базе передовых генерирующих моделей, таких как GPT-4, которые могут даже вызывать внешние функции и сервисы
• Генеративный мультимодальный ответ на вопрос на основе базы знаний, содержащей смешанные типы информации: изображения, текст, аудио и таблицы
• Извлечение информации из документов для заполнения вашей базы данных или построения графа знаний

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

Комплексная функциональность для вашего проекта LLM

Для успешного проекта в LLM требуется нечто большее, чем просто языковые модели. Являясь сквозным фреймворком, Haystack помогает вам на каждом этапе создания вашей системы:

• Плавное включение моделей от Hugging Face или других поставщиков в ваш Pipeline
• Интегрируйте источники данных для расширения поиска из любой точки Интернета
• Расширенные динамические шаблоны для запросов LLM с помощью языка шаблонов Jinja2
• Функции очистки и предварительной обработки для различных форматов и источников данных
• Интеграция с вашим предпочтительным хранилищем документов: поддерживайте актуальность ваших приложений GenAI с помощью конвейеров индексации Haystack, которые помогают вам подготавливать и поддерживать ваши данные
• Специализированные инструменты оценки, которые используют различные показатели для оценки всей системы или ее отдельных компонентов
• Модуль Hayhooks для обслуживания конвейеров Haystack через конечные точки HTTP
• Настраиваемая система ведения журнала (логгирования), которая поддерживает структурированное ведение журнала и отслеживание корреляции "из коробки".
• Инструментарий для обработки кода, собирающий данные о промежутках и трассировках в стратегических точках пути выполнения, с поддержкой открытой телеметрии и Datadog, которые уже установлены

Но это еще не все: фильтрация метаданных, управление устройствами для локально запущенных моделей, даже продвинутые методы RAG, такие как внедрение гипотетических документов (HyDE). Чего бы ни пожелал ваш искусственный интеллект, вы, скорее всего, найдете это в Haystack.

Встроенные блоки

Haystack использует две основные концепции, которые помогут вам создавать полностью функциональные и настраиваемые комплексные системы GenAI.

Компоненты (Components)

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

Хотя Haystack предлагает множество компонентов, которые вы можете использовать "из коробки", он также позволяет создавать собственные пользовательские компоненты — так же просто, как написать класс на Python. Ознакомьтесь с коллекцией интеграций, включающей пользовательские компоненты, разработанные нашими партнерами и сообществом, которые вы можете свободно использовать.

Вы можете соединять компоненты вместе для создания конвейеров (pipelines), которые являются основой архитектуры приложений LLM в Haystack.

Конвейеры (Pipelines)

Pipelines — это мощные абстракции, которые позволяют вам определять поток данных в вашем LLM-приложении. Они состоят из компонентов.

Как разработчик, вы имеете полный контроль над тем, как расположить компоненты в конвейере. Конвейеры (Pipelines) могут разветвляться, объединяться, а также возвращаться к другому компоненту. Вы можете создавать конвейеры (Pipelines) Haystack, которые могут повторять попытку, возвращаться к циклу и, возможно, даже работать непрерывно как служба.

Конвейеры (Pipelines), по сути, представляют собой графики или даже мультиграфы. Один компонент с несколькими выходами может подключаться к другому компоненту с несколькими входами или к нескольким компонентам, благодаря гибкости конвейеров.

Чтобы вы могли начать, Haystack предлагает множество примеров конвейеров для различных вариантов использования: индексация, агентный чат, RAG, контроль качества, вызов функций, веб-поиск и многое другое.

Для кого это?

Haystack предназначен для всех, кто хочет создавать приложения с искусственным интеллектом, — как для энтузиастов, так и для новичков. Вам не нужно разбираться в том, как работают модели. Все, что вам нужно, - это базовые знания Python, чтобы сразу погрузиться в работу.

Полезные ссылки по Haystack

• Начните готовить с помощью готовых Colab notebooks
• Учитесь в интерактивном режиме с помощью пошаговых инструкций
• Взгляните на документацию
• Основной блог
• Github репозиторий

Вам может быть полезно

• Топ-5 фреймворков GraphRAG для улучшенного поиска с помощью искусственного интеллекта
• Агенты искусственного интеллекта: что это такое, зачем нужны и почему за ними будущее

✨Основной Telegram-канал со всеми обновлениями✨

Эта библиотека Python предоставляет простой и эффективный набор для разработки программного обеспечения (SDK) для взаимодействия с облачными сервисами машинного обучения Яндекса. SDK устраняет сложности необработанных вызовов gRPC, упрощая разработчикам интеграцию облачных функций в свои приложения.

Yandex Cloud ML SDK предоставляет простой в использовании интерфейс для доступа к сервисам Yandex Cloud ML. В настоящее время он поддерживает:

• Генерацию текста с использованием любой поддерживаемой модели
• Генерацию изображений с помощью YandexART
• Помощников с искусственным интеллектом и управление файлами (Assistant API)
• Работу с эмбеддингами (embeddings)

Библиотека имеет как синхронный режим выполнения, так и асинхронный.

Для установки библиотеки можно выполнить команду:

pip install yandex-cloud-ml-sdk

Как начать пользоваться

Для начала Вам потребуется folder_id и API-ключ. Для получения API ключа необходимо создать сервисный аккаунт и подключить необходимые роли для работы с AI. В тестовом примере я создал сервисный аккаунт с полными админ правами для доступа к AI.

Где брать folder_id и как создавать сервисный аккаунт, я уже рассматривал ранее в статье.

Далее просто импортируем библиотеку и создаём экземпляр для работы с API:

from yandex_cloud_ml_sdk import AsyncYCloudML


yandex_folder_id = '<folder id>'
yandex_api_key = '<api key>'


# Создание экземпляра SDK
sdk = AsyncYCloudML(folder_id=yandex_folder_id, auth=yandex_api_key)

Всё, теперь можем пользоваться и экспериментировать)

Chat Completions

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

model = sdk.models.completions('yandexgpt')
model = model.configure(temperature=0.5)

messages: list[dict[str, str] | str] = [
    {'role': 'system', 'text': 'Ты - Заботливый помощник'}
]

while True:
    message = input('User:')
    if message == 'стоп':
        break
    messages.append(message)
    result = await model.run(messages)
    messages.append(result[0])
    print('AI:', result[0].text, '\n')

User: привет
AI: Здравствуйте! Чем могу помочь? 

User: Кто был главным на Руси?
AI: Главным на Руси был великий князь. 

User: стоп

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

Генерация изображений (image generation)

Данная секция посвящена использованию YandexART. Как аналог для Midjourney Вы можете теперь генерировать высококачественные изображения по текстовому описанию:

model = sdk.models.image_generation('yandex-art')

# Конфигурация модели
model = model.configure(width_ratio=2, height_ratio=3, seed=150)

• С помощью width_ratio и height_ratio можете конфигурировать размеры изображения под разные цели.
• Параметр seed отвечает лишь за то, будет для данного числа и одинаковых промтов одинаковый результат или нет. Он необязательный. Если удалить, то рандомное число будет по умолчанию и изображения всегда будут разными.

Как генерировать изображение:

operation = await model.run_deferred('Подарочная открытка с изображением корги в стиле Pixar на лаймовом фоне, держит в лапках букет цветов')
result = await operation
print(result)

Для отображения результата в Jupyter Notebook можно использовать следующий код:

from IPython.display import Image, display

display(Image(result.image_bytes, width=200, height=800))

Результат Вы увидите как показано выше.

Ассистенты (Assistant API)

Ассистенты стали популярны благодаря OpenAI Assistant API. Смысл в том, чтобы единоразово загрузить ему инструкции, базу знаний и дальше он сам будет понимать, когда запрос относится к инструкции, а когда надо пойти в базу знаний и найти нужный ответ на вопрос пользователя.

А ещё главным преимуществом ассистентов является то, что не нужно каждый раз передавать всю историю сообщений. В обычном Chat Completion как вы помните мы передаём всю историю сообщений, чтобы модель учитывала контекст.

Ассистенты же, напротив, принимают сообщение и сами хранят историю. И в результате возвращают только ответ.

Разберём сначала простые операции с ассистентами:

• Создание ассистента

assistant = await sdk.assistants.create(
    'yandexgpt',
    ttl_days=1,
    expiration_policy='static',
    temperature=0.5,
    max_prompt_tokens=50,
)
print(f"{assistant=}")

assistant=AsyncAssistant(
  id='fvt90pe2jrisf2...',
  expiration_config=ExpirationConfig(ttl_days=1, expiration_policy=<ExpirationPolicy.STATIC: 1>),
  model=AsyncGPTModel(uri=gpt://...gn7ort.../yandexgpt/latest, config=GPTModelConfig(temperature=0.5, max_tokens=None)),
  instruction=None, max_prompt_tokens=50,
  tools=(),
  name=None, description=None,
  created_by='aje5i2cktiqs...',
  created_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
  updated_by='aje5i2cktiqsq...',
  updated_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
  expires_at=datetime.datetime(2024, 11, 22, 12, 10, 1, 934024),
  labels=None
)

• Получение по ID

assistant2 = await sdk.assistants.get(assistant.id)
print(f"same {assistant2=}")

assistant2=AsyncAssistant(
  id='fvt90pe2jrisf2...e',
  expiration_config=ExpirationConfig(ttl_days=1, expiration_policy=<ExpirationPolicy.STATIC: 1>),
  model=AsyncGPTModel(uri=gpt://...ugn7.../yandexgpt/latest, config=GPTModelConfig(temperature=0.5, max_tokens=None)),
  instruction=None, max_prompt_tokens=50,
  tools=(),
  name=None, description=None,
  created_by='aje5i2cktiqsqv...',
  created_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
  updated_by='aje5i2cktiqsqv...',
  updated_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
  expires_at=datetime.datetime(2024, 11, 22, 12, 10, 1, 934024),
  labels=None
)

• Обновление данных

await assistant2.update(
    model='yandexgpt-lite', name='foo', max_tokens=5
)
print(f"updated {assistant2=}")

updated assistant2=AsyncAssistant(
  id='fvt90pe2jrisf2...',
  expiration_config=ExpirationConfig(ttl_days=1, expiration_policy=<ExpirationPolicy.STATIC: 1>),
  model=AsyncGPTModel(uri=gpt://.../yandexgpt-lite/latest, config=GPTModelConfig(temperature=0.5, max_tokens=5)),
  instruction=None, max_prompt_tokens=50,
  tools=(),
  name='foo', description=None,
  created_by='aje5i2cktiqsqv...',
  created_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
  updated_by='aje5i2cktiqsqv...',
  updated_at=datetime.datetime(2024, 11, 21, 12, 10, 24, 970164),
  expires_at=datetime.datetime(2024, 11, 22, 12, 10, 1, 934024),
  labels=None
)

• Получить список всех версий ассистента

async for version in assistant.list_versions():
    print(f"assistant {version=}\n")

assistant version=AssistantVersion(
  id='fvt7qv73ojo...qbec',
  assistant=ReadOnlyAssistant(
    id='fvt90pe2j...sboe',
    expiration_config=ExpirationConfig(ttl_days=1, expiration_policy=<ExpirationPolicy.STATIC: 1>),
    model=AsyncGPTModel(uri=gpt://...t.../yandexgpt-lite/latest, config=GPTModelConfig(temperature=0.5, max_tokens=5)),
    instruction=None, max_prompt_tokens=50,
    tools=(),
    name='foo', description=None,
    created_by='aje5i2cktiqsqv...',
    created_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
    updated_by='aje5i2cktiqsqv...',
    updated_at=datetime.datetime(2024, 11, 21, 12, 10, 24, 970164),
    expires_at=datetime.datetime(2024, 11, 22, 12, 10, 1, 934024),
    labels=None
  ),
  update_mask=('name', 'model_uri', 'completion_options.max_tokens')
)

assistant version=AssistantVersion(
  id='fvtrgpdli...eaefg',
  assistant=ReadOnlyAssistant(
    id='fvt90pe2jris...',
    expiration_config=ExpirationConfig(ttl_days=1, expiration_policy=<ExpirationPolicy.STATIC: 1>),
    model=AsyncGPTModel(uri=gpt://...ugn7.../yandexgpt/latest, config=GPTModelConfig(temperature=0.5, max_tokens=None)),
    instruction=None, max_prompt_tokens=50,
    tools=(),
    name=None, description=None,
    created_by='aje5i2cktiqsqv...',
    created_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
    updated_by='aje5i2cktiqsqv...',
    updated_at=datetime.datetime(2024, 11, 21, 12, 10, 1, 934024),
    expires_at=datetime.datetime(2024, 11, 22, 12, 10, 1, 934024),
    labels=None
  ),
  update_mask=()
)

• Удаление ассистента

async for assistant in sdk.assistants.list():
    await assistant.delete()

Теперь давайте посмотрим, как нам создать ассистента с базой знаний и пообщаться с ним.

Представим, что есть 2 файла

🌞 Побег в Анталью: Ваш идеальный отдых начинается здесь! 🌊

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

Ваши преимущества с нашим туром:

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

🏛 Исторические открытия: Откройте для себя чудеса древнего мира. Посетите античные города Аспендос и Перге, насладитесь прогулками по исторической части города – Калечи, где каждая улочка хранит свое секреты.

🌿 Природные чудеса: Полюбуйтесь величественным водопадом Дюден, исследуйте горный массив Тавр и отправьтесь на экскурсию в национальный парк Олюдениз, где воздух напоен ароматами сосен.

🍽 Некоторые изысканные угощения: Насладитесь вкуснейшей турецкой кухней с её множеством специй и ароматов. Отведайте аутентичные блюда в местных ресторанах и попробуйте свежайшие морепродукты.

🎉 Активные и вечерние развлечения: Для любителей активного отдыха доступны водные виды спорта, а для тех, кто ищет веселья, города предлагает оживлённые ночные клубы и дискотеки.

Въездная / выездная пошлина всего лишь 20 долларов в обе стороны !!!

Всего лишь 20 долларов

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

Анталья ждет вас! ✈️

...

И второй файл

Стоимость въезда/выезда с Мальдив - 10 тысяч долларов в обе стороны

Это просто 2 файла как база знаний для ассистента. В реальном мире эти файлы могут быть в разы длиннее.

Теперь к самой логике

import asyncio
import pathlib


# Загружаем файлы в Yandex Assistant
file_coros = (
    sdk.files.upload(
        path,
        ttl_days=5,
        expiration_policy="static",
    )
    for path in ['turkey_example.txt', 'maldives_example.txt']
)

files = await asyncio.gather(*file_coros)

# Создаём поисковый индекс
operation = await sdk.search_indexes.create_deferred(files)
search_index = await operation

print(search_index)

AsyncSearchIndex(
  id='fvttaeii...',
  expiration_config=ExpirationConfig(ttl_days=7, expiration_policy=<ExpirationPolicy.SINCE_LAST_ACTIVE: 2>),
  folder_id='...',
  name=None, description=None,
  created_by='aje5i2cktiqsq...',
  created_at=datetime.datetime(2024, 11, 21, 12, 21, 49, 479133),
  updated_by='aje5i2cktiqsq...',
  updated_at=datetime.datetime(2024, 11, 21, 12, 21, 49, 479133),
  expires_at=datetime.datetime(2024, 11, 28, 12, 21, 49, 479133),
  labels=None,
  index_type=TextSearchIndexType(chunking_strategy=StaticIndexChunkingStrategy(max_chunk_size_tokens=800, chunk_overlap_tokens=400))
)

Создаём ассистента с поисковым индексом:

tool = sdk.tools.search_index(search_index)

assistant = await sdk.assistants.create('yandexgpt', tools=[tool])

Обратите внимание, что поисковый индекс создаётся в виде tool, который по сути является function calling.

Для общения с пользователем необходимо сначала создать thread. Это как чат единый, в котором хранится информация общения с человеком. И потом сообщения помещать в этот thread.

thread = await sdk.threads.create()

for search_query in (
    'Какова стоимость выездной пошлины для путешествия в чарующие и солнечные МАЛЬДИВЫ, где беззаботный отдых на восхитительных пляжах, утопающих в лучах мягкого средиземноморского солнца, соединяется с открытием величественных исторических памятников и наслаждением изысканными ароматами местной кухни?',
    "Cколько пошлина в Анталье"
):
    await thread.write(search_query)
    run = await assistant.run(thread)
    result = await run
    print('Question', search_query)
    print('Answer:', result.text, '\n')

Question Какова стоимость выездной пошлины для путешествия в чарующие и солнечные МАЛЬДИВЫ, где беззаботный отдых на восхитительных пляжах, утопающих в лучах мягкого средиземноморского солнца, соединяется с открытием величественных исторических памятников и наслаждением изысканными ароматами местной кухни?
Answer: Стоимость выездной пошлины для путешествия на Мальдивы составляет 10 тысяч долларов в обе стороны. 

Question Cколько пошлина в Анталье
Answer: Въездная и выездная пошлина в Анталье составляет 20 долларов в обе стороны. 

Как видите, задаём ему 2 вопроса и он отвечает на вопросы исходя из информации, что мы в него загрузили.

Очистка пространства

await search_index.delete()
await thread.delete()
await assistant.delete()

for file in files:
    await file.delete()

Embeddings

Ранее мы с Вами уже рассматривали в статье, как использовать embeddings в проекте через http запросы.

Давайте посмотрим как это делать через SDK.

doc_texts = [
    """Александр Сергеевич Пушкин (26 мая [6 июня] 1799, Москва — 29 января [10 февраля] 1837, Санкт-Петербург)
    — русский поэт, драматург и прозаик, заложивший основы русского реалистического направления,
    литературный критик и теоретик литературы, историк, публицист, журналист.""",

    """Ромашка — род однолетних цветковых растений семейства астровые,
    или сложноцветные, по современной классификации объединяет около 70 видов невысоких пахучих трав,
    цветущих с первого года жизни."""
]

# Генерация embeddings для документов (начальной базы знаний)
doc_model = sdk.models.text_embeddings('doc')
coros = (doc_model.run(text) for text in doc_texts)
doc_embeddings = await asyncio.gather(*coros)


# Генерация embedding для поискового запроса
query_model = sdk.models.text_embeddings('query')
query_embedding = await query_model.run("когда день рождения Пушкина?")

Как видим всё очень просто. И далее эту SDK можно использовать с любой базой данных для хранения информации об embeddings.

На этом всё :) Подписывайтесь на телеграм канал, чтобы не пропускать обновления.

Вам также может понравиться:

• Запуск моделей ChatGPT, Gemini, LLama без VPN через AITunnel
• Агенты искусственного интеллекта: что это такое, зачем нужны и почему за ними будущее
• Введение в библиотеку LangGraph

Сегодня всё чаще можно услышать, что за агентами искусственного интеллекта (ИИ) — будущее. Но что же это за «агенты» и почему они вызывают такой интерес?

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

Для чего нужны агенты ИИ

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

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

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

Как агенты упрощают работу

Главная ценность агентов ИИ — умение обрабатывать огромные массивы данных и учиться на опыте. В отличие от человека, которому трудно держать в голове сразу сотни параметров и быстро реагировать на изменения, агент умеет без устали анализировать информацию практически в реальном времени. Это позволяет людям сосредоточиться на более творческих или сложных задачах, делегируя «рутинные» операции автоматизированным системам.

Благодаря использованию машинного обучения и принципов поведенческой адаптации, агенты способны со временем становиться «умнее». Чем больше данных они обрабатывают, тем более точными становятся их прогнозы и принимаемые решения. Например, система, работающая с прогнозом погоды, может самостоятельно адаптироваться к новым моделям атмосферных изменений и постоянно повышать точность своих расчётов.

Почему это нужно уже сегодня

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

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

Часто бывает российским проектам необходимо использовать зарубежные LLM в своих проектах. И чтобы их использовать, обычно создаются прокси сервера личные и зарубежные аккаунты с оплатой иностранными картами.

Такой вариант подойдёт, если вы максимально хотите сократить возможности утечки персональных данных. Для максимальной сохранности подобных данных обычно запускают LLM на своих серверах.

Но если для Вас это не супер критично и данные не супер конфиденциальные, а обычные диалоги, то я бы рассматривал использование сервисов прокси. Хотя все сервисы утверждают, что данные и логи никакие не собирают.

Сегодня рассмотрим один из самых демократичных сервисов прокси — AITunnel.

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

Создание API-ключа

Просто откройте личный кабинет, пополните баланс и на вкладке "Управление ключами" создайте API-ключ.

ChatGPT

from openai import OpenAI

# У меня создан файл 'config', где я храню API-ключ
from ai_tunnel.config import ai_tunnel_api_key


client = OpenAI(
    api_key=ai_tunnel_api_key,
    base_url='https://api.aitunnel.ru/v1/',
)

completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Скажи интересный факт"}],
    max_tokens=500,
    model='gpt-4o',
)

print(completion.choices[0].message.content)

Как видим использовать можно существующую библиотеку OpenAI, указав только base_url и название модели.

Gemini

from openai import OpenAI

# У меня создан файл 'config', где я храню API-ключ
from ai_tunnel.config import ai_tunnel_api_key


client = OpenAI(
    api_key=ai_tunnel_api_key,
    base_url='https://api.aitunnel.ru/v1/',
)

completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Скажи интересный факт"}],
    max_tokens=500,
    model='gemini-pro-1.5',
)

print(completion.choices[0].message.content)

LLama

from openai import OpenAI

# У меня создан файл 'config', где я храню API-ключ
from ai_tunnel.config import ai_tunnel_api_key


client = OpenAI(
    api_key=ai_tunnel_api_key,
    base_url='https://api.aitunnel.ru/v1/',
)

completion = client.chat.completions.create(
    messages=[{"role": "user", "content": "Скажи интересный факт"}],
    max_tokens=500,
    model='llama-3.2-90b-vision-instruct',
)

print(completion.choices[0].message.content)

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

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