YandexGPT_OpenSearch_LCEL_memory-02.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "c8fd8966-b575-4996-9e63-ffb7e7fa1802",
   "metadata": {},
   "source": [
    "## Работа с YandexGPT и OpenSearch с помощью фреймворка Langchain"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5fccbdbe-becf-4c19-b48c-6237b4307b5c",
   "metadata": {},
   "source": [
    "### 1. Устанавливаем необходимые библиотеки"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "ff5a2013-45f2-450c-b5ad-719717e5167a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:42:34.361017Z",
     "iopub.status.busy": "2024-04-13T15:42:34.359709Z",
     "iopub.status.idle": "2024-04-13T15:42:40.726937Z",
     "shell.execute_reply": "2024-04-13T15:42:40.726182Z",
     "shell.execute_reply.started": "2024-04-13T15:42:34.360978Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Defaulting to user installation because normal site-packages is not writeable\n",
      "Requirement already satisfied: yandex-chain in /home/jupyter/.local/lib/python3.10/site-packages (from -r requirements.txt (line 1)) (0.0.4)\n",
      "Requirement already satisfied: yandexcloud in /home/jupyter/.local/lib/python3.10/site-packages (from -r requirements.txt (line 2)) (0.255.0)\n",
      "Requirement already satisfied: opensearch-py in /home/jupyter/.local/lib/python3.10/site-packages (from -r requirements.txt (line 3)) (2.4.2)\n",
      "Requirement already satisfied: pypdf in /home/jupyter/.local/lib/python3.10/site-packages (from -r requirements.txt (line 4)) (3.9.0)\n",
      "Requirement already satisfied: langchain-community in /home/jupyter/.local/lib/python3.10/site-packages (from -r requirements.txt (line 5)) (0.0.32)\n",
      "Requirement already satisfied: langchain-text-splitters in /home/jupyter/.local/lib/python3.10/site-packages (from -r requirements.txt (line 6)) (0.0.1)\n",
      "Requirement already satisfied: PyJWT in /home/jupyter/.local/lib/python3.10/site-packages (from -r requirements.txt (line 7)) (2.8.0)\n",
      "Requirement already satisfied: requests in /kernel/lib/python3.10/site-packages (from yandex-chain->-r requirements.txt (line 1)) (2.31.0)\n",
      "Requirement already satisfied: langchain in /home/jupyter/.local/lib/python3.10/site-packages (from yandex-chain->-r requirements.txt (line 1)) (0.1.15)\n",
      "Requirement already satisfied: tenacity in /home/jupyter/.local/lib/python3.10/site-packages (from yandex-chain->-r requirements.txt (line 1)) (8.2.3)\n",
      "Requirement already satisfied: cryptography>=2.8 in /home/jupyter/.local/lib/python3.10/site-packages (from yandexcloud->-r requirements.txt (line 2)) (41.0.4)\n",
      "Requirement already satisfied: grpcio>=1.56.2 in /home/jupyter/.local/lib/python3.10/site-packages (from yandexcloud->-r requirements.txt (line 2)) (1.62.1)\n",
      "Requirement already satisfied: protobuf>=4.23.4 in /home/jupyter/.local/lib/python3.10/site-packages (from yandexcloud->-r requirements.txt (line 2)) (4.25.2)\n",
      "Requirement already satisfied: googleapis-common-protos>=1.59.1 in /usr/local/lib/python3.10/dist-packages (from yandexcloud->-r requirements.txt (line 2)) (1.59.1)\n",
      "Requirement already satisfied: six>=1.14.0 in /kernel/lib/python3.10/site-packages (from yandexcloud->-r requirements.txt (line 2)) (1.16.0)\n",
      "Collecting urllib3>=1.26.18 (from opensearch-py->-r requirements.txt (line 3))\n",
      "  Using cached urllib3-2.2.1-py3-none-any.whl.metadata (6.4 kB)\n",
      "Requirement already satisfied: python-dateutil in /kernel/lib/python3.10/site-packages (from opensearch-py->-r requirements.txt (line 3)) (2.9.0.post0)\n",
      "Requirement already satisfied: certifi>=2022.12.07 in /kernel/lib/python3.10/site-packages (from opensearch-py->-r requirements.txt (line 3)) (2024.2.2)\n",
      "Requirement already satisfied: PyYAML>=5.3 in /usr/local/lib/python3.10/dist-packages (from langchain-community->-r requirements.txt (line 5)) (6.0.1)\n",
      "Requirement already satisfied: SQLAlchemy<3,>=1.4 in /usr/local/lib/python3.10/dist-packages (from langchain-community->-r requirements.txt (line 5)) (2.0.19)\n",
      "Requirement already satisfied: aiohttp<4.0.0,>=3.8.3 in /usr/local/lib/python3.10/dist-packages (from langchain-community->-r requirements.txt (line 5)) (3.8.5)\n",
      "Requirement already satisfied: dataclasses-json<0.7,>=0.5.7 in /home/jupyter/.local/lib/python3.10/site-packages (from langchain-community->-r requirements.txt (line 5)) (0.5.14)\n",
      "Requirement already satisfied: langchain-core<0.2.0,>=0.1.41 in /home/jupyter/.local/lib/python3.10/site-packages (from langchain-community->-r requirements.txt (line 5)) (0.1.41)\n",
      "Requirement already satisfied: langsmith<0.2.0,>=0.1.0 in /home/jupyter/.local/lib/python3.10/site-packages (from langchain-community->-r requirements.txt (line 5)) (0.1.36)\n",
      "Requirement already satisfied: numpy<2,>=1 in /usr/local/lib/python3.10/dist-packages (from langchain-community->-r requirements.txt (line 5)) (1.22.4)\n",
      "Requirement already satisfied: attrs>=17.3.0 in /kernel/lib/python3.10/site-packages (from aiohttp<4.0.0,>=3.8.3->langchain-community->-r requirements.txt (line 5)) (23.2.0)\n",
      "Requirement already satisfied: charset-normalizer<4.0,>=2.0 in /kernel/lib/python3.10/site-packages (from aiohttp<4.0.0,>=3.8.3->langchain-community->-r requirements.txt (line 5)) (3.3.2)\n",
      "Requirement already satisfied: multidict<7.0,>=4.5 in /usr/local/lib/python3.10/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain-community->-r requirements.txt (line 5)) (6.0.4)\n",
      "Requirement already satisfied: async-timeout<5.0,>=4.0.0a3 in /usr/local/lib/python3.10/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain-community->-r requirements.txt (line 5)) (4.0.2)\n",
      "Requirement already satisfied: yarl<2.0,>=1.0 in /usr/local/lib/python3.10/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain-community->-r requirements.txt (line 5)) (1.9.2)\n",
      "Requirement already satisfied: frozenlist>=1.1.1 in /usr/local/lib/python3.10/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain-community->-r requirements.txt (line 5)) (1.4.0)\n",
      "Requirement already satisfied: aiosignal>=1.1.2 in /usr/local/lib/python3.10/dist-packages (from aiohttp<4.0.0,>=3.8.3->langchain-community->-r requirements.txt (line 5)) (1.3.1)\n",
      "Requirement already satisfied: cffi>=1.12 in /kernel/lib/python3.10/site-packages (from cryptography>=2.8->yandexcloud->-r requirements.txt (line 2)) (1.16.0)\n",
      "Requirement already satisfied: marshmallow<4.0.0,>=3.18.0 in /home/jupyter/.local/lib/python3.10/site-packages (from dataclasses-json<0.7,>=0.5.7->langchain-community->-r requirements.txt (line 5)) (3.20.1)\n",
      "Requirement already satisfied: typing-inspect<1,>=0.4.0 in /home/jupyter/.local/lib/python3.10/site-packages (from dataclasses-json<0.7,>=0.5.7->langchain-community->-r requirements.txt (line 5)) (0.9.0)\n",
      "Requirement already satisfied: jsonpatch<2.0,>=1.33 in /home/jupyter/.local/lib/python3.10/site-packages (from langchain-core<0.2.0,>=0.1.41->langchain-community->-r requirements.txt (line 5)) (1.33)\n",
      "Collecting packaging<24.0,>=23.2 (from langchain-core<0.2.0,>=0.1.41->langchain-community->-r requirements.txt (line 5))\n",
      "  Using cached packaging-23.2-py3-none-any.whl.metadata (3.2 kB)\n",
      "Requirement already satisfied: pydantic<3,>=1 in /usr/local/lib/python3.10/dist-packages (from langchain-core<0.2.0,>=0.1.41->langchain-community->-r requirements.txt (line 5)) (1.10.12)\n",
      "Requirement already satisfied: orjson<4.0.0,>=3.9.14 in /home/jupyter/.local/lib/python3.10/site-packages (from langsmith<0.2.0,>=0.1.0->langchain-community->-r requirements.txt (line 5)) (3.9.15)\n",
      "Requirement already satisfied: idna<4,>=2.5 in /kernel/lib/python3.10/site-packages (from requests->yandex-chain->-r requirements.txt (line 1)) (3.6)\n",
      "Requirement already satisfied: typing-extensions>=4.2.0 in /kernel/lib/python3.10/site-packages (from SQLAlchemy<3,>=1.4->langchain-community->-r requirements.txt (line 5)) (4.10.0)\n",
      "Requirement already satisfied: greenlet!=0.4.17 in /home/jupyter/.local/lib/python3.10/site-packages (from SQLAlchemy<3,>=1.4->langchain-community->-r requirements.txt (line 5)) (3.0.3)\n",
      "Requirement already satisfied: pycparser in /kernel/lib/python3.10/site-packages (from cffi>=1.12->cryptography>=2.8->yandexcloud->-r requirements.txt (line 2)) (2.21)\n",
      "Requirement already satisfied: jsonpointer>=1.9 in /home/jupyter/.local/lib/python3.10/site-packages (from jsonpatch<2.0,>=1.33->langchain-core<0.2.0,>=0.1.41->langchain-community->-r requirements.txt (line 5)) (2.4)\n",
      "Requirement already satisfied: mypy-extensions>=0.3.0 in /home/jupyter/.local/lib/python3.10/site-packages (from typing-inspect<1,>=0.4.0->dataclasses-json<0.7,>=0.5.7->langchain-community->-r requirements.txt (line 5)) (1.0.0)\n",
      "Using cached urllib3-2.2.1-py3-none-any.whl (121 kB)\n",
      "Using cached packaging-23.2-py3-none-any.whl (53 kB)\n",
      "Installing collected packages: urllib3, packaging\n",
      "\u001b[31mERROR: pip's dependency resolver does not currently take into account all the packages that are installed. This behaviour is the source of the following dependency conflicts.\n",
      "streamlit 1.24.0 requires pympler<2,>=0.9, which is not installed.\n",
      "ml-kernel 0.0.1 requires urllib3==1.25.11, but you have urllib3 2.2.1 which is incompatible.\n",
      "argilla 1.16.0 requires typer<0.8.0,>=0.6.0, but you have typer 0.9.0 which is incompatible.\n",
      "chromadb 0.4.24 requires numpy>=1.22.5, but you have numpy 1.22.4 which is incompatible.\n",
      "streamlit 1.24.0 requires importlib-metadata<7,>=1.4, but you have importlib-metadata 7.1.0 which is incompatible.\n",
      "botocore 1.23.24 requires urllib3<1.27,>=1.25.4, but you have urllib3 2.2.1 which is incompatible.\n",
      "cloud-ml 0.0.1 requires requests<=2.28.1,>=2.22.0, but you have requests 2.31.0 which is incompatible.\n",
      "dvc 2.58.2 requires platformdirs<4,>=3.1.1, but you have platformdirs 4.2.0 which is incompatible.\n",
      "dvc 2.58.2 requires psutil>=5.8, but you have psutil 5.7.3 which is incompatible.\n",
      "moviepy 1.0.3 requires decorator<5.0,>=4.0.2, but you have decorator 5.1.1 which is incompatible.\n",
      "pandas-gbq 0.17.9 requires pyarrow<10.0dev,>=3.0.0, but you have pyarrow 13.0.0 which is incompatible.\u001b[0m\u001b[31m\n",
      "\u001b[0mSuccessfully installed packaging-23.2 urllib3-1.26.18\n",
      "\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m A new release of pip is available: \u001b[0m\u001b[31;49m23.0.1\u001b[0m\u001b[39;49m -> \u001b[0m\u001b[32;49m24.0\u001b[0m\n",
      "\u001b[1m[\u001b[0m\u001b[34;49mnotice\u001b[0m\u001b[1;39;49m]\u001b[0m\u001b[39;49m To update, run: \u001b[0m\u001b[32;49mpython3 -m pip install --upgrade pip\u001b[0m\n"
     ]
    }
   ],
   "source": [
    "%pip install -r requirements.txt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "de37ab67-c431-42d4-8186-51e35d0dcd65",
   "metadata": {},
   "source": [
    "После установки библиотек необходимо перегазгрузить Kernel. Для этого в верхнем меню выберите Kernel -> Restart Kernel"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "37edd08c-8dd6-4714-a92a-00d5bcbfec34",
   "metadata": {
    "tags": []
   },
   "source": [
    "### 2. Подключение к кластеру OpenSearch"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "7d286c9e-5d55-48e7-963b-0a21f3bd5b72",
   "metadata": {},
   "source": [
    "Документация по подключению: https://cloud.yandex.ru/docs/managed-opensearch/operations/connect"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "ff8a7e94-5402-4720-8fc6-f90580ac3b53",
   "metadata": {},
   "source": [
    "#### Получение SSL-сертификата"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "5a6b0c93-fa27-472a-9f02-848eca02541f",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:42:50.866149Z",
     "iopub.status.busy": "2024-04-13T15:42:50.865652Z",
     "iopub.status.idle": "2024-04-13T15:42:50.950635Z",
     "shell.execute_reply": "2024-04-13T15:42:50.949913Z",
     "shell.execute_reply.started": "2024-04-13T15:42:50.866107Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "--2024-04-13 15:42:50--  https://storage.yandexcloud.net/cloud-certs/CA.pem\n",
      "Resolving storage.yandexcloud.net (storage.yandexcloud.net)... 213.180.193.243, 2a02:6b8::1d9\n",
      "Connecting to storage.yandexcloud.net (storage.yandexcloud.net)|213.180.193.243|:443... connected.\n",
      "HTTP request sent, awaiting response... 200 OK\n",
      "Length: 3579 (3.5K) [application/x-x509-ca-cert]\n",
      "Saving to: ‘/home/jupyter/datasphere/project/.opensearch/root.crt’\n",
      "\n",
      "     0K ...                                                   100% 3.55G=0s\n",
      "\n",
      "2024-04-13 15:42:50 (3.55 GB/s) - ‘/home/jupyter/datasphere/project/.opensearch/root.crt’ saved [3579/3579]\n",
      "\n"
     ]
    }
   ],
   "source": [
    "!mkdir -p /home/jupyter/datasphere/project/.opensearch && \\\n",
    "wget \"https://storage.yandexcloud.net/cloud-certs/CA.pem\" \\\n",
    "     --output-document /home/jupyter/datasphere/project/.opensearch/root.crt && \\\n",
    "chmod 0600 /home/jupyter/datasphere/project/.opensearch/root.crt"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "24cdbffa-d6dd-4133-adaf-e4abbc6e9b8c",
   "metadata": {},
   "source": [
    "#### Тестируем подключение к кластеру"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "c866d602-96f7-45ba-a4aa-81a16e90dabf",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:44:06.820465Z",
     "iopub.status.busy": "2024-04-13T15:44:06.819441Z",
     "iopub.status.idle": "2024-04-13T15:44:06.842570Z",
     "shell.execute_reply": "2024-04-13T15:44:06.841787Z",
     "shell.execute_reply.started": "2024-04-13T15:44:06.820420Z"
    }
   },
   "outputs": [],
   "source": [
    "CA = '/home/jupyter/datasphere/project/.opensearch/root.crt'\n",
    "\n",
    "import os\n",
    "#Укажите пароль для пользователя admin\n",
    "PASS = os.environ['MDB_OS_PWD'] # Обратиться к секрету <имя_секрета> из переменных окружения\n",
    "#Укажите список хостов кластера\n",
    "HOSTS = os.environ['MDB_OS_HOSTS'].split(\",\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "cc3b485f-23a8-480a-b01a-926e37170215",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:44:11.947180Z",
     "iopub.status.busy": "2024-04-13T15:44:11.946285Z",
     "iopub.status.idle": "2024-04-13T15:44:12.344651Z",
     "shell.execute_reply": "2024-04-13T15:44:12.343951Z",
     "shell.execute_reply.started": "2024-04-13T15:44:11.947137Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "{'name': 'rc1a-9r5h0inf2p0f3tk2.mdb.yandexcloud.net', 'cluster_name': 'c9qthb5rf6to08jrn7uo', 'cluster_uuid': 'us1xtR19RCe9tSmOydAvOg', 'version': {'distribution': 'opensearch', 'number': '2.8.0', 'build_type': 'deb', 'build_hash': '8cbab9609696cd93c45fd5f3090560648c04f5af', 'build_date': '2023-10-04T14:42:52.695597332Z', 'build_snapshot': False, 'lucene_version': '9.6.0', 'minimum_wire_compatibility_version': '7.10.0', 'minimum_index_compatibility_version': '7.0.0'}, 'tagline': 'The OpenSearch Project: https://opensearch.org/'}\n"
     ]
    }
   ],
   "source": [
    "from opensearchpy import OpenSearch\n",
    "\n",
    "conn = OpenSearch(\n",
    "  HOSTS,\n",
    "  http_auth=('admin', PASS),\n",
    "  use_ssl=True,\n",
    "  verify_certs=True,\n",
    "  ca_certs=CA)\n",
    "\n",
    "print(conn.info())"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "2becda23-4ec2-4903-ad50-dea4e18a08a3",
   "metadata": {},
   "source": [
    "При правильной настройке подключения код выше вернет объект dict с информацией об имени кластера, uuid, версии и т.д."
   ]
  },
  {
   "cell_type": "markdown",
   "id": "388886d0-98ce-4493-823d-8fb59da67990",
   "metadata": {},
   "source": [
    "### 2. Получаем IAM-токен для работы с YandexGPT"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "017656f3-8d1c-4834-869e-2344c3e30dae",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:44:21.118510Z",
     "iopub.status.busy": "2024-04-13T15:44:21.117568Z",
     "iopub.status.idle": "2024-04-13T15:44:21.301251Z",
     "shell.execute_reply": "2024-04-13T15:44:21.300482Z",
     "shell.execute_reply.started": "2024-04-13T15:44:21.118478Z"
    }
   },
   "outputs": [],
   "source": [
    "import time\n",
    "import jwt\n",
    "import requests"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6911d89-78b1-4e14-82fd-19c7f7aa399c",
   "metadata": {},
   "source": [
    "Для того, чтобы обратиться из DataSphere к YandexGPT в настройках проекта необходимо указать сервисный аккаунт, у которого есть роль ai.languageModels.user. Для сервисного аккаунта необходимо создать **авторизованный** ключ доступа. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "daf218fe-907b-4eb3-b93d-739e65ecbaf9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:46:13.118058Z",
     "iopub.status.busy": "2024-04-13T15:46:13.117154Z",
     "iopub.status.idle": "2024-04-13T15:46:13.141491Z",
     "shell.execute_reply": "2024-04-13T15:46:13.140685Z",
     "shell.execute_reply.started": "2024-04-13T15:46:13.118014Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "service_account_id = os.environ[\"SA_ID\"] #обращаемся к переменным окружения\n",
    "key_id = os.environ[\"KEY_ID\"]\n",
    "private_key = \"-----BEGIN PRIVATE KEY-----\\nsdsadasdasdasdasds\\n-----END PRIVATE KEY-----\\n\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "b1ed5015-3d81-4b74-8fba-71c90772da7e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:45:59.401217Z",
     "iopub.status.busy": "2024-04-13T15:45:59.400420Z",
     "iopub.status.idle": "2024-04-13T15:45:59.655638Z",
     "shell.execute_reply": "2024-04-13T15:45:59.655020Z",
     "shell.execute_reply.started": "2024-04-13T15:45:59.401176Z"
    }
   },
   "outputs": [],
   "source": [
    "# Получаем IAM-токен\n",
    "\n",
    "now = int(time.time())\n",
    "payload = {\n",
    "        'aud': 'https://iam.api.cloud.yandex.net/iam/v1/tokens',\n",
    "        'iss': service_account_id,\n",
    "        'iat': now,\n",
    "        'exp': now + 360}\n",
    "\n",
    "# Формирование JWT\n",
    "encoded_token = jwt.encode(\n",
    "    payload,\n",
    "    private_key,\n",
    "    algorithm='PS256',\n",
    "    headers={'kid': key_id})\n",
    "\n",
    "url = 'https://iam.api.cloud.yandex.net/iam/v1/tokens'\n",
    "x = requests.post(url,  \n",
    "                  headers={'Content-Type': 'application/json'},\n",
    "                  json = {'jwt': encoded_token}).json()\n",
    "token = x['iamToken']"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "31915474-76b1-43f4-94c7-aef99385cb3f",
   "metadata": {},
   "source": [
    "### 3. Создаем индекс в OpenSearch для поиска релевантных документов"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "b18cd101-8614-426d-9b8d-ec18efc6cc06",
   "metadata": {},
   "source": [
    "Устанавливаем LangChain. **LangChain** — это фреймворк для разработки приложений на базе языковых моделей."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "fbd7c854-f2d0-493b-a16a-5d89fcd745e3",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:47:22.743204Z",
     "iopub.status.busy": "2024-04-13T15:47:22.742684Z",
     "iopub.status.idle": "2024-04-13T15:47:24.324503Z",
     "shell.execute_reply": "2024-04-13T15:47:24.323821Z",
     "shell.execute_reply.started": "2024-04-13T15:47:22.743163Z"
    }
   },
   "outputs": [],
   "source": [
    "import langchain\n",
    "from operator import itemgetter\n",
    "from langchain.document_loaders import DirectoryLoader, PyPDFLoader, TextLoader\n",
    "from langchain.text_splitter import RecursiveCharacterTextSplitter\n",
    "from langchain.memory import ConversationBufferMemory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "31b8ecf7-25c1-469d-be20-3263e9bb885a",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:47:40.996029Z",
     "iopub.status.busy": "2024-04-13T15:47:40.995154Z",
     "iopub.status.idle": "2024-04-13T15:47:41.009124Z",
     "shell.execute_reply": "2024-04-13T15:47:41.008367Z",
     "shell.execute_reply.started": "2024-04-13T15:47:40.995989Z"
    }
   },
   "outputs": [],
   "source": [
    "# Указываем путь к папке с документами в Object Storage. Для этого выберите Сopy Path\n",
    "source_dir = \"/home/jupyter/datasphere/s3/....\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "177077d5-75ce-4e8e-9a0c-aee6e7a63b40",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:52:07.647900Z",
     "iopub.status.busy": "2024-04-13T15:52:07.647078Z",
     "iopub.status.idle": "2024-04-13T15:52:07.678573Z",
     "shell.execute_reply": "2024-04-13T15:52:07.677876Z",
     "shell.execute_reply.started": "2024-04-13T15:52:07.647858Z"
    }
   },
   "outputs": [],
   "source": [
    "# Создаем объект для считывания документов из S3 бакета \n",
    "loader = DirectoryLoader(source_dir, \n",
    "                         glob=\"**/*.pdf\", \n",
    "                         loader_cls=PyPDFLoader, \n",
    "                         silent_errors=True,\n",
    "                         show_progress=True, \n",
    "                         recursive=True\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "9bf9c599-9c65-47a1-805d-9103e398cc4c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:52:51.139425Z",
     "iopub.status.busy": "2024-04-13T15:52:51.138684Z",
     "iopub.status.idle": "2024-04-13T15:52:51.156419Z",
     "shell.execute_reply": "2024-04-13T15:52:51.155805Z",
     "shell.execute_reply.started": "2024-04-13T15:52:51.139384Z"
    }
   },
   "outputs": [],
   "source": [
    "# Указываем длины фрагмента, на который разбиваются документы\n",
    "\n",
    "CHUNK_SIZE = 1000\n",
    "CHUNK_OVERLAP = 100"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "id": "08c2cc29-33c0-4211-9305-fb3e4a83ee69",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:55:16.780385Z",
     "iopub.status.busy": "2024-04-13T15:55:16.779562Z",
     "iopub.status.idle": "2024-04-13T15:55:18.268093Z",
     "shell.execute_reply": "2024-04-13T15:55:18.267240Z",
     "shell.execute_reply.started": "2024-04-13T15:55:16.780340Z"
    }
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "100%|██████████| 2/2 [00:01<00:00,  1.84it/s]"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Количество фрагментов, на которые разбиты все документы = 15\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "\n"
     ]
    }
   ],
   "source": [
    "# Считываем документы и разбиваем на фрагменты\n",
    "\n",
    "documents = loader.load()\n",
    "text_splitter = RecursiveCharacterTextSplitter(\n",
    "    chunk_size=CHUNK_SIZE, \n",
    "    chunk_overlap=CHUNK_OVERLAP\n",
    ")\n",
    "docs = text_splitter.split_documents(documents)\n",
    "\n",
    "print(f\"Количество фрагментов, на которые разбиты все документы = {len(docs)}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "0a7b5c74-5978-4bb9-b5c5-87c2a9e481ab",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:58:16.183857Z",
     "iopub.status.busy": "2024-04-13T15:58:16.182856Z",
     "iopub.status.idle": "2024-04-13T15:58:16.200503Z",
     "shell.execute_reply": "2024-04-13T15:58:16.199708Z",
     "shell.execute_reply.started": "2024-04-13T15:58:16.183813Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Cоздаем объект YandexGPTEmbeddings для построения векторов с помощью YandexGPT\n",
    "from yandex_chain import YandexEmbeddings\n",
    "folder_id = os.environ[\"YC_FOLDER_ID\"]\n",
    "embeddings = YandexEmbeddings(folder_id=folder_id, iam_token = token)\n",
    "embeddings.sleep_interval = 0.1 #текущее ограничение эмбеддера 10 RPS, делаем задержку 1/10 секунды, чтобы не выйти за это ограничение"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "733255e9-5a53-4bcc-a8d2-3044234a793d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T15:58:22.636236Z",
     "iopub.status.busy": "2024-04-13T15:58:22.635378Z",
     "iopub.status.idle": "2024-04-13T15:58:22.646742Z",
     "shell.execute_reply": "2024-04-13T15:58:22.646079Z",
     "shell.execute_reply.started": "2024-04-13T15:58:22.636194Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Ориентировочное время оцифровки = 0.7000000000000001 с.\n"
     ]
    }
   ],
   "source": [
    "text_to_print = f\"Ориентировочное время оцифровки = {len(documents)*embeddings.sleep_interval} с.\"\n",
    "print(text_to_print)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "id": "15964efa-9324-4933-93ce-6b84e561c08d",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:00:46.474944Z",
     "iopub.status.busy": "2024-04-13T16:00:46.474045Z",
     "iopub.status.idle": "2024-04-13T16:00:50.548090Z",
     "shell.execute_reply": "2024-04-13T16:00:50.547354Z",
     "shell.execute_reply.started": "2024-04-13T16:00:46.474887Z"
    }
   },
   "outputs": [],
   "source": [
    "# Строим вектора по документам и добавляем их в базу OpenSearch\n",
    "from langchain_community.vectorstores import OpenSearchVectorSearch\n",
    "\n",
    "docsearch = OpenSearchVectorSearch.from_documents(\n",
    "     docs,\n",
    "     embeddings,\n",
    "     opensearch_url=HOSTS,\n",
    "     http_auth=(\"admin\", PASS),\n",
    "     use_ssl = True,\n",
    "     verify_certs = True,\n",
    "     ca_certs = CA,\n",
    "     engine = 'lucene',\n",
    "     index_name = \"yagpt-rag-demo-1000-100\", # индекс, к которому будут добавлены новые вектора текущей документации\n",
    "     bulk_size=1000000,\n",
    "     space_type=\"cosinesimil\"\n",
    ")\n",
    "# space_type: \"l2\", \"l1\", \"cosinesimil\", \"linf\", \"innerproduct\"; default: \"l2\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "id": "6d823e5d-ce90-4b4c-8d6a-984540b6f5f6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:07:08.079807Z",
     "iopub.status.busy": "2024-04-13T16:07:08.078766Z",
     "iopub.status.idle": "2024-04-13T16:07:08.090717Z",
     "shell.execute_reply": "2024-04-13T16:07:08.089915Z",
     "shell.execute_reply.started": "2024-04-13T16:07:08.079764Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Если эмбеддинги уже есть, то запускаем эту строчку\n",
    "docsearch2 = OpenSearchVectorSearch (\n",
    "    embedding_function=embeddings,\n",
    "    index_name = \"yc-docs-md-1000-200\", # уже существующий индекс, с которым будем работать дальше (к нему ничего не добавляется)\n",
    "    opensearch_url=HOSTS,\n",
    "    http_auth=(\"admin\", PASS),\n",
    "    use_ssl = True,\n",
    "    verify_certs = True,\n",
    "    ca_certs = CA,\n",
    "    engine = 'lucene'\n",
    ")  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "c745aef6-427a-4e35-a84d-c05853ad1c4c",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:05:08.892057Z",
     "iopub.status.busy": "2024-04-13T16:05:08.891279Z",
     "iopub.status.idle": "2024-04-13T16:05:09.080237Z",
     "shell.execute_reply": "2024-04-13T16:05:09.079472Z",
     "shell.execute_reply.started": "2024-04-13T16:05:08.892010Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Document(page_content='13.02.2024, 16:08 Устройство сети в Yandex Cloud | Yandex Cloud - Документация\\nhttps://cloud.yandex.ru/ru/docs/vpc/concepts/network-overview 2/5\\nОдин из основных компонентов физической сети — транспортная сеть Yandex Cloud.\\nК транспортной сети подключаются:\\nЦОД (зоны доступности) Yande x Cloud.\\nТочки присутствия (Point of Presence или PoP). На точках прис утствия размещается сетевое оборудование транспортной сети. На отдельных точка\\nвнешним се тям и  интернету (Internet Peering). На отдельных точках присутствия клиентам Yande x Cloud предоставляется возможность организова\\nсобственной инфраструктуре и облачными ресурсами  и публичным се рвисам  Yande x Cloud с п омощью услуги Yande x Cloud Interconne ct.\\nТранспортная сеть Yande x Cloud со стоит из двух уровней:\\nУровень оптической сети DWD M. Оборудование оптического спектрального уплотнения (DWD M ) обеспечивает подключение оборудования уро', metadata={'source': '/home/jupyter/datasphere/s3/ds-knights-demo/Устройство сети в Yandex Cloud _ Yandex Cloud - Докумен.pdf', 'page': 1}),\n",
       " Document(page_content='13.02.2024, 16:08 Устройство сети в Yandex Cloud | Yandex Cloud - Документация\\nhttps://cloud.yandex.ru/ru/docs/vpc/concepts/network-overview 1/5Концепции\\xa0/ Устройство сети в Yandex Cloud\\nСтатья создана Yandex Cloud Обновлена \\x00\\x00 декабря \\x00\\x00\\x00\\x00 г.\\nФизическая сеть в Yande x Cloud\\nВиртуальная сеть в Yande x Cloud\\nVRouter\\nVRouter-agent\\nCloudGate\\nВиды сетевого взаимодействия\\nОграничения\\nДополнительные материалы\\nСеть в Yande x Cloud мо жно условно разделить на две большие части:\\nФизическая сеть — э то аппаратная сеть внутри центров обработки данных (ЦОД), транспортная сеть между ЦОД и в местах подключения к внешн\\nназывают терми ном Underlay.\\nВиртуальная сеть — р аботает поверх физической сетевой инфраструктуры. Сервисы виртуальной сети Virtual Private Cloud (VPC) предоставляют п\\nIP-связность между облачными ресурса ми.\\nДоступ облачных ресурсо в к интернету.\\nВиртуальную сеть часто называют термином Overlay. В одном каталоге ресурсо в может быть создана одна или несколько виртуальных сетей. Вир', metadata={'source': '/home/jupyter/datasphere/s3/ds-knights-demo/Устройство сети в Yandex Cloud _ Yandex Cloud - Докумен.pdf', 'page': 0})]"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Тестируем сохраненные вектора в docssearch\n",
    "query = \"Как устроена сеть в облаке?\"\n",
    "docs = docsearch.similarity_search(query, k=2)\n",
    "docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "b9959e73-a9f1-4f3d-9456-a37b6666bdc5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:07:12.555409Z",
     "iopub.status.busy": "2024-04-13T16:07:12.554659Z",
     "iopub.status.idle": "2024-04-13T16:07:13.345858Z",
     "shell.execute_reply": "2024-04-13T16:07:13.345179Z",
     "shell.execute_reply.started": "2024-04-13T16:07:12.555366Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Document(page_content='description: \"Облачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\"\\nkeywords:\\n  - облачная сеть\\n  - облако\\n  - сеть\\n\\nОблачные сети и подсети\\n\\nОблачные сети {#network}\\n\\nОблачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\\n\\nДля виртуальных машин Yandex Compute Cloud и хостов баз данных доступ из интернета и в интернет открыт через публичные IP-адреса.\\n\\nУправлять трафиком в облачных сетях и подсетях можно с помощью групп безопасности. Они содержат правила, которые определяют протоколы и IP-адреса для приема и отправки трафика.\\n\\nПодсети {#subnet}', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/vpc/concepts/network.md', 'start_index': 0}),\n",
       " Document(page_content='Облака и их виды\\n\\nОблако — это сеть мощных компьютеров, расположенных в дата-центрах и доступных через интернет. Существует три основных вида облака: частное, публичное и гибридное.\\n\\nЧастное Все оборудование располагается в собственных помещениях компании, а его обслуживанием занимаются внутренние сотрудники. Информация и инфраструктура надежно защищены, но для этого требуются большие финансовые вложения. Публичное Компания арендует оборудование в необходимом ей объеме, а техническим обслуживанием занимается поставщик услуг. Это позволяет устранить затраты на поддержание вычислительной инфраструктуры и дает гибкость при выборе ресурсов. Гибридное Часть оборудования принадлежит компании и установлено на ее стороне, а часть она арендует. Такой подход встречается при постепенной миграции в облако, а также в случаях, когда требуется хранить высокочувствительные данные и компания не может доверить это стороннему исполнителю.\\n\\nМодели облачных услуг\\n\\nSaaS,\\n\\nPaaS,\\n\\nIaaS,', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/glossary/cloud-server.md', 'start_index': 659})]"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Тестируем сохраненные вектора в docssearch2\n",
    "docs2 = docsearch2.similarity_search(query, k=2)\n",
    "docs2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "f7631e2f-7772-4543-b67f-783b6a440287",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:13:51.258957Z",
     "iopub.status.busy": "2024-04-13T16:13:51.258236Z",
     "iopub.status.idle": "2024-04-13T16:13:51.275290Z",
     "shell.execute_reply": "2024-04-13T16:13:51.274324Z",
     "shell.execute_reply.started": "2024-04-13T16:13:51.258917Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.02.2024, 16:08 Устройство сети в Yandex Cloud | Yandex Cloud - Документация\n",
      "https://cloud.yandex.ru/ru/docs/vpc/concepts/network-overview 2/5\n",
      "Один из основных компонентов физической сети — транспортная сеть Yandex Cloud.\n",
      "К транспортной сети подключаются:\n",
      "ЦОД (зоны доступности) Yande x Cloud.\n",
      "Точки присутствия (Point of Presence или PoP). На точках прис утствия размещается сетевое оборудование транспортной сети. На отдельных точка\n",
      "внешним се тям и  интернету (Internet Peering). На отдельных точках присутствия клиентам Yande x Cloud предоставляется возможность организова\n",
      "собственной инфраструктуре и облачными ресурсами  и публичным се рвисам  Yande x Cloud с п омощью услуги Yande x Cloud Interconne ct.\n",
      "Транспортная сеть Yande x Cloud со стоит из двух уровней:\n",
      "Уровень оптической сети DWD M. Оборудование оптического спектрального уплотнения (DWD M ) обеспечивает подключение оборудования уро\n"
     ]
    }
   ],
   "source": [
    "# Поисковая выдача N1 по тематическому фрагменту документации\n",
    "print(docs[0].page_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "e3726eb9-9062-4ebc-89a1-dfe52f454e10",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:12:20.264250Z",
     "iopub.status.busy": "2024-04-13T16:12:20.263558Z",
     "iopub.status.idle": "2024-04-13T16:12:20.278786Z",
     "shell.execute_reply": "2024-04-13T16:12:20.278051Z",
     "shell.execute_reply.started": "2024-04-13T16:12:20.264219Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "description: \"Облачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\"\n",
      "keywords:\n",
      "  - облачная сеть\n",
      "  - облако\n",
      "  - сеть\n",
      "\n",
      "Облачные сети и подсети\n",
      "\n",
      "Облачные сети {#network}\n",
      "\n",
      "Облачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\n",
      "\n",
      "Для виртуальных машин Yandex Compute Cloud и хостов баз данных доступ из интернета и в интернет открыт через публичные IP-адреса.\n",
      "\n",
      "Управлять трафиком в облачных сетях и подсетях можно с помощью групп безопасности. Они содержат правила, которые определяют протоколы и IP-адреса для приема и отправки трафика.\n",
      "\n",
      "Подсети {#subnet}\n"
     ]
    }
   ],
   "source": [
    "# Поисковая выдача N1 по большой документации\n",
    "print(docs2[0].page_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "e6d47bb4-2793-45bb-8758-412b3fcf2f18",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:32:23.384704Z",
     "iopub.status.busy": "2024-04-13T16:32:23.383807Z",
     "iopub.status.idle": "2024-04-13T16:32:23.589381Z",
     "shell.execute_reply": "2024-04-13T16:32:23.588678Z",
     "shell.execute_reply.started": "2024-04-13T16:32:23.384660Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Document(page_content='13.02.2024, 16:08 Устройство сети в Yandex Cloud | Yandex Cloud - Документация\\nhttps://cloud.yandex.ru/ru/docs/vpc/concepts/network-overview 2/5\\nОдин из основных компонентов физической сети — транспортная сеть Yandex Cloud.\\nК транспортной сети подключаются:\\nЦОД (зоны доступности) Yande x Cloud.\\nТочки присутствия (Point of Presence или PoP). На точках прис утствия размещается сетевое оборудование транспортной сети. На отдельных точка\\nвнешним се тям и  интернету (Internet Peering). На отдельных точках присутствия клиентам Yande x Cloud предоставляется возможность организова\\nсобственной инфраструктуре и облачными ресурсами  и публичным се рвисам  Yande x Cloud с п омощью услуги Yande x Cloud Interconne ct.\\nТранспортная сеть Yande x Cloud со стоит из двух уровней:\\nУровень оптической сети DWD M. Оборудование оптического спектрального уплотнения (DWD M ) обеспечивает подключение оборудования уро', metadata={'source': '/home/jupyter/datasphere/s3/ds-knights-demo/Устройство сети в Yandex Cloud _ Yandex Cloud - Докумен.pdf', 'page': 1}),\n",
       " Document(page_content='13.02.2024, 16:08 Устройство сети в Yandex Cloud | Yandex Cloud - Документация\\nhttps://cloud.yandex.ru/ru/docs/vpc/concepts/network-overview 1/5Концепции\\xa0/ Устройство сети в Yandex Cloud\\nСтатья создана Yandex Cloud Обновлена \\x00\\x00 декабря \\x00\\x00\\x00\\x00 г.\\nФизическая сеть в Yande x Cloud\\nВиртуальная сеть в Yande x Cloud\\nVRouter\\nVRouter-agent\\nCloudGate\\nВиды сетевого взаимодействия\\nОграничения\\nДополнительные материалы\\nСеть в Yande x Cloud мо жно условно разделить на две большие части:\\nФизическая сеть — э то аппаратная сеть внутри центров обработки данных (ЦОД), транспортная сеть между ЦОД и в местах подключения к внешн\\nназывают терми ном Underlay.\\nВиртуальная сеть — р аботает поверх физической сетевой инфраструктуры. Сервисы виртуальной сети Virtual Private Cloud (VPC) предоставляют п\\nIP-связность между облачными ресурса ми.\\nДоступ облачных ресурсо в к интернету.\\nВиртуальную сеть часто называют термином Overlay. В одном каталоге ресурсо в может быть создана одна или несколько виртуальных сетей. Вир', metadata={'source': '/home/jupyter/datasphere/s3/ds-knights-demo/Устройство сети в Yandex Cloud _ Yandex Cloud - Докумен.pdf', 'page': 0})]"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Попробуем использовать ретривер, а не similarity_search\n",
    "# Сначала по тематическому фрагменту документации\n",
    "retriever = docsearch.as_retriever(search_kwargs={\"k\": 2})\n",
    "docs = retriever.invoke(query)\n",
    "docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "31e2f4eb-8103-4573-81ea-f83c72cb6c93",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:32:48.650423Z",
     "iopub.status.busy": "2024-04-13T16:32:48.649731Z",
     "iopub.status.idle": "2024-04-13T16:32:48.794352Z",
     "shell.execute_reply": "2024-04-13T16:32:48.793715Z",
     "shell.execute_reply.started": "2024-04-13T16:32:48.650382Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[Document(page_content='description: \"Облачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\"\\nkeywords:\\n  - облачная сеть\\n  - облако\\n  - сеть\\n\\nОблачные сети и подсети\\n\\nОблачные сети {#network}\\n\\nОблачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\\n\\nДля виртуальных машин Yandex Compute Cloud и хостов баз данных доступ из интернета и в интернет открыт через публичные IP-адреса.\\n\\nУправлять трафиком в облачных сетях и подсетях можно с помощью групп безопасности. Они содержат правила, которые определяют протоколы и IP-адреса для приема и отправки трафика.\\n\\nПодсети {#subnet}', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/vpc/concepts/network.md', 'start_index': 0}),\n",
       " Document(page_content='Облака и их виды\\n\\nОблако — это сеть мощных компьютеров, расположенных в дата-центрах и доступных через интернет. Существует три основных вида облака: частное, публичное и гибридное.\\n\\nЧастное Все оборудование располагается в собственных помещениях компании, а его обслуживанием занимаются внутренние сотрудники. Информация и инфраструктура надежно защищены, но для этого требуются большие финансовые вложения. Публичное Компания арендует оборудование в необходимом ей объеме, а техническим обслуживанием занимается поставщик услуг. Это позволяет устранить затраты на поддержание вычислительной инфраструктуры и дает гибкость при выборе ресурсов. Гибридное Часть оборудования принадлежит компании и установлено на ее стороне, а часть она арендует. Такой подход встречается при постепенной миграции в облако, а также в случаях, когда требуется хранить высокочувствительные данные и компания не может доверить это стороннему исполнителю.\\n\\nМодели облачных услуг\\n\\nSaaS,\\n\\nPaaS,\\n\\nIaaS,', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/glossary/cloud-server.md', 'start_index': 659})]"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Теперь используем ретривер по большой документации\n",
    "retriever2=docsearch2.as_retriever(search_kwargs={\"k\": 2})\n",
    "docs2 = retriever2.invoke(query)\n",
    "docs2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "6763baaa-5afb-43ae-84ef-137c23cdb63b",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:17:21.380215Z",
     "iopub.status.busy": "2024-04-13T16:17:21.379402Z",
     "iopub.status.idle": "2024-04-13T16:17:21.405429Z",
     "shell.execute_reply": "2024-04-13T16:17:21.404741Z",
     "shell.execute_reply.started": "2024-04-13T16:17:21.380172Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "13.02.2024, 16:08 Устройство сети в Yandex Cloud | Yandex Cloud - Документация\n",
      "https://cloud.yandex.ru/ru/docs/vpc/concepts/network-overview 2/5\n",
      "Один из основных компонентов физической сети — транспортная сеть Yandex Cloud.\n",
      "К транспортной сети подключаются:\n",
      "ЦОД (зоны доступности) Yande x Cloud.\n",
      "Точки присутствия (Point of Presence или PoP). На точках прис утствия размещается сетевое оборудование транспортной сети. На отдельных точка\n",
      "внешним се тям и  интернету (Internet Peering). На отдельных точках присутствия клиентам Yande x Cloud предоставляется возможность организова\n",
      "собственной инфраструктуре и облачными ресурсами  и публичным се рвисам  Yande x Cloud с п омощью услуги Yande x Cloud Interconne ct.\n",
      "Транспортная сеть Yande x Cloud со стоит из двух уровней:\n",
      "Уровень оптической сети DWD M. Оборудование оптического спектрального уплотнения (DWD M ) обеспечивает подключение оборудования уро\n",
      "13.02.2024, 16:08 Устройство сети в Yandex Cloud | Yandex Cloud - Документация\n",
      "https://cloud.yandex.ru/ru/docs/vpc/concepts/network-overview 1/5Концепции / Устройство сети в Yandex Cloud\n",
      "Статья создана Yandex Cloud Обновлена \u0000\u0000 декабря \u0000\u0000\u0000\u0000 г.\n",
      "Физическая сеть в Yande x Cloud\n",
      "Виртуальная сеть в Yande x Cloud\n",
      "VRouter\n",
      "VRouter-agent\n",
      "CloudGate\n",
      "Виды сетевого взаимодействия\n",
      "Ограничения\n",
      "Дополнительные материалы\n",
      "Сеть в Yande x Cloud мо жно условно разделить на две большие части:\n",
      "Физическая сеть — э то аппаратная сеть внутри центров обработки данных (ЦОД), транспортная сеть между ЦОД и в местах подключения к внешн\n",
      "называют терми ном Underlay.\n",
      "Виртуальная сеть — р аботает поверх физической сетевой инфраструктуры. Сервисы виртуальной сети Virtual Private Cloud (VPC) предоставляют п\n",
      "IP-связность между облачными ресурса ми.\n",
      "Доступ облачных ресурсо в к интернету.\n",
      "Виртуальную сеть часто называют термином Overlay. В одном каталоге ресурсо в может быть создана одна или несколько виртуальных сетей. Вир\n"
     ]
    }
   ],
   "source": [
    "# Чуть более читаемый вывод результатов поиска по тематическому фрагменту документации\n",
    "for i in range(2):\n",
    "    print(docs[i].page_content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "67e58f38-1439-46f7-b1bd-b19c2a2cbbf4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T16:18:09.027096Z",
     "iopub.status.busy": "2024-04-13T16:18:09.026236Z",
     "iopub.status.idle": "2024-04-13T16:18:09.038757Z",
     "shell.execute_reply": "2024-04-13T16:18:09.037901Z",
     "shell.execute_reply.started": "2024-04-13T16:18:09.027051Z"
    }
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "description: \"Облачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\"\n",
      "keywords:\n",
      "  - облачная сеть\n",
      "  - облако\n",
      "  - сеть\n",
      "\n",
      "Облачные сети и подсети\n",
      "\n",
      "Облачные сети {#network}\n",
      "\n",
      "Облачная сеть — это аналог традиционной локальной сети в дата-центре. Облачные сети создаются в каталогах и используются для передачи информации между облачными ресурсами и связи ресурсов с интернетом.\n",
      "\n",
      "Для виртуальных машин Yandex Compute Cloud и хостов баз данных доступ из интернета и в интернет открыт через публичные IP-адреса.\n",
      "\n",
      "Управлять трафиком в облачных сетях и подсетях можно с помощью групп безопасности. Они содержат правила, которые определяют протоколы и IP-адреса для приема и отправки трафика.\n",
      "\n",
      "Подсети {#subnet}\n",
      "Облака и их виды\n",
      "\n",
      "Облако — это сеть мощных компьютеров, расположенных в дата-центрах и доступных через интернет. Существует три основных вида облака: частное, публичное и гибридное.\n",
      "\n",
      "Частное Все оборудование располагается в собственных помещениях компании, а его обслуживанием занимаются внутренние сотрудники. Информация и инфраструктура надежно защищены, но для этого требуются большие финансовые вложения. Публичное Компания арендует оборудование в необходимом ей объеме, а техническим обслуживанием занимается поставщик услуг. Это позволяет устранить затраты на поддержание вычислительной инфраструктуры и дает гибкость при выборе ресурсов. Гибридное Часть оборудования принадлежит компании и установлено на ее стороне, а часть она арендует. Такой подход встречается при постепенной миграции в облако, а также в случаях, когда требуется хранить высокочувствительные данные и компания не может доверить это стороннему исполнителю.\n",
      "\n",
      "Модели облачных услуг\n",
      "\n",
      "SaaS,\n",
      "\n",
      "PaaS,\n",
      "\n",
      "IaaS,\n"
     ]
    }
   ],
   "source": [
    "# Чуть более читаемый вывод результатов поиска по большой документации\n",
    "for i in range(2):\n",
    "    print(docs2[i].page_content)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "486c825d-851f-45cf-909e-949fd9d86a0c",
   "metadata": {},
   "source": [
    "### 4. Обращаемся при помощи LLM к выбранным документам"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "id": "813d4e79-e098-4446-9b1c-5d93609c19e6",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:36:36.162349Z",
     "iopub.status.busy": "2024-04-13T17:36:36.161363Z",
     "iopub.status.idle": "2024-04-13T17:36:36.176723Z",
     "shell.execute_reply": "2024-04-13T17:36:36.175962Z",
     "shell.execute_reply.started": "2024-04-13T17:36:36.162304Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Сначала определим шаблоны промптов для обработки документов и для языковой модели с учетом истории общения\n",
    "\n",
    "from langchain.prompts.prompt import PromptTemplate\n",
    "from langchain_core.prompts import ChatPromptTemplate\n",
    "from langchain_core.messages import AIMessage, HumanMessage, get_buffer_string\n",
    "from langchain_core.prompts import format_document\n",
    "\n",
    "_template = \"\"\"Учитывая историю общения и текущий вопрос, составь из всего этого отдельный общий вопрос на русском языке.\n",
    "\n",
    "История общения:\n",
    "{chat_history}\n",
    "Текущий вопрос: {question}\n",
    "Отдельный общий вопрос:\"\"\"\n",
    "CONDENSE_QUESTION_PROMPT = PromptTemplate.from_template(_template)\n",
    "\n",
    "template = \"\"\"Отвечай на вопрос по информации из предоставленного ниже ДОКУМЕНТА. \n",
    "Если ответ в ДОКУМЕНТЕ отсутствует, отвечай: \"Я не знаю\" даже если думаешь, что знаешь ответ на вопрос. \n",
    "Не вздумай добавлять какие-то пояснения к \"Я не знаю\".\n",
    "ДОКУМЕНТ: {context}\n",
    "Вопрос: {question}\n",
    "\"\"\"\n",
    "ANSWER_PROMPT = ChatPromptTemplate.from_template(template)\n",
    "\n",
    "DEFAULT_DOCUMENT_PROMPT = PromptTemplate.from_template(template=\"{page_content}\")\n",
    "\n",
    "\n",
    "def _combine_documents(\n",
    "    docs, document_prompt=DEFAULT_DOCUMENT_PROMPT, document_separator=\"\\n\\n\"\n",
    "):\n",
    "    doc_strings = [format_document(doc, document_prompt) for doc in docs]\n",
    "    return document_separator.join(doc_strings)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "id": "8070e0ed-f89d-4f1f-a9b8-2e0ecf5e48ba",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:36:39.637484Z",
     "iopub.status.busy": "2024-04-13T17:36:39.636736Z",
     "iopub.status.idle": "2024-04-13T17:36:39.648870Z",
     "shell.execute_reply": "2024-04-13T17:36:39.648172Z",
     "shell.execute_reply.started": "2024-04-13T17:36:39.637449Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# инициируем модуль памяти\n",
    "memory = ConversationBufferMemory(\n",
    "    return_messages=True, output_key=\"answer\", input_key=\"question\"\n",
    ")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "id": "ed790f70-c96b-4df0-8a21-68195aa846e5",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:36:41.461294Z",
     "iopub.status.busy": "2024-04-13T17:36:41.460323Z",
     "iopub.status.idle": "2024-04-13T17:36:41.476314Z",
     "shell.execute_reply": "2024-04-13T17:36:41.475687Z",
     "shell.execute_reply.started": "2024-04-13T17:36:41.461252Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "from langchain_community.chat_models import ChatYandexGPT\n",
    "from langchain_core.runnables import RunnablePassthrough, RunnableLambda\n",
    "from langchain_core.output_parsers import StrOutputParser\n",
    "\n",
    "# Сначала мы добавляем шаг для загрузки содержимого памяти\n",
    "# Поэтому добавляем ключ \"memory\" во входящий объект\n",
    "loaded_memory = RunnablePassthrough.assign(\n",
    "    chat_history=RunnableLambda(memory.load_memory_variables) | itemgetter(\"history\"),\n",
    ")\n",
    "# выбираем какую yandexgpt модель будем использовать, и выставляем ее temperature = 0\n",
    "# model_uri = \"gpt://\"+str(folder_id)+\"/yandexgpt-lite/latest\"\n",
    "model_uri = \"gpt://\"+str(folder_id)+\"/yandexgpt/latest\"\n",
    "yagpt_model = ChatYandexGPT(iam_token = token, model_uri=model_uri, temperature = 0, max_tokens=8000)\n",
    "\n",
    "# Теперь определяем standalone_question (композитный вопрос, который учитывает историю общения)\n",
    "standalone_question = {\n",
    "    \"standalone_question\": {\n",
    "        \"question\": lambda x: x[\"question\"],\n",
    "        \"chat_history\": lambda x: get_buffer_string(x[\"chat_history\"]),\n",
    "    }\n",
    "    | CONDENSE_QUESTION_PROMPT\n",
    "    | yagpt_model\n",
    "    | StrOutputParser()\n",
    "}\n",
    "# Теперь извлекаем нужные документы по композитному запросу, используя ранее определенный ретривер \n",
    "# retriever - для тематического фрагмента документации или retriever2 - для всей документации на Яндекс Облако\n",
    "retrieved_documents = {\n",
    "    \"docs\": itemgetter(\"standalone_question\") | retriever2,\n",
    "    \"question\": lambda x: x[\"standalone_question\"],\n",
    "}\n",
    "\n",
    "# Конструируем вводные для финального промпта\n",
    "final_inputs = {\n",
    "    \"context\": lambda x: _combine_documents(x[\"docs\"]),\n",
    "    \"question\": itemgetter(\"question\"),\n",
    "}\n",
    "# Теперь запускаем выдачу ответов\n",
    "answer = {\n",
    "    \"answer\": final_inputs | ANSWER_PROMPT | yagpt_model,\n",
    "    \"docs\": itemgetter(\"docs\"),\n",
    "}\n",
    "# И собираем всю цепочку вместе!\n",
    "final_chain = loaded_memory | standalone_question | retrieved_documents | answer"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "id": "bf63e9e6-e7a7-4759-a175-41cb70113a97",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:36:44.152884Z",
     "iopub.status.busy": "2024-04-13T17:36:44.152060Z",
     "iopub.status.idle": "2024-04-13T17:36:50.069053Z",
     "shell.execute_reply": "2024-04-13T17:36:50.068328Z",
     "shell.execute_reply.started": "2024-04-13T17:36:44.152841Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'answer': AIMessage(content='Сеть в Яндекс Облаке состоит из физической и виртуальной сетей.\\n\\nОдин из основных компонентов физической сети — транспортная сеть Yandex Cloud, к которой подключаются ЦОД (зоны доступности) Yandex Cloud и точки присутствия (PoP). На отдельных точках присутствия организуются подключения к внешним сетям и интернету, а также предоставляется услуга Yandex Cloud Interconnect.\\n\\nТранспортная сеть Yandex Cloud состоит из двух уровней: трафик из внешнего мира к облачным ресурсам распределяется по всем зонам доступности Yandex Cloud, а трафик во внешний мир от облачных ресурсов распределяется по точкам присутствия. Все зоны доступности равнозначны и обеспечивают одинаковую сетевую связность.\\n\\nВиртуальная сеть в Yandex Cloud предоставляет пользователям возможность организации сетевого взаимодействия между облачными ресурсами и интернетом, а также дополнительные сетевые функции по обработке трафика.', id='run-2c5d3fc0-a262-4527-9956-443551dc1c9d-0'),\n",
       " 'docs': [Document(page_content='Физическая сеть в Yandex Cloud {#underlay}\\n\\nФизическую сеть в Yandex Cloud можно представить следующим образом:\\n\\nОдин из основных компонентов физической сети — транспортная сеть Yandex Cloud.\\n\\nК транспортной сети подключаются:\\n\\nЦОД (зоны доступности) Yandex Cloud.\\n\\nТочки присутствия (Point of Presence или PoP). На точках присутствия размещается сетевое оборудование транспортной сети. На отдельных точках присутствия организуются подключения к внешним сетям и интернету (Internet Peering). На отдельных точках присутствия клиентам Yandex Cloud предоставляется возможность организовать IP-связность между своими ресурсами в собственной инфраструктуре и облачными ресурсами и публичным сервисам Yandex Cloud с помощью услуги Yandex Cloud Interconnect.\\n\\nТранспортная сеть Yandex Cloud состоит из двух уровней:', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/_includes/overview/network.md', 'start_index': 948}),\n",
       "  Document(page_content='Трафик во внешний мир от облачных ресурсов во всех зонах доступности примерно равномерно распределяется по всем точкам присутствия.\\n\\nТрафик из внешнего мира к облачным ресурсам примерно равномерно распределяется по всем зонам доступности Yandex Cloud.\\n\\nВсе зоны доступности равнозначны — они обеспечивают одинаковую сетевую связность, то есть, одну и ту же скорость и пропускную способность. Задержки при передаче трафика от одного внешнего ресурса до облачных ресурсов в разных зонах доступности могут незначительно отличаться.\\n\\nВиртуальная сеть в Yandex Cloud {#overlay}\\n\\nВиртуальная сеть в Yandex Cloud состоит из набора сетевых функций сервиса Virtual Private Cloud и предоставляет пользователям следующие возможности:\\n\\nОрганизация сетевого взаимодействия между облачными ресурсами.\\n\\nОрганизация сетевого взаимодействия между облачными ресурсами и интернетом.\\n\\nДополнительные сетевые функции по обработке трафика (CloudGate).', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/_includes/overview/network.md', 'start_index': 2585})]}"
      ]
     },
     "execution_count": 119,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = {\"question\": \"Как устроена сеть в Яндекс Облаке?\"}\n",
    "result = final_chain.invoke(inputs)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "id": "eca1446c-4add-4bfd-8bc8-881ff0c16fa9",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:36:54.588783Z",
     "iopub.status.busy": "2024-04-13T17:36:54.587987Z",
     "iopub.status.idle": "2024-04-13T17:36:54.603872Z",
     "shell.execute_reply": "2024-04-13T17:36:54.603188Z",
     "shell.execute_reply.started": "2024-04-13T17:36:54.588738Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Обратите внимание, что память не сохраняется автоматически\n",
    "# В будущем это будет улучшено\n",
    "# А пока вам нужно сохранять данные в память самостоятельно\n",
    "memory.save_context(inputs, {\"answer\": result[\"answer\"].content})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "id": "6c3af2a5-f0c7-4e1f-af97-dd8abf9238e7",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:36:57.058014Z",
     "iopub.status.busy": "2024-04-13T17:36:57.057255Z",
     "iopub.status.idle": "2024-04-13T17:36:57.069767Z",
     "shell.execute_reply": "2024-04-13T17:36:57.069152Z",
     "shell.execute_reply.started": "2024-04-13T17:36:57.057969Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'history': [HumanMessage(content='Как устроена сеть в Яндекс Облаке?'),\n",
       "  AIMessage(content='Сеть в Яндекс Облаке состоит из физической и виртуальной сетей.\\n\\nОдин из основных компонентов физической сети — транспортная сеть Yandex Cloud, к которой подключаются ЦОД (зоны доступности) Yandex Cloud и точки присутствия (PoP). На отдельных точках присутствия организуются подключения к внешним сетям и интернету, а также предоставляется услуга Yandex Cloud Interconnect.\\n\\nТранспортная сеть Yandex Cloud состоит из двух уровней: трафик из внешнего мира к облачным ресурсам распределяется по всем зонам доступности Yandex Cloud, а трафик во внешний мир от облачных ресурсов распределяется по точкам присутствия. Все зоны доступности равнозначны и обеспечивают одинаковую сетевую связность.\\n\\nВиртуальная сеть в Yandex Cloud предоставляет пользователям возможность организации сетевого взаимодействия между облачными ресурсами и интернетом, а также дополнительные сетевые функции по обработке трафика.')]}"
      ]
     },
     "execution_count": 121,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# подгружаем данные из памяти (диалог по тематическому фрагменту документации)\n",
    "memory.load_memory_variables({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "id": "240dcf19-01be-4587-af97-58ae2355fd75",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:37:25.219366Z",
     "iopub.status.busy": "2024-04-13T17:37:25.218753Z",
     "iopub.status.idle": "2024-04-13T17:37:25.232194Z",
     "shell.execute_reply": "2024-04-13T17:37:25.231484Z",
     "shell.execute_reply.started": "2024-04-13T17:37:25.219335Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сеть в Яндекс Облаке состоит из физической и виртуальной сетей.\n",
      "\n",
      "Один из основных компонентов физической сети — транспортная сеть Yandex Cloud, к которой подключаются ЦОД (зоны доступности) Yandex Cloud и точки присутствия (PoP). На отдельных точках присутствия организуются подключения к внешним сетям и интернету, а также предоставляется услуга Yandex Cloud Interconnect.\n",
      "\n",
      "Транспортная сеть Yandex Cloud состоит из двух уровней: трафик из внешнего мира к облачным ресурсам распределяется по всем зонам доступности Yandex Cloud, а трафик во внешний мир от облачных ресурсов распределяется по точкам присутствия. Все зоны доступности равнозначны и обеспечивают одинаковую сетевую связность.\n",
      "\n",
      "Виртуальная сеть в Yandex Cloud предоставляет пользователям возможность организации сетевого взаимодействия между облачными ресурсами и интернетом, а также дополнительные сетевые функции по обработке трафика.\n"
     ]
    }
   ],
   "source": [
    "print(memory.load_memory_variables({})['history'][1].content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "id": "9c0ad761-ffed-492b-bd03-1939f91af358",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:37:08.045193Z",
     "iopub.status.busy": "2024-04-13T17:37:08.044541Z",
     "iopub.status.idle": "2024-04-13T17:37:13.671015Z",
     "shell.execute_reply": "2024-04-13T17:37:13.670318Z",
     "shell.execute_reply.started": "2024-04-13T17:37:08.045152Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'answer': AIMessage(content='Сеть в Яндекс Облаке можно условно разделить на две большие части: физическую сеть и виртуальную сеть.\\n\\n**Физическая сеть** — это аппаратная сеть внутри центров обработки данных (ЦОД), транспортная сеть между ЦОД и в местах подключения к внешним сетям и интернету. Физическую сеть часто называют термином Underlay.\\n\\n **Виртуальная сеть** работает поверх физической сетевой инфраструктуры. Сервисы виртуальной сети Virtual Private Cloud (VPC) предоставляют пользователю IP-связность между облачными ресурсами и доступ облачных ресурсов к интернету. Виртуальную сеть часто называют Overlay. В одном каталоге ресурсов может быть создана одна или несколько виртуальных сетей. Виртуальные сети изолированы друг от друга, даже если они находятся в одном каталоге ресурсов.', id='run-3ec11c6f-ab52-465f-a235-9b5840bf3b1f-0'),\n",
       " 'docs': [Document(page_content='Физическая сеть в Yandex Cloud {#underlay}\\n\\nФизическую сеть в Yandex Cloud можно представить следующим образом:\\n\\nОдин из основных компонентов физической сети — транспортная сеть Yandex Cloud.\\n\\nК транспортной сети подключаются:\\n\\nЦОД (зоны доступности) Yandex Cloud.\\n\\nТочки присутствия (Point of Presence или PoP). На точках присутствия размещается сетевое оборудование транспортной сети. На отдельных точках присутствия организуются подключения к внешним сетям и интернету (Internet Peering). На отдельных точках присутствия клиентам Yandex Cloud предоставляется возможность организовать IP-связность между своими ресурсами в собственной инфраструктуре и облачными ресурсами и публичным сервисам Yandex Cloud с помощью услуги Yandex Cloud Interconnect.\\n\\nТранспортная сеть Yandex Cloud состоит из двух уровней:', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/_includes/overview/network.md', 'start_index': 948}),\n",
       "  Document(page_content='Устройство сети в Yandex Cloud\\n\\nСеть в Yandex Cloud можно условно разделить на две большие части:\\n\\nФизическая сеть — это аппаратная сеть внутри центров обработки данных (ЦОД), транспортная сеть между ЦОД и в местах подключения к внешним сетям и интернету. Физическую сеть часто называют термином Underlay.\\n\\nВиртуальная сеть — работает поверх физической сетевой инфраструктуры. Сервисы виртуальной сети Virtual Private Cloud (VPC) предоставляют пользователю:\\n\\nIP-связность между облачными ресурсами.\\n\\nДоступ облачных ресурсов к интернету.\\n\\nВиртуальную сеть часто называют термином Overlay. В одном каталоге ресурсов может быть создана одна или несколько виртуальных сетей. Виртуальные сети изолированы друг от друга, даже если они находятся в одном каталоге ресурсов.\\n\\nНиже приведено краткое описание устройства физической сети и виртуальной сети в Yandex Cloud. Больше информации об устройстве сети можно найти в разделе дополнительные материалы.\\n\\nФизическая сеть в Yandex Cloud {#underlay}', metadata={'source': '/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/_includes/overview/network.md', 'start_index': 0})]}"
      ]
     },
     "execution_count": 123,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "inputs = {\"question\": \"Но как же она устроена?\"}\n",
    "result = final_chain.invoke(inputs)\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "id": "fa81ca75-5441-4210-b7c6-c0339fedd03e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:37:33.053804Z",
     "iopub.status.busy": "2024-04-13T17:37:33.052870Z",
     "iopub.status.idle": "2024-04-13T17:37:33.065016Z",
     "shell.execute_reply": "2024-04-13T17:37:33.064274Z",
     "shell.execute_reply.started": "2024-04-13T17:37:33.053758Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Сеть в Яндекс Облаке можно условно разделить на две большие части: физическую сеть и виртуальную сеть.\n",
      "\n",
      "**Физическая сеть** — это аппаратная сеть внутри центров обработки данных (ЦОД), транспортная сеть между ЦОД и в местах подключения к внешним сетям и интернету. Физическую сеть часто называют термином Underlay.\n",
      "\n",
      " **Виртуальная сеть** работает поверх физической сетевой инфраструктуры. Сервисы виртуальной сети Virtual Private Cloud (VPC) предоставляют пользователю IP-связность между облачными ресурсами и доступ облачных ресурсов к интернету. Виртуальную сеть часто называют Overlay. В одном каталоге ресурсов может быть создана одна или несколько виртуальных сетей. Виртуальные сети изолированы друг от друга, даже если они находятся в одном каталоге ресурсов.\n"
     ]
    }
   ],
   "source": [
    "print(result['answer'].content)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "id": "8e2d327a-8aa1-4f36-b957-66888874b463",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:37:38.653441Z",
     "iopub.status.busy": "2024-04-13T17:37:38.652781Z",
     "iopub.status.idle": "2024-04-13T17:37:38.665172Z",
     "shell.execute_reply": "2024-04-13T17:37:38.664537Z",
     "shell.execute_reply.started": "2024-04-13T17:37:38.653404Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Физическая сеть в Yandex Cloud {#underlay}\n",
      "\n",
      "Физическую сеть в Yandex Cloud можно представить следующим образом:\n",
      "\n",
      "Один из основных компонентов физической сети — транспортная сеть Yandex Cloud.\n",
      "\n",
      "К транспортной сети подключаются:\n",
      "\n",
      "ЦОД (зоны доступности) Yandex Cloud.\n",
      "\n",
      "Точки присутствия (Point of Presence или PoP). На точках присутствия размещается сетевое оборудование транспортной сети. На отдельных точках присутствия организуются подключения к внешним сетям и интернету (Internet Peering). На отдельных точках присутствия клиентам Yandex Cloud предоставляется возможность организовать IP-связность между своими ресурсами в собственной инфраструктуре и облачными ресурсами и публичным сервисам Yandex Cloud с помощью услуги Yandex Cloud Interconnect.\n",
      "\n",
      "Транспортная сеть Yandex Cloud состоит из двух уровней:\n",
      " ****************************************** \n",
      "\n",
      "Устройство сети в Yandex Cloud\n",
      "\n",
      "Сеть в Yandex Cloud можно условно разделить на две большие части:\n",
      "\n",
      "Физическая сеть — это аппаратная сеть внутри центров обработки данных (ЦОД), транспортная сеть между ЦОД и в местах подключения к внешним сетям и интернету. Физическую сеть часто называют термином Underlay.\n",
      "\n",
      "Виртуальная сеть — работает поверх физической сетевой инфраструктуры. Сервисы виртуальной сети Virtual Private Cloud (VPC) предоставляют пользователю:\n",
      "\n",
      "IP-связность между облачными ресурсами.\n",
      "\n",
      "Доступ облачных ресурсов к интернету.\n",
      "\n",
      "Виртуальную сеть часто называют термином Overlay. В одном каталоге ресурсов может быть создана одна или несколько виртуальных сетей. Виртуальные сети изолированы друг от друга, даже если они находятся в одном каталоге ресурсов.\n",
      "\n",
      "Ниже приведено краткое описание устройства физической сети и виртуальной сети в Yandex Cloud. Больше информации об устройстве сети можно найти в разделе дополнительные материалы.\n",
      "\n",
      "Физическая сеть в Yandex Cloud {#underlay}\n",
      " ****************************************** \n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Посмотреть источники информации (в данном случае их 2)\n",
    "for i in range(2):\n",
    "    print(f\"{result['docs'][i].page_content}\\n ****************************************** \\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "id": "4ecb93f0-3470-4360-b2d6-1d346c1b0998",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:37:49.241410Z",
     "iopub.status.busy": "2024-04-13T17:37:49.240628Z",
     "iopub.status.idle": "2024-04-13T17:37:49.253626Z",
     "shell.execute_reply": "2024-04-13T17:37:49.252980Z",
     "shell.execute_reply.started": "2024-04-13T17:37:49.241367Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/_includes/overview/network.md\n",
      "\n",
      "/home/jupyter/datasphere/s3/dz-yc-docs-feb-2024/yc-ru-gen-md/_includes/overview/network.md\n",
      "\n"
     ]
    }
   ],
   "source": [
    "# Посмотреть метаданные по источника информации\n",
    "for i in range(2):\n",
    "    print(f\"{result['docs'][i].metadata['source']}\\n\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "id": "58ddf2b5-c798-41c9-9dfe-6f9f3bc84a92",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:37:51.768505Z",
     "iopub.status.busy": "2024-04-13T17:37:51.767718Z",
     "iopub.status.idle": "2024-04-13T17:37:51.780875Z",
     "shell.execute_reply": "2024-04-13T17:37:51.780226Z",
     "shell.execute_reply.started": "2024-04-13T17:37:51.768461Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "ConversationBufferMemory(chat_memory=ChatMessageHistory(messages=[HumanMessage(content='Как устроена сеть в Яндекс Облаке?'), AIMessage(content='Сеть в Яндекс Облаке состоит из физической и виртуальной сетей.\\n\\nОдин из основных компонентов физической сети — транспортная сеть Yandex Cloud, к которой подключаются ЦОД (зоны доступности) Yandex Cloud и точки присутствия (PoP). На отдельных точках присутствия организуются подключения к внешним сетям и интернету, а также предоставляется услуга Yandex Cloud Interconnect.\\n\\nТранспортная сеть Yandex Cloud состоит из двух уровней: трафик из внешнего мира к облачным ресурсам распределяется по всем зонам доступности Yandex Cloud, а трафик во внешний мир от облачных ресурсов распределяется по точкам присутствия. Все зоны доступности равнозначны и обеспечивают одинаковую сетевую связность.\\n\\nВиртуальная сеть в Yandex Cloud предоставляет пользователям возможность организации сетевого взаимодействия между облачными ресурсами и интернетом, а также дополнительные сетевые функции по обработке трафика.')]), output_key='answer', input_key='question', return_messages=True)"
      ]
     },
     "execution_count": 128,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "id": "694cde80-528d-4d45-99fc-80b3c0a058d4",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:25:45.362115Z",
     "iopub.status.busy": "2024-04-13T17:25:45.361478Z",
     "iopub.status.idle": "2024-04-13T17:25:45.385158Z",
     "shell.execute_reply": "2024-04-13T17:25:45.384379Z",
     "shell.execute_reply.started": "2024-04-13T17:25:45.362067Z"
    }
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "langchain.memory.buffer.ConversationBufferMemory"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(memory)\n",
    "dir(memory)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "id": "4f99045a-8a8d-4fb5-9fbc-5f9bce6ae64e",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:38:09.486055Z",
     "iopub.status.busy": "2024-04-13T17:38:09.485241Z",
     "iopub.status.idle": "2024-04-13T17:38:09.496936Z",
     "shell.execute_reply": "2024-04-13T17:38:09.496191Z",
     "shell.execute_reply.started": "2024-04-13T17:38:09.486006Z"
    },
    "tags": []
   },
   "outputs": [],
   "source": [
    "# Очистка памяти\n",
    "memory.clear()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "id": "cb90cef4-b33e-4774-82a7-98beb9e9ae40",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:38:13.400338Z",
     "iopub.status.busy": "2024-04-13T17:38:13.399639Z",
     "iopub.status.idle": "2024-04-13T17:38:13.416815Z",
     "shell.execute_reply": "2024-04-13T17:38:13.416141Z",
     "shell.execute_reply.started": "2024-04-13T17:38:13.400295Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "{'history': []}"
      ]
     },
     "execution_count": 130,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# подгружаем данные из памяти (диалог по тематическому фрагменту документации)\n",
    "memory.load_memory_variables({})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "id": "c0a83e86-9d58-431b-8425-11dc7980a211",
   "metadata": {
    "execution": {
     "iopub.execute_input": "2024-04-13T17:38:15.972815Z",
     "iopub.status.busy": "2024-04-13T17:38:15.972087Z",
     "iopub.status.idle": "2024-04-13T17:38:17.844179Z",
     "shell.execute_reply": "2024-04-13T17:38:17.843498Z",
     "shell.execute_reply.started": "2024-04-13T17:38:15.972774Z"
    },
    "tags": []
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Я не знаю.\n"
     ]
    }
   ],
   "source": [
    "inputs = {\"question\": \"Но как же устроено то, о чем только что говорили?\"}\n",
    "result = final_chain.invoke(inputs)\n",
    "print(result['answer'].content)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "DataSphere Kernel",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}