Chat_bot_Llama_cpp_gradio_deploy.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [
        "a8eTsawHkAhj",
        "ZBk58Z4JlwGN",
        "9vDfhvAQv_gw",
        "Ur7xz02erwTt",
        "LRauQ_6SYKXg",
        "v1UmrPrHF_H7",
        "EaMaf0bJodsv",
        "THGcPGj5mOmm",
        "dhNWd-UymuRh",
        "wCQivjeDods0",
        "lt4zebPHods4",
        "lc4qsYnbods6",
        "DnZn_booXOIh",
        "BSR4o5fvods8"
      ],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "**Чат-бот на основе библиотеки Llama-cpp-python и веб интерфейсом на фреймворке Gradio, деплой бота на облачный сервер, подключение к нему сервера NGINX, аренда своего домена (сайта) и получение SSL сертификата для работы сайта по протоколу HTTPS**"
      ],
      "metadata": {
        "id": "1VpT5DKRkzEO"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Структура и код проекта, запуск в Colab"
      ],
      "metadata": {
        "id": "a8eTsawHkAhj"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Простой чат-бот с веб-интерфейсом на фреймворке Gradio**  \n",
        "**Для генерации текста языковыми моделями формата GGUF используется библиотека `llama-cpp-python`**"
      ],
      "metadata": {
        "id": "kFV6d-neYRjk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "5PYAzE-aqqJu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Стек**\n",
        "\n",
        "Библиотека `llama-cpp-python` для инференса модели в формате GGUF  \n",
        "https://github.com/abetlen/llama-cpp-python\n",
        "\n",
        "Инструкции по Docker образам для `llama-cpp-python`  \n",
        "https://github.com/abetlen/llama-cpp-python/tree/main/docker\n",
        "\n",
        "Страница модели `gemma-2-2b` в формате GGUF  \n",
        "https://huggingface.co/bartowski/gemma-2-2b-it-GGUF\n",
        "\n",
        "Страница модели `gemma-2-2b-abliterated` в формате GGUF  \n",
        "https://huggingface.co/bartowski/gemma-2-2b-it-abliterated-GGUF\n",
        "\n",
        "Фреймворк Gradio для написания веб-интерфейса  \n",
        "https://github.com/gradio-app/gradio\n",
        "\n",
        "Библиотека для загрузки файлов `data-downloader`  \n",
        "https://github.com/Fanchengyan/data-downloader  \n",
        "https://data-downloader.readthedocs.io/en/latest/user_guide/download.html  \n"
      ],
      "metadata": {
        "id": "JwpXetQip-eb"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "P_NqjrT2qeKS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Репозиторий HF где можно найти свежие модели в формате GGUF   \n",
        "https://huggingface.co/bartowski?search_models=GGUF\n",
        "\n",
        "Поиск моделей в формате GGUF на HF  \n",
        "https://huggingface.co/bartowski?search_models=GGUF  \n",
        "Заходим на страницу модели, нажимаем `Files and versions` -> ПКМ на значок загрузки -> копировать ссылку -> при вставке ссылки стереть последние символы `?download=true` чтобы осталось расширение файла `.gguf`"
      ],
      "metadata": {
        "id": "oT7X1tC1qdSf"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Структура и описание проекта"
      ],
      "metadata": {
        "id": "ZBk58Z4JlwGN"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "OrzyCjBfonh6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Скриншот главной страницы приложения приложения  \n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1HUyxCzC-7SKN_Dwz98oELCnKxa64J1nE\" width=100%>"
      ],
      "metadata": {
        "id": "bQxEsa27Wc0K"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Скриншот страницы загрузки моделей\n",
        "<img src=\"https://drive.google.com/uc?export=view&id=1HYq8O_54KwbqxPTLMXRdB2-VeH_5j0Ru\" width=100%>"
      ],
      "metadata": {
        "id": "anJ6LjlSG__c"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "vZjALlkmqmDp"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Структура проекта**:  \n",
        " - 📁 `models`\n",
        " - `requirements.txt`\n",
        " - `app.py`\n"
      ],
      "metadata": {
        "id": "waVY99ejovt5"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "dGH-K2eXquII"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Установка и запуск:**\n",
        "\n",
        "1. Создание и активация виртуального окружения (опционально)\n",
        "\n",
        " Создание окружения:\n",
        " ```\n",
        "python3 -m venv env\n",
        " ```\n",
        "\n",
        " Активация окружения:\n",
        " - Linux\n",
        "```\n",
        "source env/bin/activate\n",
        "```\n",
        "\n",
        " - Windows\n",
        "```\n",
        "env\\Scripts\\activate.bat\n",
        "```\n",
        "\n",
        "2. Установка библиотек\n",
        " - с поддержкой CPU\n",
        " ```\n",
        " pip install -r requirements.txt --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu\n",
        " ```\n",
        "\n",
        " - с поддержкой CUDA 12.4\n",
        " ```\n",
        " pip install -r requirements.txt --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124\n",
        " ```\n",
        "Для установки `llama-cpp-python` на Windows с поддержкой CUDA нужно предварительно установить [Visual Studio 2022 Community](https://visualstudio.microsoft.com/ru/downloads/) и [CUDA Toolkit](https://developer.nvidia.com/cuda-toolkit-archive), как например указано в этой [инструкции](https://github.com/abetlen/llama-cpp-python/discussions/871#discussion-5812096)  \n",
        "Для полной переустановки использовать команду\n",
        "```\n",
        "pip install --force-reinstall --no-cache-dir -r requirements.txt --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cu124\n",
        "```\n",
        "\n",
        "3. Запуск приложения\n",
        "```\n",
        "python3 app.py\n",
        "```\n",
        "\n",
        "Перейти в браузере http://localhost:7860/ после того как появится надпись `Running on local URL:  http://0.0.0.0:7860`  \n",
        "\n",
        "На некоторых системах (например на некоторых WSL) модель загружается не быстро  \n",
        "При первом запуске произойдет загрузка модели по умолчаню (`gemma-2-2b-it-Q8_0.gguf`, 2.7GB) в папку `./models`, поэтому приложение доступно не сразу"
      ],
      "metadata": {
        "id": "JnLtJ518xLrE"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "goeoOWGQqRZW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Содержимое `app.py` в разделе `Код приложения`**"
      ],
      "metadata": {
        "id": "5q7YoQ0Pqu3O"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Содержимое `requirements.txt`**\n",
        "```\n",
        "llama_cpp_python==0.2.90\n",
        "gradio>=5\n",
        "```\n",
        "Версия `Python:` `3.8+` (проверено на `3.10`)"
      ],
      "metadata": {
        "id": "6f3YDd-ctkHB"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# проверить текущие версии библиотек\n",
        "!pip list | grep -P 'llama_cpp_python|gradio'\n",
        "\n",
        "# gradio                           4.44.0\n",
        "# llama_cpp_python                 0.2.88"
      ],
      "metadata": {
        "id": "fuT5udMaQY8h",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "7cc24145-7c21-4c4f-dfa2-92c46384bef0"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "gradio                             5.0.1\n",
            "gradio_client                      1.4.0\n",
            "llama_cpp_python                   0.2.90\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Приложение протестировано на следующих версиях библиотек (октябрь 2024)\n",
        "```\n",
        "llama_cpp_python==0.2.90\n",
        "gradio==5.0.2\n",
        "```"
      ],
      "metadata": {
        "id": "SLvFkIgpqWso"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "Cr1R5tLYt-0T"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Дополнительно**\n",
        "\n",
        "Команда для установки `llama-cpp-python` для Linux с поддержкой GPU NVIDIA (если обычная без FORCE_CMAKE=1 не сработала)\n",
        "```\n",
        "CMAKE_ARGS=\"-DGGML_CUDA=on\" FORCE_CMAKE=1 pip install llama-cpp-python\n",
        "```\n",
        "Команда установки/переустановки для Windows с поддержкой CPU (если обычная команда не сработала)\n",
        "```\n",
        "pip install --force-reinstall --no-cache-dir llama-cpp-python --extra-index-url https://abetlen.github.io/llama-cpp-python/whl/cpu\n",
        "```"
      ],
      "metadata": {
        "id": "qP6793_FqKOC"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "3mliiWUhwGPv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Проверка инференса LLM в Colab"
      ],
      "metadata": {
        "id": "9vDfhvAQv_gw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Страница используемой модели  \n",
        "https://huggingface.co/bartowski/gemma-2-2b-it-GGUF"
      ],
      "metadata": {
        "id": "A7NMhTQwR23U"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Установка библиотек"
      ],
      "metadata": {
        "id": "MoO-JaUjkwyw"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -q llama_cpp_python==0.2.88 gradio"
      ],
      "metadata": {
        "id": "jioCtUNYI5Kv",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "71910d46-c32e-4877-8f8d-29798f4652f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m63.8/63.8 MB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.4/50.4 kB\u001b[0m \u001b[31m4.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m18.1/18.1 MB\u001b[0m \u001b[31m59.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m318.7/318.7 kB\u001b[0m \u001b[31m22.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m45.5/45.5 kB\u001b[0m \u001b[31m3.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m94.6/94.6 kB\u001b[0m \u001b[31m7.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.4/76.4 kB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m77.9/77.9 kB\u001b[0m \u001b[31m7.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m141.9/141.9 kB\u001b[0m \u001b[31m11.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.9/10.9 MB\u001b[0m \u001b[31m94.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m63.7/63.7 kB\u001b[0m \u001b[31m5.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m4.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m71.5/71.5 kB\u001b[0m \u001b[31m6.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m130.2/130.2 kB\u001b[0m \u001b[31m11.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Building wheel for llama_cpp_python (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# !pip install -q llama_cpp_python gradio"
      ],
      "metadata": {
        "id": "asNVFn7Jv-ku"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "!pip list | grep -P 'llama_cpp_python|gradio|huggingface-hub'"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "7UUb4A4s-ftl",
        "outputId": "79bb5fb2-d045-43ec-d4ca-c71770fef205"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "gradio                           4.44.0\n",
            "gradio_client                    1.3.0\n",
            "huggingface-hub                  0.24.7\n",
            "llama_cpp_python                 0.3.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Импорты"
      ],
      "metadata": {
        "id": "EvSz9bQwkze0"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pathlib import Path\n",
        "from shutil import rmtree\n",
        "from typing import Union, List, Dict\n",
        "from tqdm import tqdm\n",
        "\n",
        "import requests\n",
        "from llama_cpp import Llama, llama_tokenizer"
      ],
      "metadata": {
        "id": "UIZjurIotedn"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Загрузка весов модели в формате GGUF - вариант через `requests`"
      ],
      "metadata": {
        "id": "eJcLFCnFk9uQ"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# функция для загрузки файла по URL ссылке и отображением прогресс бара\n",
        "def download_file(file_url: str, file_path: Union[str, Path]) -> None:\n",
        "    response = requests.get(file_url, stream=True)\n",
        "    if response.status_code != 200:\n",
        "        raise Exception(f'Файл недоступен для скачивания по ссылке: {file_url}')\n",
        "    # получение размера файла в байтах\n",
        "    total_size = int(response.headers.get('content-length', 0))\n",
        "    # прогресс бар tqdm\n",
        "    progress_bar = tqdm(desc='Загрузка файла GGUF', total=total_size, unit='iB', unit_scale=True)\n",
        "    # открытие файла на запись\n",
        "    with open(file_path, 'wb') as file:\n",
        "        # загрузка файла чанками по 4Кб и запись чанка в файл\n",
        "        for data in response.iter_content(chunk_size=4096):\n",
        "            size = file.write(data)\n",
        "            # обновление прогресс бара\n",
        "            progress_bar.update(size)\n",
        "\n",
        "# прямая ссылка на модель в формате GGUF\n",
        "# gguf_url = 'https://huggingface.co/bartowski/Qwen2.5-1.5B-Instruct-GGUF/resolve/main/Qwen2.5-1.5B-Instruct-Q8_0.gguf'\n",
        "# gguf_url = 'https://huggingface.co/bartowski/openchat-3.6-8b-20240522-GGUF/resolve/main/openchat-3.6-8b-20240522-IQ4_XS.gguf'\n",
        "# gguf_url = https://huggingface.co/bartowski/gemma-2-2b-it-GGUF/resolve/main/gemma-2-2b-it-IQ3_M.gguf\n",
        "# gguf_url = 'https://huggingface.co/bartowski/Llama-3.2-1B-Instruct-GGUF/resolve/main/Llama-3.2-1B-Instruct-Q8_0.gguf'\n",
        "gguf_url = 'https://huggingface.co/bartowski/gemma-2-2b-it-GGUF/resolve/main/gemma-2-2b-it-Q8_0.gguf'\n",
        "\n",
        "# полный путь до модели в папке ./models\n",
        "model_path = Path('models') / gguf_url.rsplit('/')[-1]\n",
        "model_path.parent.mkdir(exist_ok=True)\n",
        "\n",
        "# если модель отсутствует в папке models то нужно ее загрузить\n",
        "if not model_path.is_file():\n",
        "    if not gguf_url.endswith('.gguf'):\n",
        "        raise Exception('Ссылка на модель LLM должна быть прямой ссылкой на файл GGUF')\n",
        "    else:\n",
        "        print('Загрузка файла GGUF для LLM модели ...')\n",
        "        download_file(gguf_url, model_path)"
      ],
      "metadata": {
        "id": "JAcBqUEitT2d",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "85e662c9-f690-4882-bd08-e5da1d491beb"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Загрузка файла LLM модели ...\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Загрузка файла GGUF: 100%|██████████| 2.78G/2.78G [00:30<00:00, 90.2MiB/s]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Загрузка весов модели в формате GGUF - вариант через `hf_hub_download`"
      ],
      "metadata": {
        "id": "PW3U_YR1QWn7"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# from huggingface_hub import hf_hub_download, list_repo_tree, list_repo_files, repo_info, repo_exists, snapshot_download\n",
        "\n",
        "# # пути куда будут скачиваться модели\n",
        "# MODELS_PATH = Path('models')\n",
        "# MODELS_PATH.parent.mkdir(exist_ok=True)\n",
        "\n",
        "# # адрес репозитория модели на HF и название файла модели в формате GGUF\n",
        "# model_id = 'bartowski/gemma-2-2b-it-GGUF'\n",
        "# model_filename = 'gemma-2-2b-it-Q8_0.gguf'\n",
        "\n",
        "# # загрузка файла GGUF\n",
        "# model_path = hf_hub_download(repo_id=model_id, filename=model_filename, local_dir=MODELS_PATH)\n",
        "# model_path"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 122
        },
        "id": "1th8_Xv_QXI6",
        "outputId": "3e6bc34f-eacd-44c3-a4d8-c394a9caeab4"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "/usr/local/lib/python3.10/dist-packages/huggingface_hub/utils/_token.py:81: UserWarning: \n",
            "Access to the secret `HF_TOKEN` has not been granted on this notebook.\n",
            "You will not be requested again.\n",
            "Please restart the session if you want to be prompted again.\n",
            "  warnings.warn(\n"
          ]
        },
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "'models/gemma-2-2b-it-Q8_0.gguf'"
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Инициализация модели"
      ],
      "metadata": {
        "id": "ulW2yLn9lA0m"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# инициализация модели для генерации текста моделью в формате GGUF\n",
        "# n_gpu_layers=-1 - использовать все слои ГПУ если ГПУ доступен\n",
        "# verbose=True - выводить инфо о модели при инициализации (False чтобы ничего не выводить)\n",
        "model = Llama(model_path=str(model_path), n_gpu_layers=-1, verbose=True)"
      ],
      "metadata": {
        "id": "95sX-3xdryoL"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Новый способ инициализации модели - напрямую из репозитория HF  \n",
        "https://github.com/abetlen/llama-cpp-python/blob/main/examples/gradio_chat/local.py"
      ],
      "metadata": {
        "id": "OtMm7o3U60yf"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# MODELS_PATH = Path('models')\n",
        "# MODELS_PATH.parent.mkdir(exist_ok=True)\n",
        "\n",
        "# model = Llama.from_pretrained(\n",
        "#     repo_id=\"bartowski/gemma-2-2b-it-GGUF\",\n",
        "#     filename=\"*8_0.gguf\",\n",
        "#     local_dir=MODELS_PATH,\n",
        "#     verbose=False,\n",
        "#     # tokenizer=llama_tokenizer.LlamaHFTokenizer.from_pretrained(\"unsloth/gemma-2-2b\"),\n",
        "# )"
      ],
      "metadata": {
        "id": "kI_wkPJo6dse"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Поддерживает ли модель системный промт"
      ],
      "metadata": {
        "id": "Of4SLXtUzXTa"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "model.metadata['tokenizer.chat_template']"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 87
        },
        "id": "1wddN03nyV1f",
        "outputId": "accfee86-2968-428d-e325-634ca0523f4b"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "\"{{ bos_token }}{% if messages[0]['role'] == 'system' %}{{ raise_exception('System role not supported') }}{% endif %}{% for message in messages %}{% if (message['role'] == 'user') != (loop.index0 % 2 == 0) %}{{ raise_exception('Conversation roles must alternate user/assistant/user/assistant/...') }}{% endif %}{% if (message['role'] == 'assistant') %}{% set role = 'model' %}{% else %}{% set role = message['role'] %}{% endif %}{{ '<start_of_turn>' + role + '\\n' + message['content'] | trim + '<end_of_turn>\\n' }}{% endfor %}{% if add_generation_prompt %}{{'<start_of_turn>model\\n'}}{% endif %}\""
            ],
            "application/vnd.google.colaboratory.intrinsic+json": {
              "type": "string"
            }
          },
          "metadata": {},
          "execution_count": 6
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# проверка что в шаблоне токенайзера нет исключения System role not supported\n",
        "support_system_role = 'System role not supported' not in model.metadata['tokenizer.chat_template']\n",
        "support_system_role"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OTsqdIR9y-WI",
        "outputId": "564b2d43-dbf3-4b45-d57c-12f5a8cd2814"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "False"
            ]
          },
          "metadata": {},
          "execution_count": 7
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Формирование входа для модели"
      ],
      "metadata": {
        "id": "t4iUQg1yKJri"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# системный промт\n",
        "system_prompt = ''\n",
        "# входной запрос пользователя\n",
        "user_message = 'Почему трава зеленая?'\n",
        "# список с репликами юзера и бота (в данном примере одна)\n",
        "messages = []\n",
        "\n",
        "# формирование стандартного промта с запросом от пользователя\n",
        "messages.append({'role': 'user', 'content': user_message})\n",
        "messages"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "coZiRcxtKOkc",
        "outputId": "893fe1db-7c5a-4afd-9a72-ccc1980e9caa"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[{'role': 'user', 'content': 'Почему трава зеленая?'}]"
            ]
          },
          "metadata": {},
          "execution_count": 5
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Генерация текста моделью\n",
        "\n",
        "Документация по методу `create_chat_completion`  \n",
        "https://llama-cpp-python.readthedocs.io/en/latest/api-reference/#llama_cpp.Llama.create_chat_completion"
      ],
      "metadata": {
        "id": "xyvdcWVcJ8wq"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "\n",
        "# параметры генерации\n",
        "# чтобы модель отвечала одинаково достаточно поставить top_k=1, top_p=0 и repeat_penalty=1 не зависимо от остальных параметров\n",
        "GENERATE_KWARGS = dict(\n",
        "    temperature=1,  # температура для софтмакса\n",
        "    top_p=0.0,  # сумма вероятностей токенов из которых нужно выбирать следующий токен\n",
        "    top_k=1,  # из скольки максимально вероятных токенов выбирать следующий токен\n",
        "    repeat_penalty=1.0,  # штраф модели за повторения\n",
        "    )\n",
        "\n",
        "# создание объекта итератора для генерации текста\n",
        "# при итерации по этому объекту в цикле она будет возвращать сгенерированный текст частями текста (токенами)\n",
        "stream_response = model.create_chat_completion(\n",
        "    messages=messages,  # входной промт на который надо сгенерировать ответ\n",
        "    stream=True,  # вернуть генератор\n",
        "    **GENERATE_KWARGS,  # передача параметров генерации\n",
        "    )\n",
        "\n",
        "# пустую строку будем конкатенировать с токенами ответа модели\n",
        "response_text = ''\n",
        "# итерация и последовательная генерация текста моделью в цикле\n",
        "for chunk in stream_response:\n",
        "    # извлечение текущего сгенерированного токена\n",
        "    token = chunk['choices'][0]['delta'].get('content')\n",
        "    if token is not None:\n",
        "        response_text += token\n",
        "        print(token, end='')"
      ],
      "metadata": {
        "id": "Ng99Cz76ryrA",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "a50a1d41-62ef-4fff-c828-0060e41dea1d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "Llama.generate: 14 prefix-match hit, remaining 1 prompt tokens to eval\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Трава зеленая из-за пигмента, называемого **хлорофиллом**. \n",
            "\n",
            "Вот как это работает:\n",
            "\n",
            "* **Хлорофилл** - это пигмент, который содержится в хлоропластах, органеллах, расположенных в клетках растений. \n",
            "* **Хлорофилл** поглощает солнечный свет, особенно в красном и синем диапазоне, и отражает зеленый свет. \n",
            "* **Зеленый свет** - это то, что мы видим, когда трава отражает свет. \n",
            "\n",
            "Таким образом, трава кажется зеленой, потому что хлорофилл поглощает большинство цветов света, кроме зеленого, который отражается. \n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stderr",
          "text": [
            "\n",
            "llama_print_timings:        load time =    2217.45 ms\n",
            "llama_print_timings:      sample time =      34.25 ms /   156 runs   (    0.22 ms per token,  4555.01 tokens per second)\n",
            "llama_print_timings: prompt eval time =       0.00 ms /     0 tokens (    -nan ms per token,     -nan tokens per second)\n",
            "llama_print_timings:        eval time =   65072.76 ms /   156 runs   (  417.13 ms per token,     2.40 tokens per second)\n",
            "llama_print_timings:       total time =   65597.71 ms /   156 tokens\n"
          ]
        },
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "CPU times: user 1min 5s, sys: 109 ms, total: 1min 5s\n",
            "Wall time: 1min 5s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "# вывод что лежит в переменной chunk на последней итерации\n",
        "chunk"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "NkDSyo-O8BoQ",
        "outputId": "0578ea6e-4144-487b-d48f-3fa4e887c25d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "{'id': 'chatcmpl-a6890e0b-b821-4c10-948a-2b0357ce17a9',\n",
              " 'model': 'models/gemma-2-2b-it-Q8_0.gguf',\n",
              " 'created': 1727297719,\n",
              " 'object': 'chat.completion.chunk',\n",
              " 'choices': [{'index': 0,\n",
              "   'delta': {},\n",
              "   'logprobs': None,\n",
              "   'finish_reason': 'stop'}]}"
            ]
          },
          "metadata": {},
          "execution_count": 47
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Проверка на другом вопросе"
      ],
      "metadata": {
        "id": "ZzDtjlQ9truC"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "\n",
        "# системный промт\n",
        "system_prompt = 'Отвечай максимально кратко и простым языком, если не знаешь ответ, говори - \"Я не знаю\"'\n",
        "# входной запрос пользователя\n",
        "user_message = 'Почему коровы летают вверх ногами?'\n",
        "# список с репликами юзера и бота\n",
        "messages = []\n",
        "\n",
        "# если задан системынй промт и модель его поддерживает - добавить его в начало списка messages\n",
        "if system_prompt and support_system_role:\n",
        "    messages.append({'role': 'system', 'content': system_prompt})\n",
        "\n",
        "# добавление сообщения пользователя в список\n",
        "messages.append({'role': 'user', 'content': user_message})\n",
        "\n",
        "# параметры генерации\n",
        "# чтобы модель отвечала одинаково достаточно поставить top_k=1, top_p=0 и repeat_penalty=1 не зависимо от остальных параметров\n",
        "GENERATE_KWARGS = dict(\n",
        "    temperature=1,  # температура для софтмакса\n",
        "    top_p=0.0,  # сумма вероятностей токенов из которых нужно выбирать следующий токен\n",
        "    top_k=1,  # из скольки максимально вероятных токенов выбирать следующий токен\n",
        "    repeat_penalty=1.0,  # штраф модели за повторения\n",
        "    )\n",
        "\n",
        "# создание объекта итератора для генерации текста\n",
        "# при итерации по этому объекту в цикле она будет возвращать сгенерированный текст частями\n",
        "stream_response = model.create_chat_completion(\n",
        "    messages=messages,  # входной промт на который надо сгенерировать ответ\n",
        "    stream=True,  # вернуть генератор\n",
        "    **GENERATE_KWARGS,  # параметры генерации\n",
        "    )\n",
        "\n",
        "# пустую строку будем конкатенировать с токенами ответа модели\n",
        "response_text = ''\n",
        "# итерация и последовательная генерация текста моделью в цикле\n",
        "for chunk in stream_response:\n",
        "    # извлечение текущего сгенерированного токена\n",
        "    token = chunk['choices'][0]['delta'].get('content')\n",
        "    if token is not None:\n",
        "        response_text += token\n",
        "        print(token, end='')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "poxW3EUztuCN",
        "outputId": "302573af-763b-4a50-d9fa-cf5d66e9d6f9"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Коровы не летают вверх ногами! 🐄 \n",
            "\n",
            "Это просто шутка или забавный миф. Коровы - это животные, которые живут на земле и не умеют летать. \n",
            "\n",
            "Может быть, ты слышал эту фразу в каком-то рассказе или фильме? 😊 \n",
            "CPU times: user 30.7 s, sys: 60.6 ms, total: 30.8 s\n",
            "Wall time: 29.3 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Проверка генерации с историей сообщений"
      ],
      "metadata": {
        "id": "Als5QRC7wQay"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "%%time\n",
        "\n",
        "# системный промт\n",
        "system_prompt = ''\n",
        "# входной запрос пользователя - проверка что модель так же получает на вход историю сообщений\n",
        "user_message = 'Что я спросил и что ты ответила одно сообщение назад?'\n",
        "# список с репликами юзера и бота\n",
        "messages = []\n",
        "# какое кол-во сообщений в истории учитывать\n",
        "history_len = 1\n",
        "# история переписки пользователя и бота\n",
        "history = [\n",
        "    ['Что ты умеешь?', 'Ничего'],\n",
        "]\n",
        "\n",
        "# если задан системынй промт и он поддерживается моделью - добавить его в начало списка\n",
        "if system_prompt and support_system_role:\n",
        "    messages.append({'role': 'system', 'content': system_prompt})\n",
        "\n",
        "# итерация по истории переписки\n",
        "if history_len != 0:\n",
        "    for user_msg, bot_msg in history[-history_len:]:\n",
        "        messages.append({'role': 'user', 'content': user_msg})\n",
        "        messages.append({'role': 'assistant', 'content': bot_msg})\n",
        "\n",
        "# формирование стандартного промта с запросом от пользователя\n",
        "messages.append({'role': 'user', 'content': user_message})\n",
        "\n",
        "# параметры генерации\n",
        "# чтобы модель отвечала одинаково достаточно поставить top_k=1, top_p=0 и repeat_penalty=1 не зависимо от остальных параметров\n",
        "GENERATE_KWARGS = dict(\n",
        "    temperature=1,  # температура для софтмакса\n",
        "    top_p=0.0,  # сумма вероятностей токенов из которых нужно выбирать следующий токен\n",
        "    top_k=1,  # из скольки максимально вероятных токенов выбирать следующий токен\n",
        "    repeat_penalty=1.0,  # штраф модели за повторения\n",
        "    )\n",
        "\n",
        "# создание объекта итератора для генерации текста\n",
        "# при итерации по этому объекту в цикле она будет возвращать сгенерированный текст частями\n",
        "stream_response = model.create_chat_completion(\n",
        "    messages=messages,  # входной промт на который надо сгенерировать ответ\n",
        "    stream=True,  # вернуть генератор\n",
        "    **GENERATE_KWARGS,  # параметры генерации\n",
        "    )\n",
        "\n",
        "# пустую строку будем конкатенировать с токенами ответа модели\n",
        "response_text = ''\n",
        "# итерация и последовательная генерация текста моделью в цикле\n",
        "for chunk in stream_response:\n",
        "    # извлечение текущего сгенерированного токена\n",
        "    token = chunk['choices'][0]['delta'].get('content')\n",
        "    if token is not None:\n",
        "        response_text += token\n",
        "        print(token, end='')"
      ],
      "metadata": {
        "id": "AVA0gh-2wP_y",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "564b54e0-1326-4c3a-c201-975c1162cd78"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Ты спросил, что я умею, а я ответила, что \"ничего\". \n",
            "\n",
            "Я немного не понимаю, что ты имеешь в виду.  Может, ты хотел спросить что-то другое? \n",
            "CPU times: user 23.7 s, sys: 50.8 ms, total: 23.8 s\n",
            "Wall time: 21.9 s\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Ошибка на версиях `llama-cpp-python==0.3+` которая не позволяет передать модель в состояние Gradio"
      ],
      "metadata": {
        "id": "zXK1JS60PG-E"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from copy import deepcopy, copy\n",
        "copy(model)"
      ],
      "metadata": {
        "id": "jp18J2vBGAHd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "import gradio as gr\n",
        "model_dict = gr.State({'model': model})"
      ],
      "metadata": {
        "id": "PaOuZJ34IVJv"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Код приложения с комментариями и его запуск в Colab"
      ],
      "metadata": {
        "id": "Ur7xz02erwTt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Руководство по написанию интерфейса чат-бота в Gradio  \n",
        "https://www.gradio.app/guides/creating-a-custom-chatbot-with-blocks/"
      ],
      "metadata": {
        "id": "xo1Ul9dkwtYk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Установка библиотек"
      ],
      "metadata": {
        "id": "rq7IkDQ6ClH1"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "!pip install -q llama_cpp_python==0.2.90 gradio"
      ],
      "metadata": {
        "id": "FQUjyad2CkKO",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "867ce29e-23e8-42a0-bd74-d5bd58d0d74d"
      },
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m63.8/63.8 MB\u001b[0m \u001b[31m6.2 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Installing build dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Getting requirements to build wheel ... \u001b[?25l\u001b[?25hdone\n",
            "  Installing backend dependencies ... \u001b[?25l\u001b[?25hdone\n",
            "  Preparing metadata (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n",
            "\u001b[2K     \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m50.4/50.4 kB\u001b[0m \u001b[31m3.1 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m42.3/42.3 MB\u001b[0m \u001b[31m12.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m319.8/319.8 kB\u001b[0m \u001b[31m13.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m45.5/45.5 kB\u001b[0m \u001b[31m2.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m94.6/94.6 kB\u001b[0m \u001b[31m6.0 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m76.4/76.4 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m78.0/78.0 kB\u001b[0m \u001b[31m4.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m436.6/436.6 kB\u001b[0m \u001b[31m18.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m141.9/141.9 kB\u001b[0m \u001b[31m8.7 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m10.9/10.9 MB\u001b[0m \u001b[31m49.3 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m63.7/63.7 kB\u001b[0m \u001b[31m3.5 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m58.3/58.3 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m71.5/71.5 kB\u001b[0m \u001b[31m2.8 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[2K   \u001b[90m━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\u001b[0m \u001b[32m130.2/130.2 kB\u001b[0m \u001b[31m4.6 MB/s\u001b[0m eta \u001b[36m0:00:00\u001b[0m\n",
            "\u001b[?25h  Building wheel for llama_cpp_python (pyproject.toml) ... \u001b[?25l\u001b[?25hdone\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Содержимое файла приложения `app.py` (весь код приложения в одной ячейке)"
      ],
      "metadata": {
        "id": "p9g7HjSzOXQg"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "from pathlib import Path\n",
        "from shutil import rmtree\n",
        "from typing import Union, List, Dict, Tuple, Optional\n",
        "from tqdm import tqdm\n",
        "\n",
        "import requests\n",
        "import gradio as gr\n",
        "from llama_cpp import Llama\n",
        "\n",
        "\n",
        "# аннотация для истории переписка пользователя и бота - список словарей\n",
        "# в Gradio версиях ниже 5 это был список кортежей\n",
        "CHAT_HISTORY = List[Optional[Dict[str, Optional[str]]]]\n",
        "# аннотация для словаря с моделью. словарь чтобы у каждого пользователя приложения была своя модель\n",
        "MODEL_DICT = Dict[str, Llama]\n",
        "\n",
        "\n",
        "# =============== ФУНКЦИИ ЗАГРУЗКИ МОДЕЛИ ===============================\n",
        "\n",
        "# функция для загрузки файла по URL ссылке и отображением прогресс баров tqdm и gradio\n",
        "def download_file(file_url: str, file_path: Union[str, Path]) -> None:\n",
        "    response = requests.get(file_url, stream=True)\n",
        "    if response.status_code != 200:\n",
        "        raise Exception(f'Файл недоступен для скачивания по ссылке: {file_url}')\n",
        "    total_size = int(response.headers.get('content-length', 0))\n",
        "    progress_tqdm = tqdm(desc='Загрузка файла GGUF', total=total_size, unit='iB', unit_scale=True)\n",
        "    progress_gradio = gr.Progress()\n",
        "    completed_size = 0\n",
        "    with open(file_path, 'wb') as file:\n",
        "        for data in response.iter_content(chunk_size=4096):\n",
        "            size = file.write(data)\n",
        "            progress_tqdm.update(size)\n",
        "            completed_size += size\n",
        "            desc = f'Загрузка файла GGUF, {completed_size/1024**3:.3f}/{total_size/1024**3:.3f} GB'\n",
        "            progress_gradio(completed_size/total_size, desc=desc)\n",
        "\n",
        "\n",
        "# функция для загрузки файла модели в формате GGUF и инициализации новой модели из него\n",
        "# так же возвращает логи загрузки модели для отображения в элементе gr.Textbox()\n",
        "# и флаг поддержки системного промта моделью\n",
        "def download_gguf_and_init_model(gguf_url: str, model_dict: MODEL_DICT) -> Tuple[MODEL_DICT, bool, str]:\n",
        "    # строка с информацией о загрузке и инициализации модели для дальнейшего отображения в gr.Textbox()\n",
        "    log = ''\n",
        "    # проверка что ссылка на GGUF модель оканичивается на .gguf\n",
        "    if not gguf_url.endswith('.gguf'):\n",
        "        log += f'Ссылка на модель LLM должна быть прямой ссылкой на файл GGUF\\n'\n",
        "        return model_dict, log\n",
        "\n",
        "    # извечение имени файла модели и формирование пути до нее\n",
        "    gguf_filename = gguf_url.rsplit('/')[-1]\n",
        "    model_path = MODELS_PATH / gguf_filename\n",
        "    # прогресс бар Gradio\n",
        "    progress = gr.Progress()\n",
        "\n",
        "    # если модель еще не загружена в папку MODELS_PATH (./models)\n",
        "    if not model_path.is_file():\n",
        "        # загрузка модели по URL ссылке\n",
        "        progress(0.3, desc='Шаг 1/2: Загрузка модели GGUF')\n",
        "        try:\n",
        "            download_file(gguf_url, model_path)\n",
        "            log += f'Файл модели {gguf_filename} загружен\\n'\n",
        "        # если загрузка не удалась до записать в логи код ошибки и инфо о текущей инициализированной модели\n",
        "        except Exception as ex:\n",
        "            log += f'Ошибка загрузки модели по ссылке {gguf_url}, код ошибки:\\n{ex}\\n'\n",
        "            curr_model = model_dict.get('model')\n",
        "            # если по каким то причинам модель отсуствует в словаре model_dict то добавить это в логи\n",
        "            if curr_model is None:\n",
        "                log += f'Никакая модель не инициализирована в словаре model_dict\\n'\n",
        "                return model_dict, load_log\n",
        "            # назввание файла текущей инициализарованной модели\n",
        "            curr_model_filename = Path(curr_model.model_path).name\n",
        "            log += f'Текущая инициалищированная модель: {curr_model_filename}\\n'\n",
        "            return model_dict, log\n",
        "    # если модель уже загружена то добавить это в логи\n",
        "    else:\n",
        "        log += f'Файл модели {gguf_filename} загружен, инициализация модели...\\n'\n",
        "\n",
        "    # удаление файла предыдущей инициализированной модели если требуется такой функционал\n",
        "    # curr_model = model_dict.get('model')\n",
        "    # if curr_model is not None and Path(curr_model.model_path).is_file():\n",
        "    #     Path(curr_model.model_path).unlink(missing_ok=True)\n",
        "\n",
        "    # инициализация загруженной модели\n",
        "    progress(0.7, desc='Шаг 2/2: Инициализация модели')\n",
        "    model = Llama(model_path=str(model_path), n_gpu_layers=-1, verbose=False)\n",
        "    model_dict = {'model': model}\n",
        "    # поддерживает ли модель системный промт\n",
        "    support_system_role = 'System role not supported' not in model.metadata['tokenizer.chat_template']\n",
        "    log += f'Модель {gguf_filename} инициализирована\\n'\n",
        "    return model_dict, support_system_role, log\n",
        "\n",
        "\n",
        "# =============== ФУНКЦИИ ИНТЕРФЕЙСА ЧАТ-БОТА =============================\n",
        "\n",
        "# добавление сообщение пользователя в окошко чат бота\n",
        "def user_message_to_chatbot(user_message: str, chatbot: CHAT_HISTORY) -> Tuple[str, CHAT_HISTORY]:\n",
        "    if user_message:\n",
        "        # chatbot.append((user_message, None))  # так было в Gradio < 5 - это был список кортежей\n",
        "        chatbot.append({'role': 'user', 'metadata': {'title': None}, 'content': user_message})\n",
        "    return '', chatbot\n",
        "\n",
        "\n",
        "# генерация ответа моделью и добавление ответа в окно чат бота посимвольно\n",
        "# функция будет вызыватся при нажатии на Enter в окошке вовода текста\n",
        "# кроме обычных аргументов - сообщения пользователя и истории - принимает еще параметры для конфига генерации\n",
        "def bot_response_to_chatbot(\n",
        "        chatbot: CHAT_HISTORY,  # список переписок пользователя и бота, который отображается в окошке чат-бота\n",
        "        model_dict: MODEL_DICT,  # словарь с модель llama-cpp-python\n",
        "        system_prompt: str,  # системный промт\n",
        "        support_system_role: bool,  # поддержиывает ли модель системный промт\n",
        "        history_len: int,  # кол-во предыдущих сообщений которые учитываются в истории\n",
        "        do_sample: bool,  # использовать ли случайное семплирование при генерации ответа моделью\n",
        "        *generate_args,  # параметры генерации ответа модели\n",
        "        ):\n",
        "\n",
        "    # получение модели и проверка есть ли она там\n",
        "    model = model_dict.get('model')\n",
        "    if model is None:\n",
        "        gr.Info('Model not initialized')\n",
        "        yield chatbot\n",
        "        return\n",
        "\n",
        "    # проверка что сообщение пользователя не пустое\n",
        "    # если это первое сообщение то чат бот будет пустой\n",
        "    # если это не первое смообщение то последнее сообщение будет от бота а не от эзера\n",
        "    if len(chatbot) == 0 or chatbot[-1]['role'] == 'assistant':\n",
        "        yield chatbot\n",
        "        return\n",
        "\n",
        "    # список с переписками юзера и бота для подачи в модель\n",
        "    messages = []\n",
        "\n",
        "    # добавление системного промта если он есть и поддерживается моделью\n",
        "    if support_system_role and system_prompt:\n",
        "        messages.append({'role': 'system', 'metadata': {'title': None}, 'content': system_prompt})\n",
        "\n",
        "    # добавление истории переписки в промт (по 2 сообщения - юзера и бота)\n",
        "    if history_len != 0:\n",
        "        messages.extend(chatbot[:-1][-(history_len*2):])\n",
        "\n",
        "    # добавление текущего сообщения пользователя\n",
        "    messages.append(chatbot[-1])\n",
        "\n",
        "    # обновление словаря параметров генерации текста\n",
        "    gen_kwargs = dict(zip(GENERATE_KWARGS.keys(), generate_args))\n",
        "    gen_kwargs['top_k'] = int(gen_kwargs['top_k'])\n",
        "    # отключение случайного семплирования если do_sample=False\n",
        "    if not do_sample:\n",
        "        gen_kwargs['top_p'] = 0.0\n",
        "        gen_kwargs['top_k'] = 1\n",
        "        gen_kwargs['repeat_penalty'] = 1.0\n",
        "\n",
        "    # формирование генератора для генерации ответа моделью с форматированием промта\n",
        "    stream_response = model.create_chat_completion(\n",
        "        messages=messages,\n",
        "        stream=True,\n",
        "        **gen_kwargs,\n",
        "        )\n",
        "\n",
        "    # обновление списка чат бота для отображеня в  окошке интерфейса\n",
        "    chatbot.append({'role': 'assistant', 'metadata': {'title': None}, 'content': ''})\n",
        "\n",
        "    # итерация и генерация токенов ответа модели в цикле\n",
        "    for chunk in stream_response:\n",
        "        token = chunk['choices'][0]['delta'].get('content')\n",
        "        if token is not None:\n",
        "            chatbot[-1]['content'] += token\n",
        "            yield chatbot\n",
        "\n",
        "\n",
        "# получение окошка для системного промта. если interactive=True то можно вводить системный промт\n",
        "# примеры системных промтов:\n",
        "# Отвечай на вопросы максимально кратко, если не знаешь ответ - говори \"не знаю\".\n",
        "# Если в вопросе есть хоть малейший намек на политику, насилие, ругательства, ответь так: \"На эту тему я не могу говорить\".\n",
        "def get_system_prompt_component(interactive: bool) -> gr.Textbox:\n",
        "    value = '' if interactive else 'System prompt is not supported by this model'\n",
        "    return gr.Textbox(value=value, label='System prompt', interactive=interactive)\n",
        "\n",
        "\n",
        "# компоненты настройки конфига генерации текста\n",
        "def get_generate_args(do_sample: bool) -> List[gr.component]:\n",
        "    # если do_sample включен (элемент gr.Checkbox() активен) то отображать слайдера с параметрами генерации\n",
        "    generate_args = [\n",
        "        gr.Slider(minimum=0.1, maximum=3, value=GENERATE_KWARGS['temperature'], step=0.1, label='temperature', visible=do_sample),\n",
        "        gr.Slider(minimum=0, maximum=1, value=GENERATE_KWARGS['top_p'], step=0.01, label='top_p', visible=do_sample),\n",
        "        gr.Slider(minimum=1, maximum=50, value=GENERATE_KWARGS['top_k'], step=1, label='top_k', visible=do_sample),\n",
        "        gr.Slider(minimum=1, maximum=5, value=GENERATE_KWARGS['repeat_penalty'], step=0.1, label='repeat_penalty', visible=do_sample),\n",
        "    ]\n",
        "    return generate_args\n",
        "\n",
        "\n",
        "# ======================== ПЕРЕМЕННЫЕ ==============================\n",
        "\n",
        "# пути куда будут скачиваться модели\n",
        "MODELS_PATH = Path('models')\n",
        "MODELS_PATH.mkdir(exist_ok=True)\n",
        "\n",
        "# ссылка на модель GGUF для стартовой модели\n",
        "DEFAULT_GGUF_URL = 'https://huggingface.co/bartowski/gemma-2-2b-it-GGUF/resolve/main/gemma-2-2b-it-Q8_0.gguf'\n",
        "\n",
        "# загрузка и инициализация стартовой модели, флага поддержики системного промта и логов загрузки\n",
        "start_model_dict, start_support_system_role, start_load_log = download_gguf_and_init_model(\n",
        "    gguf_url=DEFAULT_GGUF_URL, model_dict={},\n",
        "    )\n",
        "\n",
        "# словарь для конфига генерации текста\n",
        "GENERATE_KWARGS = dict(\n",
        "    temperature=0.2,  # температура для софтмакса\n",
        "    top_p=0.95,  # сумма вероятностей токенов из которых нужно выбирать следующий токен\n",
        "    top_k=40,  # из скольки максимально вероятных токенов выбирать следующий токен\n",
        "    repeat_penalty=1.0,  # штраф модели за повторения\n",
        "    )\n",
        "\n",
        "# ====================== ИНТЕРФЕЙС ПРИЛОЖЕНИЯ ============================\n",
        "\n",
        "# тема оформления и CSS\n",
        "# theme = gr.themes.Monochrome()\n",
        "theme = gr.themes.Base(primary_hue='green', secondary_hue='yellow', neutral_hue='zinc').set(\n",
        "    loader_color='rgb(0, 255, 0)',\n",
        "    slider_color='rgb(0, 200, 0)',\n",
        "    body_text_color_dark='rgb(0, 200, 0)',\n",
        "    button_secondary_background_fill_dark='green',\n",
        ")\n",
        "css = '''.gradio-container {width: 60% !important}'''\n",
        "\n",
        "# начало описания интерфейса приложения\n",
        "with gr.Blocks(theme=theme, css=css) as interface:\n",
        "\n",
        "    # словарь с текущей моделью llama-cpp-python\n",
        "    model_dict = gr.State(start_model_dict)\n",
        "    # флаг поддержки системного промта моделью\n",
        "    support_system_role = gr.State(start_support_system_role)\n",
        "\n",
        "    # ========== СТРАНИЦА ЧАТ-БОТА ===============================\n",
        "\n",
        "    with gr.Tab('Chatbot'):\n",
        "        with gr.Row():\n",
        "            with gr.Column(scale=3):\n",
        "                # окошко чат-бота и окошко ввода сообщения пользователя\n",
        "                chatbot = gr.Chatbot(\n",
        "                    type='messages',  # new in gradio 5+\n",
        "                    show_copy_button=True,\n",
        "                    bubble_full_width=False,\n",
        "                    height=480,\n",
        "                    )\n",
        "                user_message = gr.Textbox(label='User')\n",
        "\n",
        "                # кнопки отправить сообщение, стоп генерации и удалить историю чата\n",
        "                with gr.Row():\n",
        "                    user_message_btn = gr.Button('Send')\n",
        "                    stop_btn = gr.Button('Stop')\n",
        "                    clear_btn = gr.Button('Clear')\n",
        "\n",
        "                # окошко для системного промта\n",
        "                system_prompt = get_system_prompt_component(interactive=support_system_role.value)\n",
        "\n",
        "            with gr.Column(scale=1, min_width=80):\n",
        "                with gr.Group():\n",
        "                    # длина истории которую будет учитывать модель\n",
        "                    gr.Markdown('Length of message history')\n",
        "                    history_len = gr.Slider(\n",
        "                        minimum=0,\n",
        "                        maximum=10,\n",
        "                        value=0,\n",
        "                        step=1,\n",
        "                        info='Number of previous messages taken into account in history',\n",
        "                        label='history_len',\n",
        "                        show_label=False,\n",
        "                        )\n",
        "\n",
        "                    with gr.Group():\n",
        "                        gr.Markdown('Generation parameters')\n",
        "                        # переключатель активации случайного семплирования при генерации текста моделью\n",
        "                        do_sample = gr.Checkbox(\n",
        "                            value=False,\n",
        "                            label='do_sample',\n",
        "                            info='Activate random sampling',\n",
        "                            )\n",
        "                        # параметры генерации текста\n",
        "                        generate_args = get_generate_args(do_sample.value)\n",
        "                        do_sample.change(\n",
        "                            fn=get_generate_args,\n",
        "                            inputs=do_sample,\n",
        "                            outputs=generate_args,\n",
        "                            show_progress=False,\n",
        "                        )\n",
        "\n",
        "        # ------------------ КНОПКИ ОТПРАВИТЬ ОЧИСТИТЬ И СТОП ------------\n",
        "\n",
        "        # нажатие Enter и кнопка отправить\n",
        "        generate_event = gr.on(\n",
        "            triggers=[user_message.submit, user_message_btn.click],\n",
        "            fn=user_message_to_chatbot,\n",
        "            inputs=[user_message, chatbot],\n",
        "            outputs=[user_message, chatbot],\n",
        "        ).then(\n",
        "            fn=bot_response_to_chatbot,\n",
        "            inputs=[chatbot, model_dict, system_prompt, support_system_role, history_len, do_sample, *generate_args],\n",
        "            outputs=[chatbot],\n",
        "        )\n",
        "        # кнопка Стоп\n",
        "        stop_btn.click(\n",
        "            fn=None,\n",
        "            inputs=None,\n",
        "            outputs=None,\n",
        "            cancels=generate_event,\n",
        "        )\n",
        "        # кнопка Очистить чат\n",
        "        clear_btn.click(\n",
        "            fn=lambda: None,\n",
        "            inputs=None,\n",
        "            outputs=[chatbot],\n",
        "            )\n",
        "\n",
        "    # ============= СТРАНИЦА ЗАГРУЗКИ МОДЕЛЕЙ ============================\n",
        "\n",
        "    with gr.Tab('Load model'):\n",
        "        # окно для URL ссылки на модель в формате GGUF\n",
        "        gguf_url = gr.Textbox(\n",
        "            value='',\n",
        "            label='Link to GGUF',\n",
        "            placeholder='URL link to the model in GGUF format',\n",
        "            )\n",
        "        # кнопка загрузки модели по URL ссылке\n",
        "        load_model_btn = gr.Button('Downloading GGUF and initializing the model')\n",
        "\n",
        "        # статус загрузки и инициализации модели\n",
        "        load_log = gr.Textbox(\n",
        "            value=start_load_log,\n",
        "            label='Model loading status',\n",
        "            lines=3,\n",
        "            )\n",
        "\n",
        "        # нажатие кнопки загрузки и инициализации модели\n",
        "        load_model_btn.click(\n",
        "            fn=download_gguf_and_init_model,\n",
        "            inputs=[gguf_url, model_dict],\n",
        "            outputs=[model_dict, support_system_role, load_log],\n",
        "        ).success(\n",
        "            fn=get_system_prompt_component,\n",
        "            inputs=[support_system_role],\n",
        "            outputs=[system_prompt],\n",
        "        )\n",
        "\n",
        "# запуск приложения в Colab\n",
        "interface.launch(debug=True)\n",
        "\n",
        "# запуск приложения при деплое\n",
        "# interface.launch(server_name='0.0.0.0', server_port=7860)"
      ],
      "metadata": {
        "id": "yU6b0s6VOXWd"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "dcYBhs1GKORy"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "# в таком формате в Gradio 5+ объект gr.Chatbot(type='messages') хранит историю переписки\n",
        "chatbot_messages = [\n",
        "    {'role': 'user', 'metadata': {'title': None}, 'content': 'что ты умеешь?'},\n",
        "    {'role': 'assistant', 'metadata': {'title': None}, 'content': 'Вы написали: что ты умеешь?'},\n",
        "    {'role': 'user', 'metadata': {'title': None}, 'content': 'как дела?'},\n",
        "]"
      ],
      "metadata": {
        "id": "bIIQotExsI0G"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Docker"
      ],
      "metadata": {
        "id": "LRauQ_6SYKXg"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Сборка Docker образа и запуск контейнера с приложением**"
      ],
      "metadata": {
        "id": "trzyH0o0YKXh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "G1nHsMSGYKXh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Стек**\n",
        "\n",
        "Библиотека `llama-cpp-python` для инференса модели в формате GGUF  \n",
        "https://github.com/abetlen/llama-cpp-python\n",
        "\n",
        "Инструкции по Docker образам для `llama-cpp-python`  \n",
        "https://github.com/abetlen/llama-cpp-python/tree/main/docker\n",
        "\n",
        "Образы Nvidia CUDA  \n",
        "https://catalog.ngc.nvidia.com/orgs/nvidia/containers/cuda"
      ],
      "metadata": {
        "id": "84ip-4CAYKXi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Содержимое всех файлов кроме `*docker*` такое же как в разделе `Структура и код приложения`"
      ],
      "metadata": {
        "id": "NaEUvGq5rmOs"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "o1B2UNQU8m6z"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Структура проекта**:  \n",
        " - 📁 `models`\n",
        " - `.dockerignore`\n",
        " - `Dockerfile-cpu`\n",
        " - `Dockerfile-cuda`\n",
        " - `requirements.txt`\n",
        " - `app.py`\n",
        " - `utils.py`\n"
      ],
      "metadata": {
        "id": "Z8D4-huVx3cz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "n_fLy6Qz8lic"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Сборка образа и запуск контейнера:**\n",
        "\n",
        "1. Сборка образа  \n",
        "\n",
        " - с поддержкой CPU\n",
        "```\n",
        "docker build -t gradio-llamacpp-chatbot:cpu -f Dockerfile-cpu .\n",
        "```\n",
        "\n",
        " - с поддержкой CUDA\n",
        "```\n",
        "docker build -t gradio-llamacpp-chatbot:cuda -f Dockerfile-cuda .\n",
        "```\n",
        "\n",
        "2. Запуск контейнера на 7860 порту с пробросом папок через `docker volumes`\n",
        " - с поддержкой CPU\n",
        "```\n",
        "docker run -it -p 7860:7860 -v ./models:/app/models --name chatbot gradio-llamacpp-chatbot:cpu\n",
        "```\n",
        "\n",
        " - с поддержкой CUDA\n",
        "```\n",
        "docker run -it --gpus all -p 7860:7860 -v ./models:/app/models --name chatbot gradio-llamacpp-chatbot:cuda\n",
        "```\n",
        "\n",
        "Открыть в браузере адрес http://localhost:7860/  \n",
        "При первом запуске произойдет загрузка модели по умолчаню (`gemma-2-2b-it-Q8_0.gguf`, 2.7GB) в папку `./models`, поэтому приложение доступно не сразу"
      ],
      "metadata": {
        "id": "JoW3phfCrmOt"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "GnIZHupb8pi_"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Содержимое `.dockerignore`:**  \n",
        "```\n",
        "__pycache__\n",
        "env*\n",
        "models/*\n",
        "*.ipynb\n",
        "```"
      ],
      "metadata": {
        "id": "o_NrpzKtrmOu"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Содержимое `Dockerfile-cpu`**\n",
        "```\n",
        "FROM python:3.10\n",
        "WORKDIR /app\n",
        "COPY requirements.txt .\n",
        "RUN pip install --no-cache-dir -r requirements.txt\n",
        "COPY . .\n",
        "EXPOSE 7860\n",
        "CMD [\"python3\", \"app.py\"]\n",
        "```\n",
        "Несжатый образ занимает 1.37GB"
      ],
      "metadata": {
        "id": "cvU3cCgD4544"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Содержимое `Dockerfile-cuda`**\n",
        "```\n",
        "ARG CUDA_IMAGE='12.5.0-devel-ubuntu22.04'\n",
        "FROM nvidia/cuda:${CUDA_IMAGE} AS builder\n",
        "\n",
        "RUN apt-get update && apt-get upgrade -y \\\n",
        "    && apt-get install -y git build-essential \\\n",
        "    python3 python3-pip gcc wget \\\n",
        "    ocl-icd-opencl-dev opencl-headers clinfo \\\n",
        "    libclblast-dev libopenblas-dev \\\n",
        "    && mkdir -p /etc/OpenCL/vendors && echo 'libnvidia-opencl.so.1' > /etc/OpenCL/vendors/nvidia.icd\n",
        "\n",
        "ENV CUDA_DOCKER_ARCH=all\n",
        "ENV GGML_CUDA=1\n",
        "\n",
        "RUN python3 -m pip install --upgrade \\\n",
        "    pip pytest cmake scikit-build setuptools \\\n",
        "    fastapi uvicorn sse-starlette pydantic-settings starlette-context\n",
        "\n",
        "COPY requirements.txt .\n",
        "RUN CMAKE_ARGS='-DGGML_CUDA=on' pip install --no-cache-dir -r requirements.txt\n",
        "\n",
        "FROM nvcr.io/nvidia/cuda:12.5.0-runtime-ubuntu22.04\n",
        "\n",
        "RUN apt-get update && apt-get upgrade -y \\\n",
        "    && apt-get install -y python3 python3-pip \\\n",
        "    && apt-get clean && rm -rf /var/lib/apt/lists/*\n",
        "\n",
        "ARG PYTHON_VERSION=3.10\n",
        "COPY --from=builder /usr/local/lib/python${PYTHON_VERSION}/dist-packages /usr/local/lib/python${PYTHON_VERSION}/dist-packages\n",
        "COPY --from=builder /etc/OpenCL /etc/OpenCL\n",
        "\n",
        "WORKDIR /app\n",
        "COPY app.py .\n",
        "EXPOSE 7860\n",
        "CMD [\"python3\", \"app.py\"]\n",
        "```\n",
        "Несжатый образ занимает 5.05GB"
      ],
      "metadata": {
        "id": "XR2eAWLD455H"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "oZBL-RYvYKXi"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Запушить образы на Docker Hub**\n",
        "\n",
        "Залогиниться в Docker Hub\n",
        "```\n",
        "docker login\n",
        "```\n",
        "\n",
        "Чтобы запушить образ, он должен иметь название в формате `имя_пользователя/имя_образа:тэг`, например `username/gradio-app:latest`  \n",
        "Если название не в нужном формате то надо создать ссылку на образ с правильным форматом командой `docker tag`  \n",
        "(заменить `your_username` на свое имя на Docker Hub)\n",
        "```\n",
        "docker tag gradio-llamacpp-chatbot:cpu your_username/gradio-llamacpp-chatbot:cpu\n",
        "```\n",
        "\n",
        "Запушить образ на Docker Hub\n",
        "```\n",
        "docker push your_username/gradio-llamacpp-chatbot:cpu\n",
        "```"
      ],
      "metadata": {
        "id": "uPICrrK9u7aX"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "# Деплой на облачный сервер (Gradio + NGINX)"
      ],
      "metadata": {
        "id": "v1UmrPrHF_H7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "*Деплой приложения на Gradio на облачный сервер и дополнительное подключение сервера NGINX + аренда и подключение своего домена + установка сертификатов SSL для работы приложения по протоколу HTTPS*  "
      ],
      "metadata": {
        "id": "IB6qwthE8yCW"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Подключение к облачному серверу"
      ],
      "metadata": {
        "id": "EaMaf0bJodsv"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Подключение к удаленному серверу vk cloud**"
      ],
      "metadata": {
        "id": "J3NiqoAGodsw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> *Данная инструкция так же проверялась на сервере от immers.cloud, разница только в расположении меню и настроек, и на immers.cloud не нужно открывать порты, они уже открыты*  "
      ],
      "metadata": {
        "id": "nB_-5cSqodsw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---\n",
        "Личный кабинет панель управления  \n",
        "https://msk.cloud.vk.com/app\n",
        "\n",
        "1. Создать ключевую пару - нажать на профиль и выбрать `Ключевые пары` (необязательно создавать сейчас - можно создать потом во время создания ВМ)  \n",
        "Скачается закрытый ключ (например с и названием `ssh-vk.pem`), с его помощью можно подключится через команду  \n",
        "`ssh -i файл_ключа`  \n",
        "\n",
        "2. `Облачные вычисления` - `Виртуальные машины` - `Создать инстанс `  \n",
        "Выбрать созданный ранее или новый SSH ключ  \n",
        "При создании ВМ конкретно на vk cloud на вкладке сеть в разделе Настройки Firewall должен быть виден квадрат с надписью ssh, если его нет до добавить его (Добавить группу безопасности - ssh)  \n",
        "После создания ВМ будет отображен IP адрес для подключения (здесь и далее будет использоваться пример IP `90.156.218.32`)  \n",
        "\n",
        "3. Подключение в ВМ с указанием полученного ключа `ssh-vk.pem`  \n",
        "Если выбрали ОС `Ubuntu` то имя пользователя будет `ubuntu` (на разных серверах по разному, например на Selectel имя пользователя `root`)\n",
        "```\n",
        "ssh -i путь_до_ssh_ключа/файл_ssh_ключа имя_пользователя@IP_сервера\n",
        "```\n",
        "Например\n",
        "```\n",
        "ssh -i C:\\Users\\111\\.ssh\\ssh-vk.pem ubuntu@90.156.218.32\n",
        "```\n",
        "В этом примере скачанный на шаге 1 SSH ключ `ssh-vk.pem` находится в директории `C:\\Users\\111\\.ssh\\`  \n",
        "Так же можно отдельно заранее создать свой собственный ключ и указать его публичную часть при создании ВМ"
      ],
      "metadata": {
        "id": "z6z1ikXiodsw"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Здесь и далее в качестве арендованного IP рассматривается пример  http://90.156.218.32/ - нужно будет заменить на свой**"
      ],
      "metadata": {
        "id": "0zvzO-DvnOq9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Открытие портов на облачном сервере"
      ],
      "metadata": {
        "id": "THGcPGj5mOmm"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Если на сервере, отличном от VK Cloud (например immers.cloud), порты открыты, то все инструкции по пробросу портов в этом ноутбуке делать не нужно и можно сразу переходить в браузере по адресуи порту, на котром запущено приложение, например http://90.156.218.32:7860/**  "
      ],
      "metadata": {
        "id": "OYLICDymodsz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Открытие (проброс) портов в VK Cloud и открытие приложения в браузере**\n",
        "\n",
        "`Панель управления` в `Виртуальные сети` - `Настройки Firewall` - добавить имя группы правил (например `chatbot`) - `Входящий трафик` -\n",
        "`Добавить правило` - указать порт `7860`, затем `Добавить виртуальную машину` и выбрать свою ВМ  \n",
        "После применения настроек (настройка применяется не моментально) перейти в браузере на адрес и порт, на котром запущено приложение, например http://90.156.218.32:7860/"
      ],
      "metadata": {
        "id": "xKWKePSKodsz"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> *Проверить открыты ли порты у сервера (на примере IP сервера 91.219.226.152 и 7860 порта)*\n",
        "```\n",
        "nc -zv 91.219.226.152 7860\n",
        "telnet 91.219.226.152 7860\n",
        "```"
      ],
      "metadata": {
        "id": "zV4IchjT-aQM"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Установка библиотек и запуск приложения по HTTP"
      ],
      "metadata": {
        "id": "dhNWd-UymuRh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Установка библиотек, активация виртуального окружения и создание файлов приложения**"
      ],
      "metadata": {
        "id": "Hn_qAEeyodsx"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "```sh\n",
        "# установка python и вспомогательных библиотек\n",
        "sudo apt update\n",
        "sudo apt install -y python3 python3-pip python3-venv nano unzip\n",
        "\n",
        "# создание директории проекта и переход в нее\n",
        "mkdir chatbot_gradio\n",
        "cd chatbot_gradio\n",
        "\n",
        "# создание и активация виртуального окружения python\n",
        "python3 -m venv env\n",
        "source ./env/bin/activate\n",
        "pip install -U pip\n",
        "\n",
        "# если нужно например скачать архив с файлами проекта - закинуть его на Gdrive и открыть к нему доступ\n",
        "# pip install gdown\n",
        "# gdown ID_Архива_на_Gdrive\n",
        "# unzip archive.zip\n",
        "```"
      ],
      "metadata": {
        "id": "5cieojg4odsy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Создать файлы `app.py` и `requirements.txt`, заполнить их содержимым из раздела `Струткура и код проекта` и установить зависимости\n",
        "\n",
        "Если нужна установка `llama-cpp-python` с поддержкой CUDA то установить ее заранее по [инструкции](https://github.com/abetlen/llama-cpp-python?tab=readme-ov-file#installation-configuration) для своей системы\n",
        "\n",
        "```\n",
        "nano app.py\n",
        "nano requirements.txt\n",
        "pip install -r requirements.txt\n",
        "```\n",
        "В конце файла `app.py` установить параметр `server_name='0.0.0.0` при запуске приложения, потом после подключения сервера NGINX его можно убрать  \n"
      ],
      "metadata": {
        "id": "XWrTVrOvrI1I"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "WghqB2Dpodsy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Запуск приложения и открытие в браузере по протоколу HTTP**\n",
        "```\n",
        "python3 app.py\n",
        "```\n",
        "\n",
        "Перейти в браузере по адресу http://90.156.218.32:7860/ (порт 7860 должен быть открыт)"
      ],
      "metadata": {
        "id": "xkK_And_odsy"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Настройка NGINX для запуска на localhost"
      ],
      "metadata": {
        "id": "wCQivjeDods0"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "NGINX документация  \n",
        "https://nginx.org/ru/"
      ],
      "metadata": {
        "id": "BWMdoKrTTQax"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "NGINX - высокопроизводительный веб-сервер и обратный прокси-сервер с открытым исходным кодом.  \n",
        "Ключевые функции NGINX:\n",
        " - `Веб-сервер:`  \n",
        "Nginx может отдавать веб-страницы и файлы пользователям, когда они заходят на сайт.\n",
        " - `Обратный прокси:`  \n",
        "Перенаправляет запросы от клиентов к другим серверам, скрывая детали внутренней сети.\n",
        " - `Балансировка нагрузки:`  \n",
        "Распределяет входящие запросы между несколькими серверами, чтобы ни один сервер не был перегружен.\n",
        " - `Кэширование:`  \n",
        "Сохраняет копии часто запрашиваемых данных, чтобы быстрее отдавать их пользователям.\n",
        " - `SSL/TLS терминация:`  \n",
        "Обрабатывает шифрованные HTTPS-соединения, обеспечивая безопасность передачи данных.\n",
        " - `Сжатие данных:`  \n",
        "Уменьшает размер передаваемых данных, ускоряя загрузку веб-страниц.\n",
        " - `Обработка статического контента:`  \n",
        "Эффективно обслуживает неизменяемые файлы, такие как изображения или CSS.\n",
        " - `Ограничение скорости:`  \n",
        "Контролирует количество запросов от пользователя, защищая от перегрузок.\n",
        " - `Аутентификация:`  \n",
        "Может проверять пользователей перед предоставлением доступа к определенным ресурсам.\n",
        " - `Перезапись URL:`  \n",
        "Изменяет URL-адреса запросов, помогая в маршрутизации и SEO-оптимизации.\n"
      ],
      "metadata": {
        "id": "WlnSLODARCJ-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**NGINX можно конфигурировать несколькими способами:**  \n",
        " - 1) через правку основного конфига `/etc/nginx/nginx.conf`\n",
        " - 2) добавление своих конфигов в директорию `/etc/nginx/sites-available/` и их активация/деактивация путем добавления/удаления ссылок на них в директорию `/etc/nginx/sites-enabled/`\n",
        " - 3) добавление своих конфигов в директорию `/etc/hginx/conf.d`  \n",
        "\n",
        "Здесь будет использован способ 2, способ 1 рассмотрен внизу данного раздела в разделе дополнительно"
      ],
      "metadata": {
        "id": "uuY0q_wwi_DS"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "XkliALeoj3tY"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Установка и настройка NGINX**"
      ],
      "metadata": {
        "id": "I9nTtD70ods1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "1. Установка и включение автозапуска NGINX\n",
        "```\n",
        "sudo apt install -y nginx\n",
        "sudo systemctl enable nginx\n",
        "```\n",
        "\n",
        "2. Создание файла конфига NGINX\n",
        "```\n",
        "sudo nano /etc/nginx/sites-available/chatbot.conf\n",
        "```\n",
        "Вставить туда содержимое\n",
        "\n",
        "```\n",
        "server {\n",
        "    listen 80;\n",
        "    listen [::]:80;\n",
        "    # server_name - слушать вшешний IP облачного сервера (если указать localhost тоже будет работать)\n",
        "    # потом заменить server_name на арендованный домен с настроенной А-записью, например chatbot.nachalo2024.ru\n",
        "    server_name 90.156.218.32;  \n",
        "\n",
        "    location / {\n",
        "        proxy_pass http://127.0.0.1:7860;  # проксировть запросы на приложение Gradio\n",
        "        \n",
        "        # дополнительные заголовки при передаче запроса от клиента к серверу, нужны для корректной работы многих приложений\n",
        "        proxy_set_header Host $host;\n",
        "        proxy_set_header X-Real-IP $remote_addr;\n",
        "        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n",
        "        proxy_set_header X-Forwarded-Proto $scheme;\n",
        "    }\n",
        "}\n",
        "```\n",
        "Для сохранения изменений и выхода из редактора `nano` нажать `Ctrl+S` и `Ctrl+X`\n",
        "\n",
        "3. Активация созданного конфига NGINX\n",
        "```\n",
        "sudo ln -s /etc/nginx/sites-available/chatbot.conf /etc/nginx/sites-enabled/\n",
        "```\n",
        "В итоге в папке разрешенных сайтов `/etc/nginx/sites-enabled/` появится символическая ссылка на `chatbot.conf`\n",
        "\n",
        "4. Отключить конфиг `default` (который показывает главную страницу NGINX)\n",
        "```\n",
        "sudo rm /etc/nginx/sites-enabled/default\n",
        "```\n",
        "\n",
        "5. Перезапустить NGINX, чтобы изменения вступили в силу  \n",
        "Здесь и далее после любых изменений конфигов нужно выпонять эту команду\n",
        "```\n",
        "sudo systemctl restart nginx\n",
        "```\n",
        "Проверить статус NGINX можно командой\n",
        "```\n",
        "sudo systemctl status nginx\n",
        "```\n",
        "Проверка конфигурации NGINX на на наличие ошибок\n",
        "```\n",
        "sudo nginx -t\n",
        "```\n",
        "Должно вывести\n",
        "```\n",
        "nginx: the configuration file /etc/nginx/nginx.conf syntax is ok\n",
        "nginx: configuration file /etc/nginx/nginx.conf test is successful\n",
        "```"
      ],
      "metadata": {
        "id": "3x3vLcTWods1"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "H0MHMl61ods2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Запуск приложения и открытие в браузере по протоколу HTTP**"
      ],
      "metadata": {
        "id": "ESWhrY5qods2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "В фаерволе открыть 80 порт как в инструкции `Открытие портов` в разделе выше (просто добавить правило с ту же созданную группу `chatbot`)  \n",
        "Порт 8000 можно закрыть, он больше не нужен (через три точки - удалить)  \n",
        "Теперь можно запускать приложение на локальном хосте - `127.0.0.1` - NGINX будет проксировать запросы на него  \n",
        "То есть можно в `app.py` убрать параметр `server_name='0.0.0.0'` в  `chatbot_interface.launch()`\n",
        "\n",
        "Запуск приложения\n",
        "```\n",
        "python3 app.py\n",
        "```\n",
        "\n",
        "Перейти в браузере по адресу http://90.156.218.32/ (порт 80 должен быть открыт)"
      ],
      "metadata": {
        "id": "CUnWsCrvods2"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "jnk0SeNPi00j"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Дополнительно**\n",
        "\n",
        "Вариант настройки NGINX через правку основного конфига `/etc/nginx/nginx.conf`\n",
        "\n",
        "```\n",
        "sudo nano /etc/nginx/nginx.conf\n",
        "```\n",
        "Удалить все текущее содержимое файла в редакторе nano - `Alt + \\`, `Alt + T`"
      ],
      "metadata": {
        "id": "EXvAXtEeivlA"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Содержимое `/etc/nginx/nginx.conf` для запуска на localhost**\n",
        "```\n",
        "events {\n",
        "    worker_connections 1024;\n",
        "}\n",
        "http {\n",
        "    server {\n",
        "        listen 80;\n",
        "        server_name localhost;  # localhost или IP адрес сервера или домен\n",
        "\n",
        "        location / {\n",
        "            proxy_pass http://127.0.0.1:7860;  # адрес где запущено приложение Gradio\n",
        "            proxy_set_header Host $host;\n",
        "            proxy_set_header X-Real-IP $remote_addr;\n",
        "            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n",
        "            proxy_set_header X-Forwarded-Proto $scheme;\n",
        "        }\n",
        "    }\n",
        "}\n",
        "```"
      ],
      "metadata": {
        "id": "tppCeIqTnHXd"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Запуск приложения и открытие в браузере по протоколу HTTP**\n",
        "```\n",
        "python3 app.py\n",
        "```\n",
        "\n",
        "Перейти в браузере по адресу http://90.156.218.32/ (порт 80 должен быть открыт)"
      ],
      "metadata": {
        "id": "7BRgnlLZls9X"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Активация автоматического перезапуска приложения (опционально)"
      ],
      "metadata": {
        "id": "lt4zebPHods4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Создать systemd сервис для автоматического перезапуска приложения\n",
        "```\n",
        "sudo nano /etc/systemd/system/chatbot.service\n",
        "```\n",
        "\n",
        "Содержимое сервиса\n",
        "```\n",
        "[Unit]\n",
        "Description=Chatbot service\n",
        "\n",
        "[Service]\n",
        "# пользователь, от имени которого должен работать процесс\n",
        "# указать своего пользователя если он называется не ubuntu\n",
        "User=ubuntu\n",
        "# перезапуск всегда даже если завершилось ошибкой\n",
        "Restart=always\n",
        "\n",
        "# рабочий каталог и переменная PATH, где находятся исполняемые файлы процесса\n",
        "WorkingDirectory=/home/ubuntu/chatbot_gradio\n",
        "Environment=PATH=/home/ubuntu/chatbot_gradio/env/bin:/usr/local/sbin:/usr/local/bin:/usr/sbin:/usr/bin\n",
        "\n",
        "# команда для старта сервиса (здесь нужно использовать полный путь)\n",
        "ExecStart=/home/ubuntu/chatbot_gradio/env/bin/python3 app.py\n",
        "\n",
        "[Install]\n",
        "WantedBy=multi-user.target\n",
        "```\n",
        "\n",
        "Перезагрузка конфигурации systemd, запуск сервсиса, добавление в автозапуск и проверка статуса\n",
        "```\n",
        "sudo systemctl daemon-reload\n",
        "sudo systemctl start chatbot\n",
        "sudo systemctl enable chatbot\n",
        "sudo systemctl status chatbot\n",
        "```\n",
        "Название сервиса `chatbot` - это название сервиса которое мы создавали командой  - `sudo nano /etc/systemd/system/chatbot.service`"
      ],
      "metadata": {
        "id": "TYhFEEiuods4"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "J3hET7Xeu1LG"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Варианты опции Restart для сервиса**\n",
        "\n",
        " - `no` (по умолчанию): Сервис не будет автоматически перезапускаться.\n",
        " - `always`: Сервис всегда перезапускается, независимо от причины завершения.\n",
        " - `on-success`: Перезапуск только если процесс завершился с кодом выхода 0 или сигналом SIGHUP, SIGINT, SIGTERM или SIGPIPE.\n",
        " - `on-failure`: Перезапуск если процесс завершился с ненулевым кодом выхода, был убит сигналом, или истекло время ожидания.\n",
        " - `on-abnormal`: Перезапуск если процесс был убит сигналом, истекло время ожидания, или если сервис не смог остановиться корректно.\n",
        " - `on-abort`: Перезапуск только если процесс завершился по сигналу, который обычно создает core dump.\n",
        " - `on-watchdog`: Перезапуск только если истекло время ожидания watchdog."
      ],
      "metadata": {
        "id": "1gtV62cHuWKh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Регистрация и настройка своего домена (сайта)"
      ],
      "metadata": {
        "id": "lc4qsYnbods6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Аренда своего домена**\n",
        "\n",
        "---\n",
        "Регистрация домена на примере сервиса Reg RU  \n",
        "https://www.reg.ru/\n",
        "\n",
        "Здесь и далее в качестве примера названия арендованного домена будет рассматриваться `nachalo2024.ru`  \n",
        "Настройки и условия описаны на момент июля 2024, они могут менятся\n",
        "\n",
        "---\n",
        "После регистрации и оплаты домена Reg RU подключает платный хостинг на месяц, которым можно пользоваться месяц бесплатно, или можно сразу перейти на бесплатные серверы DNS\n",
        "\n",
        "Инcтрукция как изменить DNS серверы на бесплатные (актуально для Reg RU):  \n",
        "Заходим в `Домены` -> нажимаем на наш домен `nachalo2024.ru` -> `DNS-серверы и управление зоной` -> `Изменить` -> `DNS-серверы Изменить` -> выбрать `Бесплатные DNS-серверы ns1.reg.ru, ns2.reg.ru` -> `Да`  \n",
        "Процесс обновления DNS может занять до 24 часов  \n",
        "Проверить какие DNS установлены для любого сайта можно на этом же сайте через [whois](https://www.reg.ru/whois/)\n",
        "\n",
        "---\n",
        "После регистрации и оплаты домена нужно добавить А-запись DNS, которая будет указывать, на какой IP адрес указывает наш домен  \n",
        "Например пользователи будут заходить на домен `chatbot.nachalo2024.ru`, и с помощью А-записи они будут перенаправляться на IP адрес арендованного сервера на котором запущено наше приложение на Gradio - например `90.156.218.32`\n",
        "\n",
        "---\n",
        "Как добавлять A-записи [инструкция](https://help.reg.ru/support/dns-servery-i-nastroyka-zony/nastroyka-resursnykh-zapisey-dns/nastroyka-resursnykh-zapisey-v-lichnom-kabinete#0)\n",
        "\n",
        "Как добавлять A-записи быстрая инструкция:  \n",
        "Под надписью `Ресурсные записи` нажимаем `Добавить запись` -> `A` -> в поле `Subdomain` вводим любое название для поддомена, например `chatbot`, в поле `IP Address` вводим IP арендованной виртуальной машины, например `90.156.218.32`  \n",
        "Таким образом поддомен `chatbot.nachalo2024.ru` будет связан с IP `90.156.218.32`\n",
        "\n",
        "Перенаправление заработает не сразу, бывает нужно ждать долго (у меня уходило примерно 3 - 20 мин но говорят что может занимать до нескольких дней)  \n",
        "\n",
        "Проверка что А-запись активна и домен работает\n",
        "```\n",
        "ping chatbot.nachalo2024.ru\n",
        "nslookup chatbot.nachalo2024.ru\n",
        "```\n",
        "Онлайн проверка что А-запись активна и домен работает  \n",
        "https://www.digwebinterface.com/  \n",
        "https://dnschecker.org/  "
      ],
      "metadata": {
        "id": "3qlA0I1-ods6"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "IJfX_aQYods7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Дополнительно**\n",
        "\n",
        "Быстро проверить что домен работает и происходит перенапраление на работающее приложение на сервере\n",
        "```\n",
        "sudo apt update\n",
        "sudo apt install -y python3\n",
        "python3 -m http.server --bind 0.0.0.0 8000\n",
        "```\n",
        "Для проверки сервера перейти на http://90.156.218.32:8000/  \n",
        "Для проверки домена перейти на http://chatbot.nachalo2024.ru:8000/  \n",
        "На сервере должен быть открыт порт `8000`"
      ],
      "metadata": {
        "id": "Y_1c8EPCods7"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Настройка NGINX для запуска на арендованном домене"
      ],
      "metadata": {
        "id": "DnZn_booXOIh"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Перед запуском данного раздела нужно выполнить код из раздела `Подключение к серверу, установка библиотек` и установить nginx"
      ],
      "metadata": {
        "id": "ZS7p1LSjeKdk"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Редактирование (или создание) файла конфига NGINX\n",
        "```\n",
        "sudo nano /etc/nginx/sites-available/chatbot.conf\n",
        "```\n",
        "Вставить туда содержимое\n",
        "```\n",
        "server {\n",
        "    listen 80;\n",
        "    listen [::]:80;\n",
        "    server_name chatbot.nachalo2024.ru;  # арендованный домен с настроенной А-записью\n",
        "\n",
        "    location / {\n",
        "        proxy_pass http://127.0.0.1:7860;  # проксировть запросы на приложение Gradio\n",
        "        proxy_set_header Host $host;\n",
        "        proxy_set_header X-Real-IP $remote_addr;\n",
        "        proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;\n",
        "        proxy_set_header X-Forwarded-Proto $scheme;\n",
        "    }\n",
        "}\n",
        "```\n",
        "\n",
        "Перезапустить NGINX, чтобы изменения вступили в силу  \n",
        "Здесь и далее после любых изменений конфигов нужно выпонять эту команду\n",
        "```\n",
        "sudo systemctl restart nginx\n",
        "```\n",
        "\n",
        "Запуск приложения и открытие в браузере по протоколу HTTP\n",
        "```\n",
        "python3 app.py\n",
        "```\n",
        "\n",
        "Перейти в браузере по адресу http://chatbot.nachalo.ru/ (порт 80 должен быть открыт)"
      ],
      "metadata": {
        "id": "1TMk85GUV064"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "> Если сайт не открывается, и мы уже ранее проводили с ним эксперименты, возможно браузер закэшировал старую DNS запись (можно проверить в другом браузере, и если сайт открывается то это так)  \n",
        "Исправить это можно очистив кэш браузера (или очистить отдельно DNS кэш, например в Chrome введя в адресную строку `chrome://net-internals/#dns`, нажать `Enter` и нажать `Clear host cache`)  \n",
        "Очистить кэш DNS в ОС Windows можно через командную строку, введя `ipconfig /flushdns`"
      ],
      "metadata": {
        "id": "8gErJUWhods8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "## Установка SSL сертификата и запуск приложения по HTTPS"
      ],
      "metadata": {
        "id": "BSR4o5fvods8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "Чтобы сайт нормально работал по протоколу HTTPS, нужно установить для него SSL сертификат, в данном примере устанавливается бесплатный сертификат Let's Encrypt  \n",
        "https://letsencrypt.org/ru/getting-started/\n",
        "\n",
        "1. Установка Certbot\n",
        "```\n",
        "sudo apt install -y certbot python3-certbot-nginx\n",
        "```\n",
        "\n",
        "2. Создание SSL-сертификата\n",
        "```\n",
        "sudo certbot --nginx -d chatbot.nachalo2024.ru -m email_adress@mail.ru --agree-tos\n",
        "```\n",
        "Эта команда обновляет файл конфига NGINX нашего приложения `/etc/nginx/sites-available/chatbot.conf`  \n",
        "\n",
        "3. Активировать автопродление сертификата когда срок действия закончится (опционально)\n",
        "```\n",
        "sudo certbot renew --dry-run\n",
        "```\n",
        "\n",
        "4. Перезапустить службу NGINX\n",
        "```\n",
        "sudo systemctl restart nginx\n",
        "```"
      ],
      "metadata": {
        "id": "tIDZ96rgods8"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "tA_TIg0eods9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Запуск приложения и открытие в браузере по протоколу HTTPS**"
      ],
      "metadata": {
        "id": "DwYXmaIZods9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "В фаерволе открыть 443 порт как в инструкции `Проброс портов` в разделе выше  \n",
        "Порт 80 можно не удалять - NGINX будет перенаправлять запросы с HTTP на HTTPS (с 80 порта на 443)\n",
        "\n",
        "Запуск приложения\n",
        "```\n",
        "python3 app.py\n",
        "```\n",
        "\n",
        "Перейти в браузере по адресу https://chatbot.nachalo2024.ru/"
      ],
      "metadata": {
        "id": "Vx5FBuDXods9"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "L5HkQM3dods-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Дополнительные команды**\n",
        "\n",
        "Попытки получить сертификат ограничены, если несколько раз это сделать неудачно то будет временная блокировка на получение сертификата, поэтому есть безопасная версия команды - просто проверить что ошибок нет и сертификат будет выдан\n",
        "```\n",
        "sudo certbot certonly --dry-run --nginx -d fastapi.nachalo2024.ru -m адрес_email@mail.ru --agree-tos\n",
        "```\n",
        "Если напишет `The dry run was successful.` то все ок и можно делать основную команду\n",
        "\n",
        "Проверить текущие сертификаты\n",
        "```\n",
        "sudo certbot certificates\n",
        "```\n",
        "\n",
        "Если при установке сертификата ошибка `duplicate location` то нужно отключить конфиги которыые конфликтуют  \n",
        "Список активированных конфигов\n",
        "```\n",
        "ls /etc/nginx/sites-enabled/\n",
        "```\n",
        "Отключить конфиг (например конфиг `default`)\n",
        "```\n",
        "sudo rm /etc/nginx/sites-enabled/default\n",
        "```\n",
        "И перезапустить службу\n",
        "```\n",
        "sudo systemctl restart nginx\n",
        "```"
      ],
      "metadata": {
        "id": "eo8MkiHaods-"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "---"
      ],
      "metadata": {
        "id": "zR-veh2U9z5g"
      }
    },
    {
      "cell_type": "markdown",
      "source": [
        "**Дополнительные прочие команды**\n",
        "\n",
        "Если порт 7860 занят (например мы вылетели из сервера при работающем приложении потом снова загли) то нужно узнать PID процесса командой `sudo lsof -i :7860`, затем убить его командой `sudo kill -9 PID`"
      ],
      "metadata": {
        "id": "N2HOqB1H92mS"
      }
    }
  ]
}