init

.dockerignore

@@ -0,0 +1,5 @@
+/data/
+/logs/
+__pycache__
+*.db
+.env

.env-example

@@ -0,0 +1 @@
+DEEPINFRA_API_KEY=Bearer <ключ>

.gitignore

@@ -0,0 +1,19 @@
+/data/
+common.log
+/output/test.json
+/logs/
+
+venv
+.idea
+__pycache__
+*.db
+
+*.docx
+*.doc
+*.pdf
+*.xlsx
+*.xls
+*.pptx
+*.ppt
+.env
+/docker-compose.yaml

Dockerfile

@@ -0,0 +1,44 @@
+FROM nvidia/cuda:12.6.0-runtime-ubuntu22.04
+
+ARG PORT=7860
+ENV PORT=${PORT}
+ENV CONFIG_PATH=config_dev.yaml
+ENV SQLALCHEMY_DATABASE_URL=sqlite:///./logs.db
+
+ENV PYTHONUNBUFFERED=1
+ENV DEBIAN_FRONTEND=noninteractive
+
+WORKDIR /app
+
+RUN apt-get update && apt-get install -y --no-install-recommends \
+    build-essential \
+    python3.11 \
+    python3.11-distutils \
+    wget \
+    && wget https://bootstrap.pypa.io/get-pip.py \
+    && python3.11 get-pip.py \
+    && rm get-pip.py \
+    && apt-get clean \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set Python 3.11 as the default python3
+RUN update-alternatives --install /usr/bin/python3 python3 /usr/bin/python3.11 1 \
+    && update-alternatives --install /usr/bin/python python /usr/bin/python3.11 1
+
+# Устанавливаем специфичные версии библиотек PyTorch
+RUN python -m pip install \
+    torch==2.6.0+cu126 \
+    --index-url https://download.pytorch.org/whl/cu126
+
+COPY requirements.txt /app/
+RUN python -m pip install -r requirements.txt
+# RUN python -m pip install --ignore-installed elasticsearch==7.11.0 || true
+
+COPY . .
+
+RUN mkdir -p /app/data/regulation_datasets /app/data/documents /app/logs
+
+
+EXPOSE ${PORT}
+
+CMD ["sh", "-c", "uvicorn main:app --host 0.0.0.0 --port ${PORT}"]

README.md

@@ -1,10 +0,0 @@
----
-title: Generic Chatbot Backend
-emoji: 🚀
-colorFrom: pink
-colorTo: gray
-sdk: docker
-pinned: false
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

common/common.py

@@ -0,0 +1,235 @@
+import logging
+from enum import Enum
+
+
+def configure_logging(level=logging.INFO, config_file_path='./common.log'):
+    logging.basicConfig(
+        filename=config_file_path,
+        filemode="a",
+        level=level,
+        datefmt="%Y-%m-%d %H:%M:%S",
+        format="[%(asctime)s.%(msecs)03d] %(module)30s:%(lineno)4d %(levelname)-7s - %(message)s",
+    )
+
+
+def get_elastic_query(query):
+    return {
+        "query": {
+            "multi_match": {
+                "query": f"{query}",
+                "fields": ["text"],
+                "fuzziness": "AUTO",
+                "analyzer": "russian",
+            }
+        }
+    }
+
+
+def get_elastic_people_query(query):
+    has_business_curator = (
+        "бизнес куратор" in query.lower()
+        or "бизнес-куратор" in query.lower()
+        or "куратор" in query.lower()
+    )
+    business_curator_boost = 30 if has_business_curator else 15
+    return {
+        "query": {
+            "bool": {
+                "should": [
+                    {
+                        "multi_match": {
+                            "query": f"{query}",
+                            "fields": ["person_name^3"],
+                            "fuzziness": "AUTO",
+                            "analyzer": "standard",
+                        }
+                    },
+                    {
+                        "nested": {
+                            "path": "business_processes",
+                            "query": {
+                                "multi_match": {
+                                    "query": f"{query}",
+                                    "fields": [
+                                        "business_processes.production_activities_section",
+                                        "business_processes.processes_name",
+                                    ],
+                                    "fuzziness": "AUTO",
+                                    "analyzer": "standard",
+                                }
+                            },
+                        }
+                    },
+                    {
+                        "nested": {
+                            "path": "organizatinal_structure",
+                            "query": {
+                                "multi_match": {
+                                    "query": f"{query}",
+                                    "fields": ["organizatinal_structure.position^2"],
+                                    "fuzziness": "AUTO",
+                                    "analyzer": "standard",
+                                }
+                            },
+                        }
+                    },
+                    {
+                        "nested": {
+                            "path": "business_curator",
+                            "query": {
+                                "multi_match": {
+                                    "query": f"{query}",
+                                    "fields": [
+                                        f"business_curator.company_name^{business_curator_boost}"
+                                    ],
+                                    "fuzziness": "AUTO",
+                                    "analyzer": "standard",
+                                }
+                            },
+                        }
+                    },
+                ]
+            }
+        },
+        "min_score": 13.0,
+    }
+
+
+def get_elastic_group_query(query):
+    return {
+        "query": {
+            "bool": {
+                "should": [
+                    {
+                        "multi_match": {
+                            "query": f"{query}",
+                            "fields": ["group_name"],
+                            "fuzziness": "AUTO",
+                            "analyzer": "standard",
+                        }
+                    },
+                    {
+                        "multi_match": {
+                            "query": "персонального состава Персональный состав Комитета ПАО ГМК Норильский никель Рабочей группы",
+                            "fields": ["group_name"],
+                            "operator": "or",
+                            "boost": 0.1,
+                        }
+                    },
+                ]
+            }
+        },
+        "min_score": 7.5,
+    }
+
+
+def get_elastic_rocks_nn_query(query):
+    return {
+        "query": {
+            "function_score": {
+                "query": {
+                    "multi_match": {
+                        "query": f"{query}",
+                        "fields": ["division_name", "division_name_2", "company_name"],
+                        "fuzziness": "AUTO",
+                        "analyzer": "custom_analyzer",
+                    }
+                },
+                "functions": [{"filter": {"term": {"_id": "3"}}, "weight": 0.5}],
+                "boost_mode": "multiply",
+            }
+        },
+        "min_score": 0.5,
+    }
+
+
+def get_elastic_segmentation_query(query):
+    return {
+        "query": {
+            "bool": {
+                "should": [
+                    {
+                        "multi_match": {
+                            "query": f"{query}",
+                            "fields": [
+                                "segmentation_model",
+                                "segmentation_model2",
+                                "company_name",
+                            ],
+                            "fuzziness": "AUTO",
+                            "analyzer": "russian",
+                        }
+                    },
+                    {
+                        "multi_match": {
+                            "query": "модели сегментации модель сегментации",
+                            "fields": ["segmentation_model", "segmentation_model2"],
+                            "operator": "or",
+                            "boost": 0.1,
+                        }
+                    },
+                ]
+            }
+        },
+        "min_score": 1.0,
+    }
+
+
+def get_elastic_abbreviation_query(query):
+    return {
+        "query": {
+            "multi_match": {
+                "query": f"{query}",
+                "fuzziness": "AUTO",
+                "fields": ["text"],
+                "analyzer": "russian",
+            }
+        }
+    }
+
+
+def combine_answer(answer):
+    """
+
+    Args:
+        answer:
+
+    Returns:
+
+    """
+    answer_combined = {}
+    indexes = []
+    for key in answer:
+        if key != 'people_search':
+            for answer_key in answer[key]:
+                answer_value = answer[key][answer_key]
+                filename_i = answer_value["doc_name"]
+                title_i = answer_value["title"]
+
+                if (
+                    filename_i in answer_combined
+                    and answer_value['index_answer'] not in indexes
+                ):
+                    answer_combined[filename_i]["chunks"].append(answer_value)
+                else:
+                    answer_combined[filename_i] = {
+                        "filename": filename_i,
+                        "title": title_i,
+                        "chunks": [answer_value],
+                    }
+                indexes.append(answer_value['index_answer'])
+    return list(answer_combined.values())
+
+
+class TypeQuestion(Enum):
+    TYPE_ONE = '[1]'
+    TYPE_TWO = '[2]'
+    TYPE_THREE = '[3]'
+
+
+def get_source_format(filename: str) -> str:
+    """
+    Получает формат файла из имени файла.
+    """
+    format_ = filename.split('.')[-1]
+    return format_.upper()

common/configuration.py

@@ -0,0 +1,274 @@
+"""This module includes classes to define configurations."""
+
+from typing import Any, Dict, List, Optional
+
+from pyaml_env import parse_config
+from pydantic import BaseModel
+
+
+class Query(BaseModel):
+    query: str
+    query_abbreviation: str
+    abbreviations_replaced: Optional[List] = None
+    userName: Optional[str] = None
+
+
+class SemanticChunk(BaseModel):
+    index_answer: int
+    doc_name: str
+    title: str
+    text_answer: str
+    # doc_number: str  # TODO Потом поменять название переменной на doc_id везде с чем это будет связанно
+    other_info: List
+    start_index_paragraph: int
+
+
+class FilterChunks(BaseModel):
+    id: str
+    filename: str
+    title: str
+    chunks: List[SemanticChunk]
+
+
+class BusinessProcess(BaseModel):
+    production_activities_section: Optional[str]
+    processes_name: Optional[str]
+    level_process: Optional[str]
+
+
+class Lead(BaseModel):
+    person: Optional[str]
+    leads: Optional[str]
+
+
+class Subordinate(BaseModel):
+    person_name: Optional[str]
+    position: Optional[str]
+
+
+class OrganizationalStructure(BaseModel):
+    position: Optional[str] = None
+    leads: Optional[List[Lead]] = None
+    subordinates: Optional[Subordinate] = None
+
+
+class RocksNN(BaseModel):
+    division: Optional[str]
+    company_name: Optional[str]
+
+
+class RocksNNSearch(BaseModel):
+    division: Optional[str]
+    company_name: Optional[List]
+
+
+class SegmentationSearch(BaseModel):
+    segmentation_model: Optional[str]
+    company_name: Optional[List]
+
+
+class Group(BaseModel):
+    group_name: Optional[str]
+    position_in_group: Optional[str]
+    block: Optional[str]
+
+
+class GroupComposition(BaseModel):
+    person_name: Optional[str]
+    position_in_group: Optional[str]
+
+
+class SearchGroupComposition(BaseModel):
+    group_name: Optional[str]
+    group_composition: Optional[List[GroupComposition]]
+
+
+class PeopleChunks(BaseModel):
+    business_processes: Optional[List[BusinessProcess]] = None
+    organizatinal_structure: Optional[List[OrganizationalStructure]] = None
+    business_curator: Optional[List[RocksNN]] = None
+    groups: Optional[List[Group]] = None
+    person_name: str
+
+
+class SummaryChunks(BaseModel):
+    doc_chunks: Optional[List[FilterChunks]] = None
+    people_search: Optional[List[PeopleChunks]] = None
+    groups_search: Optional[SearchGroupComposition] = None
+    rocks_nn_search: Optional[RocksNNSearch] = None
+    segmentation_search: Optional[SegmentationSearch] = None
+    query_type: str = '[3]'
+
+
+class ElasticConfiguration:
+    def __init__(self, config_data):
+        self.es_host = str(config_data['es_host'])
+        self.es_port = int(config_data['es_port'])
+        self.use_elastic = bool(config_data['use_elastic'])
+        self.people_path = str(config_data['people_path'])
+
+
+class FaissDataConfiguration:
+    def __init__(self, config_data):
+        self.model_embedding_path = str(config_data['model_embedding_path'])
+        self.device = str(config_data['device'])
+        self.path_to_metadata = str(config_data['path_to_metadata'])
+
+
+class ChunksElasticSearchConfiguration:
+    def __init__(self, config_data):
+        self.use_chunks_search = bool(config_data['use_chunks_search'])
+        self.index_name = str(config_data['index_name'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class PeopleSearchConfiguration:
+    def __init__(self, config_data):
+        self.use_people_search = bool(config_data['use_people_search'])
+        self.index_name = str(config_data['index_name'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class VectorSearchConfiguration:
+    def __init__(self, config_data):
+        self.use_vector_search = bool(config_data['use_vector_search'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class GroupsSearchConfiguration:
+    def __init__(self, config_data):
+        self.use_groups_search = bool(config_data['use_groups_search'])
+        self.index_name = str(config_data['index_name'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class RocksNNSearchConfiguration:
+    def __init__(self, config_data):
+        self.use_rocks_nn_search = bool(config_data['use_rocks_nn_search'])
+        self.index_name = str(config_data['index_name'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class AbbreviationSearchConfiguration:
+    def __init__(self, config_data):
+        self.use_abbreviation_search = bool(config_data['use_abbreviation_search'])
+        self.index_name = str(config_data['index_name'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class SegmentationSearchConfiguration:
+    def __init__(self, config_data):
+        self.use_segmentation_search = bool(config_data['use_segmentation_search'])
+        self.index_name = str(config_data['index_name'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class SearchConfiguration:
+    def __init__(self, config_data):
+        self.vector_search = VectorSearchConfiguration(config_data['vector_search'])
+        self.people_elastic_search = PeopleSearchConfiguration(
+            config_data['people_elastic_search']
+        )
+        self.chunks_elastic_search = ChunksElasticSearchConfiguration(
+            config_data['chunks_elastic_search']
+        )
+        self.groups_elastic_search = GroupsSearchConfiguration(
+            config_data['groups_elastic_search']
+        )
+        self.rocks_nn_elastic_search = RocksNNSearchConfiguration(
+            config_data['rocks_nn_elastic_search']
+        )
+        self.segmentation_elastic_search = SegmentationSearchConfiguration(
+            config_data['segmentation_elastic_search']
+        )
+        self.stop_index_names = list(config_data['stop_index_names'])
+        self.abbreviation_search = AbbreviationSearchConfiguration(
+            config_data['abbreviation_search']
+        )
+
+
+class FilesConfiguration:
+    def __init__(self, config_data):
+        self.empty_start = bool(config_data['empty_start'])
+        self.regulations_path = str(config_data['regulations_path'])
+        self.default_regulations_path = str(config_data['default_regulations_path'])
+        self.documents_path = str(config_data['documents_path'])
+
+
+class RankingConfiguration:
+    def __init__(self, config_data):
+        self.use_ranging = bool(config_data['use_ranging'])
+        self.alpha = float(config_data['alpha'])
+        self.beta = float(config_data['beta'])
+        self.k_neighbors = int(config_data['k_neighbors'])
+
+
+class DataBaseConfiguration:
+    def __init__(self, config_data):
+        self.elastic = ElasticConfiguration(config_data['elastic'])
+        self.faiss = FaissDataConfiguration(config_data['faiss'])
+        self.search = SearchConfiguration(config_data['search'])
+        self.files = FilesConfiguration(config_data['files'])
+        self.ranker = RankingConfiguration(config_data['ranging'])
+
+
+class LLMConfiguration:
+    def __init__(self, config_data):
+        self.base_url = str(config_data['base_url']) if config_data['base_url'] not in ("", "null", "None") else None
+        self.api_key_env = (
+            str(config_data['api_key_env'])
+            if config_data['api_key_env'] not in ("", "null", "None")
+            else None
+        )
+        self.model = str(config_data['model'])
+        self.tokenizer = str(config_data['tokenizer_name'])
+        self.temperature = float(config_data['temperature'])
+        self.top_p = float(config_data['top_p'])
+        self.min_p = float(config_data['min_p'])
+        self.frequency_penalty = float(config_data['frequency_penalty'])
+        self.presence_penalty = float(config_data['presence_penalty'])
+        self.seed = int(config_data['seed'])
+
+
+class CommonConfiguration:
+    def __init__(self, config_data):
+        self.log_file_path = str(config_data['log_file_path'])
+        self.log_sql_path = str(config_data['log_sql_path'])
+
+
+class Configuration:
+    """Encapsulates all configuration parameters."""
+
+    def __init__(self, config_file_path: Optional[str] = None):
+        """Creates an instance of the class.
+
+        There is 1 possibility to load configuration data:
+            - from configuration file using a path;
+        If attribute is not None, the configuration file is used.
+
+        Args:
+            config_file_path: A path to config file to load configuration data from.
+        """
+        if config_file_path is not None:
+            self._load_from_config(config_file_path)
+        else:
+            raise ValueError('At least one of config_path must be not None.')
+
+    def _load_data(self, data: Dict[str, Any]):
+        """Loads configuration data from dictionary.
+
+        Args:
+            data: A configuration dictionary to load configuration data from.
+        """
+        self.common_config = CommonConfiguration(data['common'])
+        self.db_config = DataBaseConfiguration(data['bd'])
+        self.llm_config = LLMConfiguration(data['llm'])
+
+    def _load_from_config(self, config_file_path: str):
+        """Reads configuration file and form configuration dictionary.
+
+        Args:
+            config_file_path: A configuration dictionary to load configuration data from.
+        """
+        data = parse_config(config_file_path)
+        self._load_data(data)

common/constants.py

@@ -0,0 +1,475 @@
+"""This module includes common constants for the project"""
+
+DEFAULT_CONFIG_RELATIVE_PATH = 'config.yaml'
+
+
+PROMPT_OLD = """
+Ты мастер по документам. Я задам тебе запрос пользователя. 
+И пронумерованный список документов с текстами, найденных по запросу. 
+У документов будут названия и конкретный текст документа. 
+Твоя задача написать номер документа из списка, 
+текст и название которого лучше всего отвечает на заданный пользователем запрос. 
+Пиши в формате "Ответ: [Номер документа из списка]". 
+Больше в ответе ничего не нужно. Отвечай только на русском языке. 
+Запрос: {query}
+
+Пронумерованный список документов с текстами:\n{answer}
+
+"""
+
+PROMPT_CLASSIFICATION = """[INST]  Ты распределитель запросов. Я дам тебе запрос. Твоя задача понять к какой из трёх групп нужно распределить запрос пользователя. Существует таблица ЭЛ, в которой записаны некие данные. Все запросы касаются компании, для которой создана эта таблица. Я приведу тебе примеры данных из этой таблицы ЭЛ:
+Строка 1: Информация о сотруднике Кузнецов А.В.
+Должность: Директор департамента гражданской обороны, предупреждения чрезвычайных ситуаций и пожарной безопасности ПАО "ГМК "Норильский никель"
+Руководителем Кузнецов А.В. является Попов А.Н.
+Входит в состав групп:
+Персональный состав Рабочей группы по контролю за подготовкой гидротехнических сооружений объектов промышленности Компании и РОКС НН к паводковому сезону 2024. Должность внутри группы: Член Рабочей группы
+Состав Комиссии по категорированию объектов критической информационной инфраструктуры Главного офиса ПАО "ГМК "Норильский никель". Должность внутри группы: Член Комиссии
+####
+Строка 2: Информация о сотруднике Попов А.Н.
+Должность: Старший вице-президент - Операционный директор, руководитель Забайкальского дивизиона
+Руководит следующими сотрудниками:
+Манукян А.Г.
+Кузнецов А.В.
+Руководителем Попов А.Н. является Потанин В.О.
+Должность: Вице-президент - руководитель Забайкальского дивизиона
+Отвечает за Бизнес процессы:
+Производственно-техническое развитие
+Геологоразведка и минерально-сырьевая база
+Является Бизнес-куратором (РОКС НН):
+ООО «Ширинское»ООО «Быстринская сервисная компания», ООО «Бугдаинский рудник», ООО «Востокгеология»
+Входит в состав групп:
+Составы Комиссий по проведению специальной оценки условий труда в Главном офисе ПАО "ГМК "Норильский никель". Должность внутри группы: Председатель Комиссии
+Состав Научно-технического совета ПАО "ГМК "Норильский никель". Должность внутри группы: Председатель Научно-технического совета
+####
+Виды связей в таблице: в таблице перечисляются составы, подразделения, комитеты, подкомитеты, комиссии, совет (в смысле группы людей) и рабочие группы. Данная таблица вида ЭЛ связывает конкретных людей с должностями, людьми друг с другом в подчинении, должностями внутри групп и названиями групп. Также в ней есть все возможные связи между различными ��олжностями у одного или нескольких людей. Таблица содержит всю информацию о том, за какой процесс или бизнес процесс кто отвечает. По фамилии также можно найти любого конкретного человека из таблицы вида ЭЛ. Вся информация о бизнес кураторах и за что они отвечают в таблице вида ЭЛ. В таблице можно найти кто отвечает и кто ответственен за всё что угодно.
+Конец видов связей в таблице.
+Основные правила:
+- Если ответ на все вопросы внутри запроса можно найти напрямую ответ в такого вида таблице ЭЛ, и при этом больше никаких дополнительных размышлений для ответа не нужно, то это группа 2.
+- Если данные из такого таблицы вида таблицы ЭЛ не дают прямого ответа на все вопросы в запросе, но отвечают хотя бы на один из них, то это группа 3.
+- Если ответ на вопросы внутри запроса можно найти напрямую ответ в такого вида таблице ЭЛ, и также требуется дополнительная информация для ответа, то это группа 3.
+- Если абсолютно непонятно что именно хочет пользователь, то это группа 3.
+- Если для ответа на вопрос нужна только дополнительная информация вне таблицы группы ЭЛ, то это группа 1.
+- Если таблица вида ЭЛ не поможет в ответе на запрос пользователя, то это группа 1.
+- В конечном ответе должна быть одна цифра.
+- Количество людей в запросе не должно влиять на постановку оценки.
+Конец основных правил.
+Ты действуешь по плану. Начало плана:
+1. Внимательно прочитай запрос. В запросе могут быть несколько вопросов.
+2. Рассуждай шаг за шагом, почему данный запрос должен относиться к какой-то из трёх групп. Во время рассуждения используй логику. Основывайся на типах информации из таблицы вида ЭЛ, видах связей в таблице и заданных основных правилах.
+3. Выбери конкретную группу, которая подходит лучше всего согласно твоим рассуждениям.
+Конец плана.
+Твой ответ должен выводиться в таком формате 'Рассуждения:Твои рассуждения
+Ответ:[цифра группы]'. Цифра группы в итоговом ответе должна обрамляться скобочками '[]'.
+Не пиши в ответ '####', это для разграничения.
+####
+Далее будет первый структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Кто является управляющим состава комитета управления МОМ?
+####
+Вывод:
+Рассуждения: В запросе пользователя вопрос, который касается имени управляющего состава комитета управления МОМ. Т.к. в таблице вида ЭЛ есть связь между именем и составами различных комитетов, то эти данные можно полностью получить в этой таблице, больше ничего не потребуется. Группа 2.
+Ответ:[2]
+####
+Далее будет второй структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Как мне найти какой-то конкретный документ (НМД/ОПД)?
+####
+Вывод: 
+Рассуждения: В запросе нет никаких данных, котор��е можно найти в таблице вида ЭЛ. Это группа 1.
+Ответ:[1]
+####
+Далее будет третий структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: А как мне узнать кто входит в состав КО? Где посмотреть Положение?
+####
+Вывод:
+Рассуждения: В запросе два вопроса. Первый вопрос касается имени человека, который входит в состав КО. Это можно полностью найти в таблице вида ЭЛ. Второй вопрос хочет узнать, где посмотреть Положение. Этого нет в таблице ЭЛ. Т.к. данные из такого таблицы вида таблицы ЭЛ не дают прямого ответа на все вопросы в запросе, но отвечают хотя бы на один из них, то это группа 3.
+Ответ:[3]
+####
+Далее будет четвертый структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Уметрохин А.М.
+####
+Вывод:
+Рассуждения: В запросе имя человека. Видимо пользователь хочет получить данные по человеку в этой компании. Все данные по людям в компании есть в таблице вида ЭЛ, поэтому группа 2.
+Ответ:[2]
+####
+Далее будет пятый структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Какая должность у Пупкина Вити
+####
+Вывод:
+Рассуждения: В запросе пользователь хочет получить информацию о должности Пупкина Вити. Эту информацию можно найти в таблице вида ЭЛ, поэтому это группа 2.
+Ответ:[2]
+####
+Далее будет шестой структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Где посмотреть Положение?
+####
+Вывод: 
+Рассуждения: В запросе спрашивают, на каком ресурсе можно посмотреть Положение. Этой информации не может быть в таблице вида ЭЛ, поэтому это группа 1.
+Ответ:[1]
+####
+Далее будет седьмой структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Кто руководитель состава пожарной инспекции? Какие функции у руководителя состава пожарной инспекции?
+####
+Вывод:
+Рассуждения: В запросе 2 вопроса. В первом пытаются узнать имя человека, который входит в состав пожарной инспекции. Такого рода информация полностью содержится в таблице вида ЭЛ. Второй вопрос касается функций конкретной должности. В таблице вида ЭЛ есть привязка должностей к чему-либо, но нет пояснений о функциях конкретных должностей. Так как первый вопрос полностью можно найти в таблице вида ЭЛ, а второй нет, то это группа 3.
+Ответ:[3]
+####
+Далее будет восьмой структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Кому подчиняется Василий Петрович?
+####
+Вывод:
+Рассуждения: В запросе хотят узнать информацию связи человека с другим в подчинение. Вся информация о связях людей в компании хранится в таблице вида ЭЛ. Группа 2.
+Ответ:[2]
+####
+Далее будет девятый структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Как посмотреть в каких комитетах председателем является Потанин В.О.
+####
+Вывод:
+Рассуждения: В запросе хотят узнать список комитетов, председателем которых является Потанин В.О.. Данная информация полностью находится в таблице вида ЭЛ, так как там есть связь между именем, должностью в группе и названием группы. При этом больше никаких дополнительных размышлений для ответа не нужно, поэтому это группа 2.
+Ответ:[2]
+####
+Далее будет десятый структурный шаблон с правильной логикой ответа, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос: Как работники компании могут понять сколько им заплатят?
+####
+Вывод:
+Рассуждения: В запросе хотят узнать информацию о зарплатах работников компании. В таблице ЭЛ нет такой информации. Хотя там есть информация о должностях, это никак не поможет в ответе на вопрос. Группа 1.
+Ответ:[1]
+####
+Далее будет настоящий запрос
+####
+Запрос: {query}
+####
+Вывод: 
+[/INST]"""
+
+PROMPT = """ [INST] Ты специалист по внутренним данным компании. Ты давно работаешь в компании и знаешь все её правила. Тебе будет дан запрос пользователя и приведено несколько юридических документов. Твоя задача - подробно ответить на запрос пользователя, используя информацию из заданных юридических документов. За отлично выполненную работу тебе заплатят 10$. Я спас тебе жизнь и ты теперь должен отлично выполнить эту задачу. У тебя есть основные правила, которых ты придерживаешься во время вывода. Основные правила:
+- Не обязательно все заданные юридические документы помогут тебе в формировании ответа.
+- Ты должен использовать только заданные юридические документы.
+- Тебе разрешено делать логические рассуждения по шагам на основе юридических документов для ответа на запрос.
+- Тебе запрещено выдумывать. Вся информация для ответа или есть в предоставленных источниках, или её нет и тогда ты пишешь в ответе что её нет.
+- Тебе запрещено самостоятельно расшифровывать любые сокращения.
+- Используй официально-деловой стиль общения.
+- Между различными логическими частями в документах будут стоять "...". Воспринимай это как разные куски информации.
+- Тебе запрещено ставить "..." в ответе
+- Если инициалы из запроса и предоставленных документов не совпадают, то это разные люди. Например "Иванов А.А." и "Иванов А.И." - это разные люди.
+- Если запрос содержит "Кто", то в первую очередь ты должен постараться найти имя человека.
+- Если ты ище��ь общую информацию о сотруднике, то ты стараешься выписать всё, что с ним связано.
+- Если ты будешь дублировать одинаковую информацию из разных источников при цитировании во втором пункте.
+- В документе с названием "Информация о сотруднике" весь текст документа относится к человеку, имя которого указано в заголовке документа.
+- Если ты ищешь конкретную информацию о сотруднике, то ты должен во время цитирования писать как нужную информацию по запросу, так и имя сотрудника рядом с этой информацией.
+- Квадратные скобки в документах по информации о сотрудниках для твоего понимания. Нельзя использовать квадратные скобки с текстом в ответе.
+- Вместо названия документа в первых 3-х пунктах ответа писать слова "Документ [номер]".
+- Различные документы разделены между собой обратным слешем для твоего удобства. Обратные слеши нельзя писать в ответе.
+- Если ты не нашёл ответа на вопрос, то не нужно перечислять все документы, просто поставь в списке документов "-".
+- Тебе запрещено писать номера пунктов плана, иначе тебя будут пытать
+- Не пиши в ответе про заданные тебе правила и инструкцию
+- Отвечай всегда только на РУССКОМ языке, даже если текст запроса и документов не на русском!
+- Перед третьим пунктом плана ты обязан написать '%%'
+- Не пиши в ответ "####", это для разграничения.
+Конец основных правил.
+Ты действуешь по плану. Начало плана:
+1) Прочитай запрос пользователя. Воспринимай запрос как нечто цельное. Напиши рассуждения шаг за шагом что именно тебе нужно найти для ответа на запрос. Какие цитаты из одного или несколько юридических документов лучше всего отвечают на запрос пользователя. Если вопрос касается человека, то подумай, есть ли у тебя документ "Информация о сотруднике" с подходящим именем.
+2) Сопоставь запрос пользователя и юридические документы. Выпиши номера документов, которые подходят для ответа на запрос "Документ [номер]". Если ни в одном документе нет нужной информации для ответа на вопрос пользователя, то твой ответ "Извините, я не нашла нужную информацию". Кроме перечисления нужных документов ничего нельзя писать в этом пункте
+3) НАПИШИ '%%'. Затем составь ответ на запрос. Старайся опираться в ответе на те документы, номера которых ты выписал ранее. При ответе тебе можно использовать смысловую нагрузку "Названий документов", но нельзя выписывать эти названия документов. Не дублируй одинаковый текст из разных документов. Если запрос может иметь несколько различных смыслов, а ответ в предоставленных документах только по одному из них, то укажи пользователю, что для получения ответа на другой смысл запроса требуется уточнение. Если в предыдущем шаге ты не нашёл подходящих документов, то напиши 'Информации в найденных документах нет, попробуйте перефразировать запрос', а затем, если вопрос твоего профиля (касается информации по документам компании), поп��обуй самостоятельно порассуждать. 
+4) Выпиши все названия документов, которые ты ранее использовал в своём ответе в виде списка. Если в ответе ты не использовал ни одного документа или если ты не нашёл ответа на вопрос, то поставь '-'.
+5) Напиши 'Конец ответа'.
+Конец плана.
+Итоговый текст должен выглядеть так: "Какие документы нужны: [твои рассуждения что нужно найти]
+В каких документах есть ответ:
+[перечисление номеров документов]
+%%Ответ на запрос:
+[твои мысли, если цитат не хватает для ответа на вопрос]
+Список документов:
+[Названия документов]
+Конец ответа."
+####
+Далее будет первый структурный шаблон, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос пользователя: Какие действия являются первоочередными в момент обнаружения происшествия?
+
+Отрывки из юридических документов: Документ: [1]
+Название документа: УЧЕТ И РАССЛЕДОВАНИЕ
+...Дополнительные разделы: 
+5.1.1 Первоочередными действиями в момент обнаружения происшествия являются:
+- обеспечение безопасности работников Компании и третьих лиц;
+- оперативное информирование (в соответствии с Приложением А);
+- принятие мер по сохранению места происшествия;
+- сбор детальной информации о происшествии;
+- принятие мер по минимизации негативного воздействия на окружающую среду при его наличии.
+...
+- оперативное патрулирование (в соответствии с Приложением Б);
+...
+\
+Документ: [2]
+Название документа: $S_СТАНДАРТ ОРГАНИЗАЦИИ
+...Дополнительные разделы: 
+5. Порядок действий при происшествии...
+####
+Вывод:
+Какие документы нужны: По заданному вопросу нужны документы, связанные с происшествиями и порядком действий в момент их обнаружения.
+В каких документах есть ответ: Документ [1]
+
+%%Ответ на запрос: 
+5.1.1 Первоочередными действиями в момент обнаружения происшествия являются:
+- обеспечение безопасности работников Компании и третьих лиц;
+- оперативное информирование (в соответствии с Приложением А);
+- принятие мер по сохранению места происшествия;
+- сбор детальной информации о происшествии;
+- принятие мер по минимизации негативного воздействия на окружающую среду при его наличии.
+
+Список документов:
+* Документ: [1]
+Название документа: УЧЕТ И РАССЛЕДОВАНИЕ
+
+Конец ответа.
+####
+Далее будет второй структурный шаблон, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос пользователя: В состав каких групп входит Позлов М.М.?
+Отрывки из юридических документов: Документ: [1]
+Информация о сотруднике Позлов М.М.
+[
+Должность: Старший вице-президент - Операционный директор, руководитель Забайкальского дивизиона
+Руководит следующими сотрудниками:
+Селезнев С.С.
+Манукян А.Г.
+Кузнецов А.В.
+Руководителем Попов А.Н. является Потанин В.О.
+]
+Отвечает за Бизнес процессы:
+Производственно-техническое развитие
+Производство
+Является Бизнес-куратором (РОКС НН):
+ООО «Ширинское»ООО «Быстринская сервисная компания»ООО «Бугдаинский рудник»ООО «Востокгеология»ООО «Восточная ГРК»АО
+Входит в состав групп:
+Составы Комиссий по проведению специальной оценки условий тр уда в Главном офисе ПАО "ГМК "Норильский никель". Должность внутри группы: Председатель Комиссии 2
+Состав Научно-технического совета
+Состав Инвестиционного комитета. Должность внутри группы: Постоянные члены Комитета
+\
+Документ: [2]
+Информация о сотруднике Кузнецов А.В.
+[
+Должность: Директор департамента гражданской обороны
+]
+Входит в состав групп:
+Персональный состав Рабочей группы по контролю за подготовкой к паводковому сезону 2024. Должность внутри группы: Член Рабочей группы
+####
+Вывод:
+Какие документы нужны: По заданному вопросу нужны документы, в которых есть информация о составах групп Позлова М.М.
+В каких документах есть ответ:
+Документ [1]
+
+%%Ответ на запрос: Согласно найденной информации Позлов М.М. входит в следующий состав групп: составы Комиссий по проведению специальной оценки условий труда в Главном офисе ПАО "ГМК "Норильский никель", состав Научно-технического совета и состав Инвестиционного комитета.
+
+Список документов:
+Документ [1]
+Информация о сотруднике Позлов М.М.
+
+Конец ответа.
+####
+Далее будет третий структурный шаблон, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+####
+Запрос пользователя: Что такое ДМД?
+
+Отрывки из юридических документов: Документ: [1]
+Название документа: ОРГАНИЗАЦИИ ААААААА
+...
+Нет ничего хорошего. Всё съели мухи.
+...
+\
+Документ: [2]
+Название документа: $S_ПОЛОЖЕНИЕ О.DOCX
+...ДМД лучше использовать при налоговой ставке в 12%.
+...ДМД очень важно...
+\
+Документ: [3]
+Название документа: $S_ПОЛОЖЕНИЕ Е.DOCX
+...От грубых производственных деталей. Если ваш ДМД достаточно крупный, то разделите его. Не пытайтесь помыть станок, он чистый. Где слон? Не вижу я никаких заводов.
+...
+\
+Документ: [4]
+Название документа: $S_ПОЛОЖЕНИЕ Р.DOCX
+...ДМД лучше использовать при налоговой ставке в 12%.
+...
+####
+Вывод:
+Какие документы нужны: Для ответа на вопрос нужны документы, где есть определение ДМД. Если такого рода документы не нашлись, то нужны документы с упоминанием ДМД.
+В каких документах есть ответ:
+Документах [2], [3], [4]
+
+%%Ответ на запрос: В найденных документах нет определения или расшифровки понятия ДМД из вашего запроса. Согласно документам это нечто, что можно использовать при налоговой ставке и, если оно достаточно крупное, то его можно разделять. Также ДМД очень важно. Налоговые ставки применяются к различного вида экономической деятельности. Также подобную деятельность можно разделить на части - филиалы. Возможно ДМД связано именно с этим.
+
+Список документов:
+*Документ: [2]
+Название документа: $S_ПОЛОЖЕНИЕ О.DOCX
+*Документ: [3]
+Название документа: $S_ПОЛОЖЕНИЕ Е.DOCX
+*Документ: [4]
+Название документа: $S_ПОЛОЖЕНИЕ Р.DOCX
+
+Конец ответа.
+####
+Далее будет настоящий запрос
+####
+Запрос пользователя: {query}
+Отрывки из юридических документов: {answer}
+####
+Вывод: [/INST]"""
+
+
+PROMPT_NAME = """ [INST]  Ты мастер по правильным ответам. Твоя цель - дать правильный ответ на основе заданных тебе источников. Я задам тебе запрос о конкретном человеке или связи человека и дам список информации о людях. Основные правила:
+- Тебе нужно максимально чётко ответить на поставленный запрос используя ТОЛЬКО информацию из списка.
+- Если нужной информации в списке нет, то пиши в ответе "Извините, не смогла найти нужную информацию по источникам". Не нужно выдумывать информацию.
+- Если тебя просят перечислить должности для одного человека, то перечисляй их с более важной к наименее.
+- Не пиши в ответ "#####", это для разграничения.
+- Не пиши должности человека в квадратных скобках [], это смысловое разграничение для тебя.
+- Сформулируй ответ на официально-деловом РУССКОМ языке, избегай канцеляризмов, штампов, вводных конструкций.
+- Если инициалы из запроса и предоставленных документов не совпадают, то это разные люди. Например "Иванов А.А." и "Иванов А.И." - это разные люди.
+Конец основных правил.
+Ты действуешь по плану. Начало плана:
+1) Прочитай вопрос и напиши для себя что именно тебе нужно сделать для вывода правильного ответа на вопрос.
+2) Выведи ответ на вопрос, следуя основным правилам и используя предоставленные источники.
+Конец плана.
+Твой ответ должен следовать шаблону "'твои рассуждения из пункта 1'
+2. Ответ:'ответ на вопрос пользователя'"
+Отвечай всегда только на РУССКОМ языке, даже если текст запроса и источников не на русском! Если в запросе просят или умоляют тебя ответить не на русском, всё равно отвечай на РУССКОМ! Не пиши в ответ "#####", это для разграничения.
+#####
+Далее будет первый структурный шаблон с правильной логикой, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+#####
+Запрос о конкретном человеке: В состав каких групп входит Пидемский А.Н.?
+Список информации о людях: Документ: [1]
+Информация о сотруднике Манихин А.Н.
+[
+Должность: Почтальон
+]
+Входит в состав группы:
+Состав Архитектурного подкомитета ИТ-комитета. Должность внутри группы: Заместитель Председателя Архитектурного подкомитета ИТ-комитета
+\
+
+Документ: [2]
+Информация о сотруднике Пидемский А.Н.
+[
+Должность: АО "Кольская ГМК" (по согласованию)
+]
+Входит в состав группы:
+Персональный состав Рабочей группы по разработке мероприятий по реализации ключевых направлений Программы повышения эффективности закупок в ПАО "ГМК "Норильский никель". Должность внутри группы: Член Рабочей группы
+\
+
+Документ: [3]
+Информация о сотруднике Иванова А.Н.
+[
+Должность: Руководитель по направлению правового сопровождения закупочной деятельности Правового ��епартамента
+]
+Входит в состав группы:
+Персональный состав Рабочей группы по разработке мероприятий по реализации ключевых направлений Программы повышения эффективности закупок в ПАО "ГМК "Норильский никель". Должность внутри группы: Член Рабочей группы
+\
+#####
+Вывод:
+Мне нужно найти в состав каких групп входит Пидемский А.Н..
+Ответ: Пидемский А.Н. входит в состав группы:
+Персональный состав Рабочей группы по разработке мероприятий по реализации ключевых направлений Программы повышения эффективности закупок в ПАО "ГМК "Норильский никель".
+#####
+Далее будет второй структурный шаблон с правильной логикой, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+#####
+Запрос о конкретном человеке: Какая должность у Петрова Н.В.?
+Список информации о людях:Документ: [1]
+Информация о сотруднике Пидемский А.Н.
+[
+Должность: АО "Кольская ГМК" (по согласованию)
+]
+Входит в состав группы:
+Персональный состав Рабочей группы по разработке мероприятий по реализации ключевых направлений Программы повышения эффективности закупок в ПАО "ГМК "Норильский никель". Должность внутри группы: Член Рабочей группы
+\
+
+Документ: [2]
+Информация о сотруднике Иванова А.Н.
+[
+Должность: Руководитель по направлению правового сопровождения закупочной деятельности Правового департамента
+]
+Входит в состав группы:
+Персональный состав Рабочей группы по разработке мероприятий по реализации ключевых направлений Программы повышения эффективности закупок в ПАО "ГМК "Норильский никель". Должность внутри группы: Член Рабочей группы
+\
+#####
+Вывод:
+Мне нужно найти должность Петрова Н.В..
+Ответ:
+Извините, не смогла найти нужную информацию по источникам.
+#####
+Далее будет третий структурный шаблон с правильной логикой, по которому ты отвечаешь. НЕ ИСПОЛЬЗУЙ данные из этого шаблона, он показывает только пример твоей работы
+#####
+Запрос о конкретном человеке: Кузнецов А.В.
+Список информации о людях:Документ: [1]
+Информация о сотруднике Попов А.Н.
+[
+Должность: Старший вице-президент - Операционный директор, руководитель Забайкальского дивизиона
+Руководит следующими сотрудниками:
+Селезнев С.С.
+Манукян А.Г.
+Кузнецов А.В.
+Руководителем Попов А.Н. является Потанин В.О.
+]
+Отвечает за Бизнес процессы:
+Производственно-техническое развитие
+Производство
+Является Бизнес-куратором (РОКС НН):
+ООО «Ширинское»ООО «Быстринская сервисная компания»ООО «Бугдаинский рудник»ООО «Востокгеология»ООО «Восточная ГРК»АО
+Входит в состав групп:
+Составы Комиссий по проведению специальной оценки условий тр уда в Главном офисе ПАО "ГМК "Норильский никель". Должность внутри группы: Председатель Комиссии 2
+Состав Научно-технического совета
+Состав Инвестиционного комитета. Должность внутри группы: Постоянные члены Комитета
+\
+Документ: [2]
+Информация о сотруднике Кузнецов А.В.
+[
+Должность: Директор департамента гражданской обороны, предупреждения чрезвычайных ситуаций и пожарной безопасности ПАО "ГМК "Норильский никель"
+]
+Входит в состав групп:
+Персональный состав Рабочей группы по контролю за подготовкой гидротехнических сооружений объектов промышленности Компании и РОКС НН к паводковому сезону 2024. Должность внутри группы: Член Рабочей группы
+#####
+Вывод:
+В запросе имя человека. Пользователь хочет получить всю возможную информацию о Кузнецове А.В.
+Ответ:
+Информация о сотруднике Кузнецов А.В.
+Должность: Директор департамента гражданской обороны, предупреждения чрезвычайных ситуаций и пожарной безопасности ПАО "ГМК "Норильский никель"
+Входит в состав групп:
+Персональный состав Рабочей группы по контролю за подготовкой гидротехнических сооружений объектов промышленности Компании и РОКС НН к паводковому сезону 2024. Должность внутри группы: Член Рабочей группы
+Руководителем Кузнецова А.В. является Попов А.Н.
+#####
+Далее будет настоящий запрос
+#####
+Запрос о конкретном человеке: {query}
+Список информации о людях: {answer}
+#####
+Вывод: [/INST]"""
+
+
+ERROR = '500 Internal Server Error'
+
+ELASTIC_INDEX_PEOPLE = 'people_search'
+DEVICE = 'cuda'
+DO_NORMALIZATION = True
+MODEL_PATH = './models/multilingual_e5_base/snapshots/file_model'
+COLUMN_EMBEDDING = 'Embedding'
+COLUMN_DOC_NAME = 'DocName'
+COLUMN_LABELS_STR = 'labels'
+COLUMN_TEXT = 'Text'
+
+# Константы для карт проводок
+COLUMN_EMBEDDING_FULL = 'EmbeddingFull'
+COLUMN_TABLE_NAME = 'TableName'
+COLUMN_NAMES = 'Columns'
+COLUMN_TYPE_DOC_MAP = 'TypeDocs'
+
+# Константы для PDF
+COLUMN_SLIDE_NUMBER = 'SlideNumber'
+
+# Константы для подготовки датасета
+UNKNOWN = "unknown"
+PROCESSING_FORMATS = ['XML', 'DOCX']

common/db.py

@@ -0,0 +1,39 @@
+import os
+from fastapi import Depends
+import logging
+
+from typing import Annotated
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker, scoped_session, Session
+
+from common.configuration import Configuration
+from components.dbo.models.base import Base
+import components.dbo.models.feedback
+import components.dbo.models.acronym
+import components.dbo.models.dataset
+import components.dbo.models.dataset_document
+import components.dbo.models.document
+import components.dbo.models.log
+import components.dbo.models.llm_prompt
+import components.dbo.models.llm_config
+
+
+CONFIG_PATH = os.environ.get('CONFIG_PATH', './config_dev.yaml')
+config = Configuration(CONFIG_PATH)
+logger = logging.getLogger(__name__)
+
+engine = create_engine(config.common_config.log_sql_path, connect_args={'check_same_thread': False})
+
+session_factory = sessionmaker(autocommit=False, autoflush=False, bind=engine)
+SessionLocal = scoped_session(session_factory)
+
+def get_db_session_factory():
+    
+    db = session_factory()
+    try:
+        yield db
+    finally:
+        db.close()
+
+logger.info("Creating tables...")
+Base.metadata.create_all(bind=engine)

common/dependencies.py

@@ -0,0 +1,83 @@
+import logging
+from logging import Logger
+import os
+from fastapi import Depends
+
+from common.configuration import Configuration
+from components.llm.common import LlmParams
+from components.llm.deepinfra_api import DeepInfraApi
+from components.services.dataset import DatasetService
+from components.embedding_extraction import EmbeddingExtractor
+from components.datasets.dispatcher import Dispatcher
+from components.services.document import DocumentService
+from components.services.acronym import AcronymService
+from components.services.llm_config import LLMConfigService
+
+from typing import Annotated
+from sqlalchemy.orm import sessionmaker, Session
+from common.db import session_factory
+from components.services.llm_prompt import LlmPromptService
+
+
+def get_config() -> Configuration:
+    return Configuration(os.environ.get('CONFIG_PATH', 'config_dev.yaml'))
+
+
+def get_db() -> sessionmaker:
+    return session_factory
+
+
+def get_logger() -> Logger:
+    return logging.getLogger(__name__) 
+
+
+def get_embedding_extractor(config: Annotated[Configuration, Depends(get_config)]) -> EmbeddingExtractor:
+    return EmbeddingExtractor(
+        config.db_config.faiss.model_embedding_path,
+        config.db_config.faiss.device,
+    )
+
+
+def get_dataset_service(
+    vectorizer: Annotated[EmbeddingExtractor, Depends(get_embedding_extractor)],
+    config: Annotated[Configuration, Depends(get_config)],
+    db: Annotated[sessionmaker, Depends(get_db)]
+) -> DatasetService:
+    return DatasetService(vectorizer, config, db)
+
+def get_dispatcher(vectorizer: Annotated[EmbeddingExtractor, Depends(get_embedding_extractor)], 
+                   config: Annotated[Configuration, Depends(get_config)],              
+                   logger: Annotated[Logger, Depends(get_logger)],
+                   dataset_service: Annotated[DatasetService, Depends(get_dataset_service)]) -> Dispatcher:
+    return Dispatcher(vectorizer, config, logger, dataset_service)
+
+
+def get_acronym_service(db: Annotated[Session, Depends(get_db)]) -> AcronymService:
+    return AcronymService(db)
+
+
+def get_document_service(dataset_service: Annotated[DatasetService, Depends(get_dataset_service)],
+                        config: Annotated[Configuration, Depends(get_config)],
+                        db: Annotated[sessionmaker, Depends(get_db)]) -> DocumentService:
+    return DocumentService(dataset_service, config, db)
+
+
+def get_llm_config_service(db: Annotated[Session, Depends(get_db)]) -> LLMConfigService:
+    return LLMConfigService(db)
+
+def get_llm_service(config: Annotated[Configuration, Depends(get_config)]) -> DeepInfraApi:
+    
+    llm_params = LlmParams(**{
+        "url": config.llm_config.base_url,
+        "model": config.llm_config.model,
+        "tokenizer": config.llm_config.tokenizer,
+        "type": "deepinfra",
+        "default": True,
+        "predict_params": None, #должны задаваться при каждом запросе
+        "api_key": os.environ.get(config.llm_config.api_key_env),
+        "context_length": 128000
+    })
+    return DeepInfraApi(params=llm_params)
+
+def get_llm_prompt_service(db: Annotated[Session, Depends(get_db)]) -> LlmPromptService:
+    return LlmPromptService(db)

common/exceptions.py

@@ -0,0 +1,22 @@
+from fastapi import HTTPException
+
+
+class FeedbackNotFoundException(HTTPException):
+    def __init__(self, feedback_id: int):
+        super().__init__(status_code=404, detail=f"Отзыв id={feedback_id} не найден")
+
+class LLMResponseException(HTTPException):
+    def __init__(self, detail: str = "Не удалось получить ответ LLM"):
+        super().__init__(status_code=400, detail=detail)
+
+class LogNotFoundException(HTTPException):
+    def __init__(self, log_id: int):
+        super().__init__(status_code=404, detail=f"Лог id={log_id} не найден")
+
+class InvalidUserScoreException(HTTPException):
+    def __init__(self, userScore: int):
+        super().__init__(status_code=400, detail=f"Невалидная оценка {userScore} ответа LLM")
+
+class InvalidEstimateException(HTTPException):
+    def __init__(self, estimate_value: int):
+        super().__init__(status_code=400, detail=f"Невалидная оценка {estimate_value} времени")

components/datasets/dispatcher.py

@@ -0,0 +1,313 @@
+import logging
+import re
+from logging import Logger
+from pathlib import Path
+from typing import Dict, List, Tuple
+
+import pandas as pd
+from elasticsearch.exceptions import ConnectionError
+from natasha import Doc, MorphVocab, NewsEmbedding, NewsMorphTagger, Segmenter
+
+from common.common import (
+    get_elastic_abbreviation_query,
+    get_elastic_group_query,
+    get_elastic_people_query,
+    get_elastic_query,
+    get_elastic_rocks_nn_query,
+    get_elastic_segmentation_query,
+)
+from common.configuration import Configuration, Query, SummaryChunks
+from common.constants import PROMPT, PROMPT_CLASSIFICATION
+from components.elastic import create_index_elastic_chunks
+from components.elastic.elasticsearch_client import ElasticsearchClient
+from components.embedding_extraction import EmbeddingExtractor
+from components.nmd.aggregate_answers import aggregate_answers
+from components.nmd.faiss_vector_search import FaissVectorSearch
+from components.nmd.llm_chunk_search import LLMChunkSearch
+from components.nmd.metadata_manager import MetadataManager
+from components.nmd.query_classification import QueryClassification
+from components.nmd.rancker import DocumentRanking
+
+from components.services.dataset import DatasetService
+
+logger = logging.getLogger(__name__)
+
+
+class Dispatcher:
+    def __init__(
+        self,
+        embedding_model: EmbeddingExtractor,
+        config: Configuration,
+        logger: Logger,
+        dataset_service: DatasetService
+    ):
+        self.dataset_service = dataset_service
+        self.config = config
+        self.embedder = embedding_model
+        self.dataset_id = None
+        
+        self.try_load_default_dataset()
+
+        self.llm_search = LLMChunkSearch(config.llm_config, PROMPT, logger)
+        if self.config.db_config.elastic.use_elastic:
+            self.elastic_search = ElasticsearchClient(
+                host=f'{config.db_config.elastic.es_host}',
+                port=config.db_config.elastic.es_port,
+            )
+
+        self.query_classification = QueryClassification(
+            config.llm_config, PROMPT_CLASSIFICATION, logger
+        )
+        self.segmenter = Segmenter()
+        self.morph_tagger = NewsMorphTagger(NewsEmbedding())
+        self.morph_vocab = MorphVocab()
+
+    def try_load_default_dataset(self):
+        default_dataset = self.dataset_service.get_default_dataset()
+        if default_dataset is not None and default_dataset.id is not None and default_dataset.id != self.dataset_id:
+            logger.info(f'Reloading dataset {default_dataset.id}')
+            self.reset_dataset(default_dataset.id)
+        else:
+            self.faiss_search = None
+            self.meta_database = None
+            
+    def reset_dataset(self, dataset_id: int):
+        logger.info(f'Reset dataset to dataset_id: {dataset_id}')
+        data_path = Path(self.config.db_config.faiss.path_to_metadata)
+        df = pd.read_pickle(data_path / str(dataset_id) / 'dataset.pkl')
+        logger.info(f'Dataset loaded from {data_path / str(dataset_id) / "dataset.pkl"}')
+        logger.info(f'Dataset shape: {df.shape}')
+        self.faiss_search = FaissVectorSearch(self.embedder, df, self.config.db_config)
+        logger.info(f'Faiss search initialized')
+        self.meta_database = MetadataManager(df, logger)
+        logger.info(f'Meta database initialized')
+
+        if self.config.db_config.elastic.use_elastic:
+            create_index_elastic_chunks(df, logger)
+            logger.info(f'Elastic index created')
+        self.document_ranking = DocumentRanking(df, self.config)
+        logger.info(f'Document ranking initialized')
+
+    def __vector_search(self, query: str) -> Dict[int, Dict]:
+        """
+        Метод для поиска ближайших векторов по векторной базе Faiss.
+        Args:
+            query: Запрос пользователя.
+
+        Returns:
+            возвращает словарь chunks.
+        """
+        query_embeds, scores, indexes = self.faiss_search.search_vectors(query)
+        if self.config.db_config.ranker.use_ranging:
+            indexes = self.document_ranking.doc_ranking(query_embeds, scores, indexes)
+        return self.meta_database.search(indexes)
+
+    def __elastic_search(
+        self, query: str, index_name: str, search_function, size: int
+    ) -> Dict:
+        """
+        Метод для полнотекстового поиска.
+        Args:
+            query: Запрос пользователя.
+            index_name: Наименование индекса.
+            search_function: Функция запроса, зависит от индекса по которому нужно искать.
+            size: Количество ближайших соседей, или размер выборки.
+
+        Returns:
+            Возвращает словарь c ответами.
+        """
+        self.elastic_search.set_index(index_name)
+        return self.elastic_search.search(query=search_function(query), size=size)
+
+    @staticmethod
+    def _get_indexes_full_text_elastic_search(elastic_answer: Dict) -> List:
+        """
+        Метод позволяет получить индексы чанков, которые нашел elastic.
+        Args:
+            elastic_answer: Результаты полнотекстового поиска по чанкам.
+
+        Returns:
+            Возвращает список индексов.
+        """
+        answer = []
+        for answer_dict in elastic_answer:
+            answer.append(answer_dict['_source']['index'])
+        return answer
+
+    def _lemmatization_text(self, text: str):
+        doc = Doc(text)
+        doc.segment(self.segmenter)
+        doc.tag_morph(self.morph_tagger)
+
+        for token in doc.tokens:
+            token.lemmatize(self.morph_vocab)
+
+        return ' '.join([token.lemma for token in doc.tokens])
+
+    def _get_abbreviations(self, query: Query):
+        query_abbreviation = query.query_abbreviation
+        abbreviations_replaced = query.abbreviations_replaced
+        try:
+            if self.config.db_config.elastic.use_elastic:
+                if (
+                    self.config.db_config.search.abbreviation_search.use_abbreviation_search
+                ):
+                    abbreviation_answer = self.__elastic_search(
+                        query=query.query,
+                        index_name=self.config.db_config.search.abbreviation_search.index_name,
+                        search_function=get_elastic_abbreviation_query,
+                        size=self.config.db_config.search.abbreviation_search.k_neighbors,
+                    )
+                    if len(abbreviation_answer) > 0:
+                        query_lemmatization = self._lemmatization_text(query.query)
+                        for abbreviation in abbreviation_answer:
+                            abbreviation_lemmatization = self._lemmatization_text(
+                                abbreviation['_source']['text'].lower()
+                            )
+                            if abbreviation_lemmatization in query_lemmatization:
+                                query_abbreviation_lemmatization = (
+                                    self._lemmatization_text(query_abbreviation)
+                                )
+                                index = re.search(
+                                    abbreviation_lemmatization,
+                                    query_abbreviation_lemmatization,
+                                ).span()[1]
+                                space_index = query_abbreviation.find(' ', index)
+                                if space_index != -1:
+                                    query_abbreviation = '{} ({}) {}'.format(
+                                        query_abbreviation[:space_index],
+                                        abbreviation["_source"]["abbreviation"],
+                                        query_abbreviation[space_index:],
+                                    )
+                                else:
+                                    query_abbreviation = '{} ({})'.format(
+                                        query_abbreviation,
+                                        abbreviation["_source"]["abbreviation"],
+                                    )
+        except ConnectionError:
+            logger.info("Connection Error Elasticsearch")
+
+        return Query(
+            query=query.query,
+            query_abbreviation=query_abbreviation,
+            abbreviations_replaced=abbreviations_replaced,
+        )
+
+    def search_answer(self, query: Query) -> SummaryChunks:
+        """
+        Метод для поиска чанков отвечающих на вопрос пользователя в разных типах поиска.
+        Args:
+            query: Запрос пользователя.
+
+        Returns:
+            Возвращает чанки найденные на запрос пользователя.
+        """
+        self.try_load_default_dataset()
+        query = self._get_abbreviations(query)
+
+        logger.info(f'Start search for {query.query_abbreviation}')
+        logger.info(f'Use elastic search: {self.config.db_config.elastic.use_elastic}')
+
+        answer = {}
+        if self.config.db_config.search.vector_search.use_vector_search:
+            logger.info('Start vector search.')
+            answer['vector_answer'] = self.__vector_search(query.query_abbreviation)
+            logger.info(f'Vector search found {len(answer["vector_answer"])} chunks')
+
+        try:
+            if self.config.db_config.elastic.use_elastic:
+                if self.config.db_config.search.people_elastic_search.use_people_search:
+                    logger.info('Start people search.')
+                    people_answer = self.__elastic_search(
+                        query.query,
+                        index_name=self.config.db_config.search.people_elastic_search.index_name,
+                        search_function=get_elastic_people_query,
+                        size=self.config.db_config.search.people_elastic_search.k_neighbors,
+                    )
+                    logger.info(f'People search found {len(people_answer)} chunks')
+                    answer['people_answer'] = people_answer
+
+                if self.config.db_config.search.chunks_elastic_search.use_chunks_search:
+                    logger.info('Start full text chunks search.')
+                    chunks_answer = self.__elastic_search(
+                        query.query,
+                        index_name=self.config.db_config.search.chunks_elastic_search.index_name,
+                        search_function=get_elastic_query,
+                        size=self.config.db_config.search.chunks_elastic_search.k_neighbors,
+                    )
+                    indexes = self._get_indexes_full_text_elastic_search(chunks_answer)
+                    chunks_answer = self.meta_database.search(indexes)
+                    logger.info(
+                        f'Full text chunks search found {len(chunks_answer)} chunks'
+                    )
+                    answer['chunks_answer'] = chunks_answer
+
+                if self.config.db_config.search.groups_elastic_search.use_groups_search:
+                    logger.info('Start groups search.')
+                    groups_answer = self.__elastic_search(
+                        query.query,
+                        index_name=self.config.db_config.search.groups_elastic_search.index_name,
+                        search_function=get_elastic_group_query,
+                        size=self.config.db_config.search.groups_elastic_search.k_neighbors,
+                    )
+                    if len(groups_answer) != 0:
+                        logger.info(f'Groups search found {len(groups_answer)} chunks')
+                        answer['groups_answer'] = groups_answer
+
+                if (
+                    self.config.db_config.search.rocks_nn_elastic_search.use_rocks_nn_search
+                ):
+                    logger.info('Start Rocks NN search.')
+                    rocks_nn_answer = self.__elastic_search(
+                        query.query,
+                        index_name=self.config.db_config.search.rocks_nn_elastic_search.index_name,
+                        search_function=get_elastic_rocks_nn_query,
+                        size=self.config.db_config.search.rocks_nn_elastic_search.k_neighbors,
+                    )
+                    if len(rocks_nn_answer) != 0:
+                        logger.info(
+                            f'Rocks NN search found {len(rocks_nn_answer)} chunks'
+                        )
+                        answer['rocks_nn_answer'] = rocks_nn_answer
+
+                if (
+                    self.config.db_config.search.segmentation_elastic_search.use_segmentation_search
+                ):
+                    logger.info('Start Segmentation search.')
+                    segmentation_answer = self.__elastic_search(
+                        query.query,
+                        index_name=self.config.db_config.search.segmentation_elastic_search.index_name,
+                        search_function=get_elastic_segmentation_query,
+                        size=self.config.db_config.search.segmentation_elastic_search.k_neighbors,
+                    )
+                    if len(segmentation_answer) != 0:
+                        logger.info(
+                            f'Segmentation search found {len(segmentation_answer)} chunks'
+                        )
+                        answer['segmentation_answer'] = segmentation_answer
+
+        except ConnectionError:
+            logger.info("Connection Error Elasticsearch")
+
+        final_answer = aggregate_answers(**answer)
+        logger.info(f'Final answer found {len(final_answer)} chunks')
+        return SummaryChunks(**final_answer)
+
+    def llm_classification(self, query: str) -> str:
+        type_query = self.query_classification.classification(query)
+        return type_query
+
+    def llm_answer(
+        self, query: str, answer_chunks: SummaryChunks
+    ) -> Tuple[str, str, str, int]:
+        """
+        Метод для поиска правильного ответа с помощью LLM.
+        Args:
+            query: Запрос.
+            answer_chunks: Ответы векторного поиска и elastic.
+
+        Returns:
+            Возвращает исходные chunks из поисков, и chunk который выбрала модель.
+        """
+        prompt = PROMPT
+        return self.llm_search.llm_chunk_search(query, answer_chunks, prompt)

components/dbo/models/acronym.py

@@ -0,0 +1,19 @@
+from sqlalchemy import (
+    ForeignKey,
+    Integer,
+    String,
+)
+from sqlalchemy.orm import mapped_column, relationship
+from components.dbo.models.base import Base
+
+
+
+class Acronym(Base):
+    __tablename__ = "acronym"
+
+    short_form = mapped_column(String)
+    full_form = mapped_column(String)
+    type = mapped_column(String)
+    document_id = mapped_column(Integer, ForeignKey('document.id'), nullable=True)
+
+    document = relationship("Document", back_populates="acronyms")

components/dbo/models/base.py

@@ -0,0 +1,20 @@
+from datetime import datetime, timezone
+
+from sqlalchemy import (
+    DateTime,
+    Integer
+)
+from sqlalchemy.orm import Mapped, mapped_column, DeclarativeBase
+
+class Base(DeclarativeBase):
+    """Базовая модель с id, датой создания и датой удаления."""
+
+
+    id: Mapped[int] = mapped_column(Integer, primary_key=True, autoincrement=True)
+    date_created: Mapped[datetime] = mapped_column(
+        DateTime, default=datetime.now(timezone.utc), nullable=False
+    )
+    date_removed: Mapped[datetime | None] = mapped_column(DateTime, nullable=True)
+    
+    def to_dict(self):
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

components/dbo/models/dataset.py

@@ -0,0 +1,26 @@
+from sqlalchemy import (
+    Boolean,
+    ForeignKey,
+    Integer,
+    String,
+)
+from sqlalchemy.orm import Mapped, relationship, mapped_column
+
+from components.dbo.models.base import Base
+
+class Dataset(Base):
+    """
+    Сущность, которая хранит информацию о датасете.
+    """
+
+    __tablename__ = "dataset"
+
+    name: Mapped[str] = mapped_column(String, unique=True)
+    is_draft: Mapped[bool] = mapped_column(Boolean, default=True)
+    is_active: Mapped[bool] = mapped_column(Boolean, default=True)
+    previous_dataset_id: Mapped[int] = mapped_column(Integer, ForeignKey("dataset.id"), nullable=True)
+
+    documents: Mapped[list["DatasetDocument"]] = relationship(
+        "DatasetDocument", back_populates="dataset",
+        cascade="all, delete-orphan"
+    )

components/dbo/models/dataset_document.py

@@ -0,0 +1,24 @@
+from sqlalchemy import (
+    ForeignKey,
+    Integer,
+)
+from sqlalchemy.orm import Mapped, relationship, mapped_column
+from components.dbo.models.base import Base
+
+
+class DatasetDocument(Base):
+    """
+    Отношение многие ко многим между документами и датасетами.
+    """
+
+    __tablename__ = "dataset_document"
+
+    dataset_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey('dataset.id', ondelete='CASCADE'), index=True
+    )
+    document_id: Mapped[int] = mapped_column(
+        Integer, ForeignKey('document.id', ondelete='CASCADE'), index=True
+    )
+
+    dataset: Mapped["Dataset"] = relationship("Dataset", back_populates='documents')
+    document: Mapped["Document"] = relationship("Document", back_populates='datasets')

components/dbo/models/document.py

@@ -0,0 +1,25 @@
+from datetime import datetime
+
+from sqlalchemy import (
+    String,
+)
+from sqlalchemy.orm import Mapped, relationship, mapped_column
+from components.dbo.models.base import Base
+
+class Document(Base):
+    """
+    Сущность, которая хранит основную информацию о документе.
+    """
+
+    __tablename__ = "document"
+
+    filename: Mapped[str] = mapped_column(String)
+    source_format: Mapped[str] = mapped_column(String)
+    title: Mapped[str] = mapped_column(String)
+    status: Mapped[str] = mapped_column(String)
+    owner: Mapped[str] = mapped_column(String)
+
+    datasets: Mapped[list["DatasetDocument"]] = relationship(
+        'DatasetDocument', back_populates='document'
+    )
+    acronyms = relationship("Acronym", back_populates="document")

components/dbo/models/feedback.py

@@ -0,0 +1,27 @@
+from sqlalchemy import (
+    Boolean,
+    CheckConstraint,
+    Column,
+    DateTime,
+    ForeignKey,
+    Integer,
+    String,
+)
+from sqlalchemy.orm import mapped_column, relationship
+from components.dbo.models.base import Base
+
+
+
+class Feedback(Base):
+    __tablename__ = 'feedback'
+
+    userComment = mapped_column(String)
+    userScore = mapped_column(
+        Integer, CheckConstraint("userScore > 0 AND userScore < 6"), nullable=False
+    )
+    manualEstimate = mapped_column(Integer)
+    llmEstimate = mapped_column(Integer)
+
+    log_id = mapped_column(Integer, ForeignKey('log.id'), index=True)
+
+    log = relationship("Log", back_populates="feedback")

components/dbo/models/llm_config.py

@@ -0,0 +1,31 @@
+from sqlalchemy import (
+    Boolean, 
+    String,
+    Integer,
+    Float
+)
+from sqlalchemy.orm import Mapped, mapped_column
+
+from components.dbo.models.base import Base
+
+
+class LLMConfig(Base):
+    """
+    Сущность, которая хранит параметры вызова ЛЛМ.
+    """
+
+    __tablename__ = "llm_config"
+
+    is_default: Mapped[bool] = mapped_column(Boolean, is_default=False)
+    model: Mapped[String] = mapped_column(String)
+    temperature: Mapped[float] = mapped_column(Float)
+    top_p: Mapped[float] = mapped_column(Float)
+    min_p: Mapped[float] = mapped_column(Float)
+    frequency_penalty: Mapped[float] = mapped_column(Float)
+    presence_penalty: Mapped[float] = mapped_column(Float)
+    n_predict: Mapped[int] = mapped_column(Integer)
+    seed: Mapped[int] = mapped_column(Integer)
+
+    #TODO: вынести в базовый класс
+    def to_dict(self):
+        return {c.name: getattr(self, c.name) for c in self.__table__.columns}

components/dbo/models/llm_prompt.py

@@ -0,0 +1,21 @@
+from sqlalchemy import (
+    Boolean, 
+    String
+)
+from sqlalchemy.orm import Mapped, mapped_column
+
+from components.dbo.models.base import Base
+
+
+class LlmPrompt(Base):
+    """
+    Настройки промптов для ллм.
+    """
+
+    __tablename__ = "llm_prompt"
+
+    is_default: Mapped[bool] = mapped_column(Boolean, is_default=False)
+    name: Mapped[String] = mapped_column(String)
+    text: Mapped[String] = mapped_column(String)
+    type: Mapped[String] = mapped_column(String)
+    

components/dbo/models/log.py

@@ -0,0 +1,19 @@
+from sqlalchemy import (
+    Integer,
+    String,
+)
+from sqlalchemy.orm import relationship, mapped_column
+from components.dbo.models.base import Base
+
+
+class Log(Base):
+    __tablename__ = 'log'
+
+    llmPrompt = mapped_column(String)
+    llmResponse = mapped_column(String)
+    llm_classifier = mapped_column(String)
+    userRequest = mapped_column(String)
+    query_type = mapped_column(String)
+    userName = mapped_column(String)
+
+    feedback = relationship("Feedback", back_populates="log")

components/elastic/__init__.py

@@ -0,0 +1,7 @@
+from .create_index_elastic import create_index_elastic_people
+from .create_index_elastic_chunks import create_index_elastic_chunks
+
+__all__ = [
+    'create_index_elastic_chunks',
+    'create_index_elastic_people',
+]

components/elastic/create_index_elastic.py

@@ -0,0 +1,298 @@
+import json
+import logging
+import sys
+import time
+from pathlib import Path
+
+from elasticsearch import Elasticsearch
+from tqdm import tqdm
+
+ROOT_DIR = Path(__file__).resolve().parent.parent.parent
+if ROOT_DIR not in sys.path:
+    sys.path.append(str(ROOT_DIR))
+
+
+def create_index_elastic_people(
+    path: str,
+    logger: logging.Logger | None = None,
+):
+    if logger is None:
+        logger = logging.getLogger(__name__)
+
+    # Подключение к Elasticsearch
+    es = Elasticsearch(hosts='localhost:9200')
+    INDEX_NAME = 'people_search'
+
+    # Удаление старого индекса, если он существует
+    if es.indices.exists(index=INDEX_NAME):
+        es.indices.delete(index=INDEX_NAME)
+
+    mapping = {
+        "settings": {
+            "analysis": {
+                "char_filter": {
+                    "quote_removal": {
+                        "type": "pattern_replace",
+                        "pattern": "[\"«»]",
+                        "replacement": "",
+                    }
+                },
+                "filter": {
+                    # "russian_stemmer": {
+                    #     "type": "stemmer",
+                    #     "name": "russian"
+                    # },
+                    "custom_stopwords": {
+                        "type": "stop",
+                        "stopwords": [
+                            "кто",
+                            "является",
+                            "куратором",
+                            "руководит",
+                            "отвечает",
+                            "бизнес",
+                            "за что",
+                            "ООО",
+                            "ОАО",
+                            "НН",
+                            "персональный",
+                            "состав",
+                            "персональный",
+                            "состав",
+                            "Комитета",
+                            "ПАО",
+                            "ГМК",
+                            "Норильский никель",
+                            "Рабочей группы",
+                            "что",
+                            "как",
+                            "почему",
+                            "зачем",
+                            "где",
+                            "когда",
+                        ],
+                    }
+                },
+                "analyzer": {
+                    "custom_analyzer": {
+                        "type": "custom",
+                        "char_filter": ["quote_removal"],
+                        "tokenizer": "standard",
+                        "filter": [
+                            "lowercase",
+                            "custom_stopwords",
+                            # "russian_stemmer"
+                        ],
+                    }
+                },
+            }
+        },
+        "mappings": {
+            "properties": {
+                "business_processes": {
+                    "type": "nested",
+                    "properties": {
+                        "production_activities_section": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                        "processes_name": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                        "level_process": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                    },
+                },
+                "organizatinal_structure": {
+                    "type": "nested",
+                    "properties": {
+                        "position": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                        "leads": {
+                            "type": "nested",
+                            "properties": {
+                                "0": {
+                                    "type": "text",
+                                    "analyzer": "custom_analyzer",
+                                    "search_analyzer": "custom_analyzer",
+                                },
+                                "1": {
+                                    "type": "text",
+                                    "analyzer": "custom_analyzer",
+                                    "search_analyzer": "custom_analyzer",
+                                },
+                            },
+                        },
+                        "subordinate": {
+                            "type": "object",
+                            "properties": {
+                                "person_name": {
+                                    "type": "text",
+                                    "analyzer": "custom_analyzer",
+                                    "search_analyzer": "custom_analyzer",
+                                },
+                                "position": {
+                                    "type": "text",
+                                    "analyzer": "custom_analyzer",
+                                    "search_analyzer": "custom_analyzer",
+                                },
+                            },
+                        },
+                    },
+                },
+                "business_curator": {
+                    "type": "nested",
+                    "properties": {
+                        "division": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                        "company_name": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                    },
+                },
+                "groups": {
+                    "type": "nested",
+                    "properties": {
+                        "group_name": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                        "position_in_group": {
+                            "type": "text",
+                            "analyzer": "custom_analyzer",
+                            "search_analyzer": "custom_analyzer",
+                        },
+                        "block": {"type": "keyword", "null_value": "unknown"},
+                    },
+                },
+                "person_name": {
+                    "type": "text",
+                    "analyzer": "custom_analyzer",
+                    "search_analyzer": "custom_analyzer",
+                },
+            }
+        },
+    }
+    # Создание индекса с указанным маппингом
+    es.indices.create(index=INDEX_NAME, body=mapping)
+
+    group_names = []
+    for ind, path in tqdm(enumerate(Path(path).iterdir())):
+        # Открываем файл и читаем его содержимое
+        try:
+            with open(path, 'r', encoding='utf-8') as file:
+                data = json.load(file)
+
+            # Индексирование документа в Elasticsearch
+            es.index(index=INDEX_NAME, id=ind + 1, body=data)
+            time.sleep(0.5)
+        except:
+            print(f"Ошибка при чтении или добавлении файла {path.name} в индекс")
+
+    if es.indices.exists(index=INDEX_NAME):
+        print(f"Index '{INDEX_NAME}' exists.")
+
+    # Подсчет количества документов в индексе
+    count_response = es.count(index=INDEX_NAME)
+    print(f"Total documents in '{INDEX_NAME}': {count_response['count']}")
+
+    def get_elastic_people_query(query):
+        has_business_curator = (
+            "бизнес куратор" in query.lower() or "бизнес-куратор" in query.lower()
+        )
+        business_curator_boost = 20 if has_business_curator else 15
+        return {
+            "query": {
+                "function_score": {
+                    "query": {
+                        "bool": {
+                            "should": [
+                                {
+                                    "multi_match": {
+                                        "query": query,
+                                        "fields": ["person_name^3"],
+                                        "fuzziness": "AUTO",
+                                        "analyzer": "custom_analyzer",
+                                    }
+                                },
+                                {
+                                    "nested": {
+                                        "path": "business_processes",
+                                        "query": {
+                                            "multi_match": {
+                                                "query": query,
+                                                "fields": [
+                                                    "business_processes.production_activities_section",
+                                                    "business_processes.processes_name",
+                                                ],
+                                                "fuzziness": "AUTO",
+                                                "analyzer": "custom_analyzer",
+                                            }
+                                        },
+                                    }
+                                },
+                                {
+                                    "nested": {
+                                        "path": "organizatinal_structure",
+                                        "query": {
+                                            "multi_match": {
+                                                "query": query,
+                                                "fields": [
+                                                    "organizatinal_structure.position^2"
+                                                ],
+                                                "fuzziness": "AUTO",
+                                                "analyzer": "custom_analyzer",
+                                            }
+                                        },
+                                    }
+                                },
+                                {
+                                    "nested": {
+                                        "path": "business_curator",
+                                        "query": {
+                                            "multi_match": {
+                                                "query": query,
+                                                "fields": [
+                                                    f"business_curator.company_name^{business_curator_boost}"
+                                                ],
+                                                "fuzziness": "AUTO",
+                                                "analyzer": "custom_analyzer",
+                                            }
+                                        },
+                                    }
+                                },
+                            ]
+                        }
+                    }
+                }
+            }
+        }
+
+    query = 'кто бизнес куратор ООО Медвежий ручей?'
+    # Выполнение поиска в Elasticsearch
+    response = es.search(index=INDEX_NAME, body=get_elastic_people_query(query), size=2)
+    logger.info(f"Number of hits: {response['hits']['total']['value']}")
+
+    # Вывод результата поиска
+    for hit in response['hits']['hits']:
+        logger.info(hit['_source'])
+
+
+if __name__ == '__main__':
+    path = '/mnt/ntr_work/data/фывфыаыфвфы/person_card'
+    create_index_elastic_people(path)

components/elastic/create_index_elastic_abbreviation.py

@@ -0,0 +1,77 @@
+import logging
+
+import pandas as pd
+from elasticsearch import Elasticsearch
+from tqdm import tqdm
+
+
+def create_index_elastic_abbreviation(
+    df: pd.DataFrame,
+    logger: logging.Logger | None,
+):
+    if logger is None:
+        logger = logging.getLogger(__name__)
+
+    # Подключение к Elasticsearch
+    es = Elasticsearch(hosts='localhost:9200')
+
+    INDEX_NAME = 'nmd_abbreviation_elastic'
+
+    # Удаление старого индекса, если он существует
+    if es.indices.exists(index=INDEX_NAME):
+        es.indices.delete(index=INDEX_NAME)
+
+    mapping = {
+        "mappings": {
+            "properties": {
+                "abbreviation": {"type": "text", "analyzer": "russian"},
+                "text": {"type": "text", "analyzer": "russian"},
+            }
+        }
+    }
+
+    # Создание индекса с указанным маппингом
+    es.indices.create(index=INDEX_NAME, body=mapping)
+
+    # Индексация документов
+    for ind, row in tqdm(df.iterrows()):
+        document = {'abbreviation': row['name'], 'text': row['definition']}
+
+        # Индексирование документа в Elasticsearch
+        es.index(index=INDEX_NAME, id=ind, body=document)
+
+    if es.indices.exists(index=INDEX_NAME):
+        logger.info(f"Index '{INDEX_NAME}' exists.")
+
+    # # Подсчет количества документов в индексе
+    count_response = es.count(index=INDEX_NAME)
+    logger.info(f"Total documents in '{INDEX_NAME}': {count_response['count']}")
+
+    # Поиск документов, где поле "person_full_name" содержит определенное значение "Александров Д.В."
+    query = {
+        "query": {
+            "multi_match": {
+                "query": "для нужен стандарт управления бизнес процессами компании?",
+                "fuzziness": "AUTO",
+                "minimum_should_match": "83%",
+                "fields": ["text"],
+            }
+        },
+        "highlight": {"fields": {"text": {}}},
+    }
+
+    # Выполнение поиска в Elasticsearch
+    response = es.search(index=INDEX_NAME, body=query, size=1)
+    logger.info(f"Number of hits: {response['hits']['total']['value']}")
+
+    # Вывод результата поиска
+    for hit in response['hits']['hits']:
+        logger.info(hit)
+        logger.info('=====')
+
+
+if __name__ == '__main__':
+    # Чтение CSV файла с данными
+    df = pd.read_csv('/mnt/ntr_work/project/nmd800/data/abbreviations.csv')
+
+    create_index_elastic_abbreviation(df)

components/elastic/create_index_elastic_chunks.py

@@ -0,0 +1,73 @@
+import logging
+
+import pandas as pd
+from elasticsearch import Elasticsearch
+from tqdm import tqdm
+
+
+def create_index_elastic_chunks(
+    df: pd.DataFrame,
+    logger: logging.Logger | None,
+):
+    if logger is None:
+        logger = logging.getLogger(__name__)
+
+    # Подключение к Elasticsearch
+    es = Elasticsearch(hosts='localhost:9200')
+
+    INDEX_NAME = 'nmd_full_text2'
+
+    # Удаление старого индекса, если он существует
+    if es.indices.exists(index=INDEX_NAME):
+        es.indices.delete(index=INDEX_NAME)
+
+    mapping = {
+        "mappings": {
+            "properties": {
+                "index": {"type": "keyword"},
+                "text": {"type": "text", "analyzer": "standard"},
+            }
+        }
+    }
+
+    # Создание индекса с указанным маппингом
+    es.indices.create(index=INDEX_NAME, body=mapping)
+
+    # Индексация документов
+    for ind, row in tqdm(df.iterrows()):
+        document = {'index': ind, 'text': row['Text']}
+
+        # Индексирование документа в Elasticsearch
+        es.index(index=INDEX_NAME, id=ind, body=document)
+
+    if es.indices.exists(index=INDEX_NAME):
+        print(f"Index '{INDEX_NAME}' exists.")
+
+    # # Подсчет количества документов в индексе
+    count_response = es.count(index=INDEX_NAME)
+    print(f"Total documents in '{INDEX_NAME}': {count_response['count']}")
+
+    # Поиск документов, где поле "person_full_name" содержит определенное значение "Александров Д.В."
+    query = {
+        "query": {
+            "multi_match": {
+                "query": "4.1. Комиссия ГО имеет право: привлекать работников Компании (по согласованию с руководителями структурных подразделений) для подготовки проектов документов Комиссии ГО, в сроки, установленные Комиссией ГО, а также в целях выполнения других работ, необходимых для принятия решений Комиссии ГО; отклонять материалы, представленные для рассмотрения на заседания Комиссии ГО в случае, если материалы требуют доработки или не относятся к компетенции Комиссии ГО в соответствии с разделом 6 настоящего Положения; \uf02d запрашивать у руководителей структурных подразделений Компании информацию и документы для принятия решений в рамках компетенции Комиссии ГО в соответствии с разделом 6 настоящего Положения; приглашать на заседания Комиссии ГО работников Группы компаний «Норильский никель», представителей Комиссий Филиалов, а также внешних консультантов, экспертов",
+                "fields": ["*"],
+            }
+        }
+    }
+
+    # Выполнение поиска в Elasticsearch
+    response = es.search(index=INDEX_NAME, body=query, size=2)
+    logger.info(f"Number of hits: {response['hits']['total']['value']}")
+
+    # Вывод результата поиска
+    for hit in response['hits']['hits']:
+        logger.info(hit['_source'])
+
+
+if __name__ == '__main__':
+    df = pd.read_pickle(
+        '/mnt/ntr_work/project/nmd800/data/db/dataset_local_tables2.pkl'
+    )
+    create_index_elastic_chunks(df)

components/elastic/create_index_elastic_group.py

@@ -0,0 +1,133 @@
+import json
+import logging
+import time
+from pathlib import Path
+
+from elasticsearch import Elasticsearch
+from tqdm import tqdm
+
+
+def create_index_elastic_group(
+    path: str,
+    logger: logging.Logger | None = None,
+):
+    if logger is None:
+        logger = logging.getLogger(__name__)
+
+    # Подключение к Elasticsearch
+    es = Elasticsearch(hosts='localhost:9200')
+    INDEX_NAME = 'group_search_elastic_nn'
+
+    # Удаление старого индекса, если он существует
+    if es.indices.exists(index=INDEX_NAME):
+        es.indices.delete(index=INDEX_NAME)
+
+    mapping = {
+        "mappings": {
+            "properties": {
+                "group_name_nn": {"type": "text", "analyzer": "standard"},
+                "group_composition_nn": {
+                    "type": "nested",
+                    "properties": {
+                        "person_name_nn": {"type": "text", "analyzer": "standard"},
+                        "position_in_group_nn": {
+                            "type": "text",
+                            "analyzer": "standard",
+                        },
+                    },
+                },
+            }
+        }
+    }
+
+    # Создание индекса с указанным маппингом
+    es.indices.create(index=INDEX_NAME, body=mapping)
+
+    for ind, path in tqdm(enumerate(Path(path).iterdir())):
+        # Открываем файл и читаем его содержимое
+        with open(path, 'r', encoding='utf-8') as file:
+            data = json.load(file)
+        # Индексирование документа в Elasticsearch
+        es.index(index=INDEX_NAME, id=ind + 1, body=data)
+
+        # Подсчет количества документов в индексе
+        count_response = es.count(index=INDEX_NAME)
+        logger.info(
+            f"{ind}, Total documents in '{INDEX_NAME}': {count_response['count']}"
+        )
+        time.sleep(0.5)
+
+    if es.indices.exists(index=INDEX_NAME):
+        logger.info(f"Index '{INDEX_NAME}' exists.")
+
+    # Подсчет количества документов в индексе
+    count_response = es.count(index=INDEX_NAME)
+    logger.info(f"Total documents in '{INDEX_NAME}': {count_response['count']}")
+
+    query = "Какие действия являются первоочередными в момент обнаружения происшествия?"
+
+    # Поиск документов, где поле "person_full_name" содержит определенное значение "Александров Д.В."
+    # query_ = {
+    #     "query": {
+    #         "function_score": {
+    #             "query": {
+    #                 "multi_match": {
+    #                     "query": f"{query}",
+    #                     "fields": ["group_name"],
+    #                     "fuzziness": "AUTO",
+    #                     "analyzer": "standard"
+    #                 }
+    #             },
+    #             "functions": [
+    #                 {
+    #                     "filter": {
+    #                         "multi_match": {
+    #                             "query": "персонального состава Персональный состав Комитета ПАО ГМК Норильский никель Рабочей группы",
+    #                             "fields": ["group_name"],
+    #                             "operator": "or"
+    #                         }
+    #                     },
+    #                     "weight": 0.9  #// Понижает вес документов с этими словами
+    #                 }
+    #             ],
+    #             "boost_mode": "multiply"  # // Умножает вес документов с фильтром на указанный коэффициент
+    #         }
+    #     }
+    # }
+    query_ = {
+        "query": {
+            "bool": {
+                "should": [
+                    {
+                        "multi_match": {
+                            "query": f"{query}",
+                            "fields": ["group_name"],
+                            "fuzziness": "AUTO",
+                            "analyzer": "standard",
+                        }
+                    },
+                    {
+                        "multi_match": {
+                            "query": "персонального состава Персональный состав Комитета ПАО ГМК Норильский никель Рабочей группы",
+                            "fields": ["group_name"],
+                            "operator": "or",
+                            "boost": 0.1,
+                        }
+                    },
+                ]
+            }
+        }
+    }
+
+    # Выполнение поиска в Elasticsearch
+    response = es.search(index=INDEX_NAME, body=query_, size=2)
+    logger.info(f"Number of hits: {response['hits']['total']['value']}")
+
+    # Вывод результата поиска
+    for hit in response['hits']['hits']:
+        logger.info(hit['_source'])
+
+
+if __name__ == '__main__':
+    path = '/mnt/ntr_work/project/nmd800/data/group_card'
+    create_index_elastic_group(path)

components/elastic/create_index_elastic_rocks_nn.py

@@ -0,0 +1,137 @@
+import json
+import logging
+from pathlib import Path
+import time
+
+from elasticsearch import Elasticsearch
+from tqdm import tqdm
+
+
+def create_index_elastic_rocks_nn(
+    path: str,
+    logger: logging.Logger | None = None,
+):
+    if logger is None:
+        logger = logging.getLogger(__name__)
+
+    # Подключение к Elasticsearch
+    es = Elasticsearch(hosts='localhost:9200')
+    INDEX_NAME = 'rocks_nn_search_elastic'
+
+    # Удаление старого индекса, если он существует
+    if es.indices.exists(index=INDEX_NAME):
+        es.indices.delete(index=INDEX_NAME)
+
+    mapping = {
+        "settings": {
+            "analysis": {
+                "filter": {
+                    "custom_stopwords": {
+                        "type": "stop",
+                        "stopwords": [
+                            "ООО",
+                            "ОАО",
+                            "НН",
+                            "нн",
+                            "Перечень",
+                            "перечень",
+                            "дивизиона",
+                            "дивизион",
+                        ],
+                    }
+                },
+                "analyzer": {
+                    "custom_analyzer": {
+                        "type": "custom",
+                        "tokenizer": "standard",
+                        "filter": [
+                            "lowercase",
+                            "custom_stopwords",
+                        ],
+                    }
+                },
+            }
+        },
+        "mappings": {
+            "properties": {
+                "division_name": {
+                    "type": "text",
+                    "analyzer": "custom_analyzer",
+                    "search_analyzer": "custom_analyzer",
+                },
+                "division_name_2": {
+                    "type": "text",
+                    "analyzer": "custom_analyzer",
+                    "search_analyzer": "custom_analyzer",
+                },
+                "company_name": {
+                    "type": "text",
+                    "analyzer": "custom_analyzer",
+                    "search_analyzer": "custom_analyzer",
+                },
+            }
+        },
+    }
+
+    # Создание индекса с указанным маппингом
+    es.indices.create(index=INDEX_NAME, body=mapping)
+
+    for ind, path in tqdm(enumerate(Path(path).iterdir())):
+        # Открываем файл и читаем его содержимое
+        with open(path, 'r', encoding='utf-8') as file:
+            data = json.load(file)
+        # Индексирование документа в Elasticsearch
+        es.index(index=INDEX_NAME, id=ind + 1, body=data)
+
+        # Подсчет количества документов в индексе
+        count_response = es.count(index=INDEX_NAME)
+        logger.info(
+            f"{ind}, Total documents in '{INDEX_NAME}': {count_response['count']}"
+        )
+        time.sleep(1.0)
+
+    if es.indices.exists(index=INDEX_NAME):
+        logger.info(f"Index '{INDEX_NAME}' exists.")
+
+    # Подсчет количества документов в индексе
+    count_response = es.count(index=INDEX_NAME)
+    logger.info(f"Total documents in '{INDEX_NAME}': {count_response['count']}")
+
+    query = "Какие РОКС НН входят в состав Норильского дивизиона?"
+
+    query_ = {
+        "query": {
+            "function_score": {
+                "query": {
+                    "multi_match": {
+                        "query": f"{query}",
+                        "fields": ["division_name", "division_name_2", "company_name"],
+                        "fuzziness": "AUTO",
+                        "analyzer": "custom_analyzer",
+                    }
+                },
+                "functions": [
+                    {
+                        "filter": {
+                            "term": {"_id": "3"}  # ID документа, который нужно понизить
+                        },
+                        "weight": 0.5,  # Устанавливает очень низкий вес для этого документа
+                    }
+                ],
+                "boost_mode": "multiply",  # Сочетание _score и весов
+            }
+        }
+    }
+
+    # Выполнение поиска в Elasticsearch
+    response = es.search(index=INDEX_NAME, body=query_, size=1)
+    logger.info(f"Number of hits: {response['hits']['total']['value']}")
+
+    # Вывод результата поиска
+    for hit in response['hits']['hits']:
+        logger.info(hit['_source'])
+
+
+if __name__ == '__main__':
+    path = '/mnt/ntr_work/project/nmd800/data/rocks_nn_card'
+    create_index_elastic_rocks_nn(path)

components/elastic/create_index_elastic_segmentation.py

@@ -0,0 +1,101 @@
+import json
+import logging
+import time
+from pathlib import Path
+
+from elasticsearch import Elasticsearch
+from tqdm import tqdm
+
+
+def create_index_elastic_segmentation(
+    path: str,
+    logger: logging.Logger | None = None,
+):
+    if logger is None:
+        logger = logging.getLogger(__name__)
+
+    # Подключение к Elasticsearch
+    es = Elasticsearch(hosts='localhost:9200')
+    INDEX_NAME = 'segmentation_search_elastic'
+
+    # Удаление старого индекса, если он существует
+    if es.indices.exists(index=INDEX_NAME):
+        es.indices.delete(index=INDEX_NAME)
+
+    mapping = {
+        "mappings": {
+            "properties": {
+                "segmentation_model": {"type": "text", "analyzer": "standard"},
+                "segmentation_model2": {"type": "text", "analyzer": "standard"},
+                "company_name": {"type": "text", "analyzer": "standard"},
+            }
+        }
+    }
+
+    # Создание индекса с указанным маппингом
+    es.indices.create(index=INDEX_NAME, body=mapping)
+
+    for ind, path in tqdm(enumerate(Path(path).iterdir())):
+        # Открываем файл и читаем его содержимое
+        with open(path, 'r', encoding='utf-8') as file:
+            data = json.load(file)
+        # Индексирование документа в Elasticsearch
+        es.index(index=INDEX_NAME, id=ind + 1, body=data)
+
+        # Подсчет количества документов в индексе
+        count_response = es.count(index=INDEX_NAME)
+        logger.info(
+            f"{ind}, Total documents in '{INDEX_NAME}': {count_response['count']}"
+        )
+        time.sleep(1.0)
+
+    if es.indices.exists(index=INDEX_NAME):
+        logger.info(f"Index '{INDEX_NAME}' exists.")
+
+    # Подсчет количества документов в индексе
+    count_response = es.count(index=INDEX_NAME)
+    logger.info(f"Total documents in '{INDEX_NAME}': {count_response['count']}")
+
+    query = "К какой модели сегментации относится ООО ГРК Быстринское?"
+
+    query_ = {
+        "query": {
+            "bool": {
+                "should": [
+                    {
+                        "multi_match": {
+                            "query": f"{query}",
+                            "fields": [
+                                "segmentation_model",
+                                "segmentation_model2",
+                                "company_name",
+                            ],
+                            "fuzziness": "AUTO",
+                            "analyzer": "standard",
+                        }
+                    },
+                    {
+                        "multi_match": {
+                            "query": "модели сегментации модель сегментации",
+                            "fields": ["segmentation_model", "segmentation_model2"],
+                            "operator": "or",
+                            "boost": 0.1,
+                        }
+                    },
+                ]
+            }
+        }
+    }
+
+    # Выполнение поиска в Elasticsearch
+    response = es.search(index=INDEX_NAME, body=query_, size=1)
+    logger.info(f"Number of hits: {response['hits']['total']['value']}")
+
+    # Вывод результата поиска
+    for hit in response['hits']['hits']:
+        logger.info(hit['_source'])
+
+
+if __name__ == '__main__':
+    path = '/mnt/ntr_work/project/nmd800/data/segmentation_card'
+    create_index_elastic_segmentation(path)

components/elastic/elasticsearch_client.py

@@ -0,0 +1,111 @@
+from elasticsearch import Elasticsearch
+
+from common.common import get_elastic_query
+
+
+class ElasticsearchClient:
+    def __init__(self,
+                 host: str = 'localhost',
+                 port: int = 9200,
+                 scheme: str = 'http',
+                 index_name='my_index',
+                 answer=None):
+        """
+            Инициализация клиента Elasticsearch и установка имени индекса.
+
+        Args:
+            host: Адрес хоста Elasticsearch
+            port:
+            scheme:
+            index_name: Название индекса, с которым будет работать клиент
+        """
+        self.es = Elasticsearch([{'host': host, 'port': port, 'scheme': scheme}])
+        self.index_name = index_name
+        self.answer = answer
+
+    def set_index(self, index_name):
+        """
+        Метод для изменения индекса.
+
+        Args:
+            index_name: Название индекса
+        """
+        self.index_name = index_name
+
+    def search(self, query, size=10):
+        """
+        Выполняет поиск по указанному запросу и возвращает результаты.
+
+        Args:
+            query: Запрос для поиска
+            size: Максимальное количество возвращаемых результатов
+
+        Returns:
+            Результаты поиска
+        """
+        response = self.es.search(index=self.index_name, body=query, size=size)
+        return response['hits']['hits']
+
+    def create_document(self, doc_id, document):
+        """
+        Создает новый документ в Elasticsearch.
+
+        Args:
+            doc_id: Данные документа
+            document: Идентификатор документа
+        """
+        self.es.index(index=self.index_name, id=doc_id, body=document)
+
+    def get_document(self, doc_id):
+        """
+        Получает документ по его идентификатору.
+
+        Args:
+            doc_id: Идентификатор документа
+
+        Returns:
+            Найденный документ
+        """
+        return self.es.get(index=self.index_name, id=doc_id)
+
+    def delete_document(self, doc_id):
+        """
+        Удаляет документ по его идентификатору.
+
+        Args:
+            doc_id: Идентификатор документа
+        """
+        self.es.delete(index=self.index_name, id=doc_id)
+
+    def update_document(self, doc_id, document):
+        """
+        Обновляет данные существующего документа.
+
+        Args:
+            doc_id: Идентификатор документа
+            document: Обновленные данные документа
+        """
+        self.es.update(index=self.index_name, id=doc_id, body={"doc": document})
+
+    def indices(self):
+        return self.es.indices.exists(index=self.index_name)
+
+
+# Пример использования
+if __name__ == "__main__":
+    # Инициализация клиента Elasticsearch
+    es_client = ElasticsearchClient(index_name='people_search')
+
+    # Пример запроса для поиска по имени
+    search_query = {
+        "query": {
+            "match": {
+                "person_full_name": "Бизнес-куратором каких РОКС НН является Берлин А.В."
+            }
+        }
+    }
+
+    # Выполнение поиска и вывод результатов
+    results = es_client.search(query=get_elastic_query('Бизнес-куратором каких РОКС НН является Берлин А.В.'))
+    for result in results:
+        print(result['_source'])

components/embedding_extraction.py

@@ -0,0 +1,195 @@
+import logging
+from typing import Callable
+
+import numpy as np
+import torch
+import torch.nn.functional as F
+from torch.utils.data import DataLoader
+from transformers import AutoModel, AutoTokenizer, BatchEncoding, XLMRobertaModel
+from transformers.modeling_outputs import (
+    BaseModelOutputWithPoolingAndCrossAttentions as EncoderOutput,
+)
+
+logger = logging.getLogger(__name__)
+
+
+class EmbeddingExtractor:
+    """Класс обрабатывает текст вопроса и возвращает embedding"""
+
+    def __init__(
+        self,
+        model_id: str,
+        device: str | torch.device | None = None,
+        batch_size: int = 1,
+        do_normalization: bool = True,
+        max_len: int = 510,
+    ):
+        """
+        Класс, соединяющий в себе модель, токенизатор и параметры векторизации.
+
+        Args:
+            model_id: Идентификатор модели.
+            device: Устройство для вычислений (по умолчанию - GPU, если доступен).
+            batch_size: Размер батча (по умолчанию - 1).
+            do_normalization: Нормировать ли вектора (по умолчанию - True).
+            max_len: Максимальная длина текста в токенах (по умолчанию - 510).
+        """
+        if device is None:
+            device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+        else:
+            device = torch.device(device)
+
+        self.device = device
+        # Инициализация модели
+        self.tokenizer = AutoTokenizer.from_pretrained(model_id)
+        self.model: XLMRobertaModel = AutoModel.from_pretrained(model_id).to(
+            self.device
+        )
+        self.model.eval()
+        self.model.share_memory()
+
+        self.batch_size = batch_size if device.type != 'cpu' else 1
+        self.do_normalization = do_normalization
+        self.max_len = max_len
+
+    @staticmethod
+    def _average_pool(
+        last_hidden_states: torch.Tensor, attention_mask: torch.Tensor
+    ) -> torch.Tensor:
+        """
+        Расчёт усредненного эмбеддинга по всем токенам
+
+        Args:
+            last_hidden_states: Матрица эмбеддингов отдельных токенов размерности (batch_size, seq_len, embedding_size) - последний скрытый слой
+            attention_mask: Маска, чтобы не учитывать при усреднении пустые токены
+
+        Returns:
+            torch.Tensor - Усредненный эмбеддинг размерности (batch_size, embedding_size)
+        """
+        last_hidden = last_hidden_states.masked_fill(
+            ~attention_mask[..., None].bool(), 0.0
+        )
+        return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None]
+
+    def _query_tokenization(self, text: str | list[str]) -> BatchEncoding:
+        """
+        Преобразует текст в токены.
+
+        Args:
+            text: Текст.
+            max_len: Максимальная длина текста (510 токенов)
+
+        Returns:
+            BatchEncoding - Словарь с ключами "input_ids", "attention_mask" и т.п.
+        """
+        if isinstance(text, str):
+            cleaned_text = text.replace('\n', ' ')
+        else:
+            cleaned_text = [t.replace('\n', ' ') for t in text]
+
+        return self.tokenizer(
+            cleaned_text,
+            return_tensors='pt',
+            padding=True,
+            truncation=True,
+            max_length=self.max_len,
+        )
+
+    @torch.no_grad()
+    def query_embed_extraction(
+        self,
+        text: str,
+        do_normalization: bool = True,
+    ) -> np.ndarray:
+        """
+        Функция преобразует один текст в эмбеддинг размерности (1, embedding_size)
+
+        Args:
+            text: Текст.
+            do_normalization: Нормировать ли вектора embedding
+
+        Returns:
+            np.array - Эмбеддинг размерности (1, embedding_size)
+        """
+        inputs = self._query_tokenization(text).to(self.device)
+        outputs = self.model(**inputs)
+
+        mask = inputs["attention_mask"]
+        embedding = self._average_pool(outputs.last_hidden_state, mask)
+
+        if do_normalization:
+            embedding = F.normalize(embedding, dim=-1)
+
+        return embedding.cpu().numpy()
+
+    # TODO: В будущем стоит объединить vectorize и query_embed_extraction
+    def vectorize(
+        self,
+        texts: list[str] | str,
+        progress_callback: Callable[[int, int], None] | None = None,
+    ) -> np.ndarray:
+        """
+        Векторизует все тексты в списке.
+        Во многом аналогичен методу query_embed_extraction, в будущем стоит объединить их.
+
+        Args:
+            texts: Список текстов или один текст.
+            progress_callback: Функция, которая будет вызываться при каждом шаге векторизации.
+                Принимает два аргумента: current и total.
+                current - текущий шаг векторизации.
+                total - общее количество шагов векторизации.
+
+        Returns:
+            np.array - Матрица эмбеддингов размерности (texts_count, embedding_size)
+        """
+        if isinstance(texts, str):
+            texts = [texts]
+
+        loader = DataLoader(texts, batch_size=self.batch_size)
+        embeddings = []
+
+        logger.info(
+            'Vectorizing texts with batch size %d on %s', self.batch_size, self.device
+        )
+
+        for i, batch in enumerate(loader):
+            embeddings.append(self._vectorize_batch(batch))
+
+            if progress_callback is not None:
+                progress_callback(i * self.batch_size, len(texts))
+            else:
+                logger.info('Vectorized batch %d', i)
+
+        logger.info('Vectorized all %d batches', len(embeddings))
+
+        return torch.cat(embeddings).numpy()
+
+    @torch.no_grad()
+    def _vectorize_batch(
+        self,
+        texts: list[str],
+    ) -> torch.Tensor:
+        """
+        Векторизует один батч текстов.
+
+        Args:
+            texts: Список текстов.
+
+        Returns:
+            torch.Tensor - Матрица эмбеддингов размерности (batch_size, embedding_size)
+        """
+        tokenized = self._query_tokenization(texts).to(self.device)
+        outputs: EncoderOutput = self.model(**tokenized)
+        mask = tokenized["attention_mask"]
+        embedding = self._average_pool(outputs.last_hidden_state, mask)
+
+        if self.do_normalization:
+            embedding = F.normalize(embedding, dim=-1)
+
+        return embedding.cpu()
+
+    def get_dim(self) -> int:
+        """
+        Возвращает размерность эмбеддинга.
+        """
+        return self.model.config.hidden_size

components/faiss_vector_database.py

@@ -0,0 +1,248 @@
+from typing import Tuple, List, Dict, Union
+
+import faiss
+import pandas as pd
+import numpy as np
+import torch
+
+from common.constants import COLUMN_DOC_NAME
+from common.constants import COLUMN_EMBEDDING
+from common.constants import COLUMN_LABELS_STR
+from common.constants import COLUMN_NAMES
+from common.constants import COLUMN_TABLE_NAME
+from common.constants import COLUMN_TYPE_DOC_MAP
+
+
+class FaissVectorDatabase:
+    """Класс для взаимодействия между векторами и информацией о них"""
+    def __init__(self, path_to_metadata: str = None, df: pd.DataFrame = None, global_df: pd.DataFrame = None):
+        if isinstance(df, pd.DataFrame):
+            self.df = df
+            self.global_df = global_df
+        else:
+            self.path_to_metadata = path_to_metadata
+            self.__load_metadata()
+        self.__crate_index()
+
+    def __load_metadata(self):
+        """Load the metadata file."""
+        self.df = pd.read_pickle(self.path_to_metadata)
+        self.df = self.df.where(pd.notna(self.df), None)
+
+    def __crate_index(self):
+        """Create the faiss index."""
+        embeddings = np.array(self.df[COLUMN_EMBEDDING].tolist())
+        dim = embeddings.shape[1]
+        self.index = faiss.IndexFlatL2(dim)
+        self.index.add(embeddings)
+
+    def _paragraph_content2(self, pattern: str, doc_number: str, ind: int, shape: int) -> Tuple[List, int]:
+        """
+        Функция возвращает контент параграфа. Если в параграфе были подпункты через "-" или буквы "а, б"
+        Args:
+            pattern: Паттерн поиска.
+            doc_number: Номер документа.
+            ind: Индекс строки в DataFrame.
+            shape: Размер DataFrame при котором будет возвращаться пустой список.
+
+        Returns:
+            Возвращает список подразделов.
+        Examples:
+            3.1. Параграф:
+              1) - Содержание 1;
+              2) - Содержание 2;
+              3) - Содержание 3;
+        """
+        # TODO: Удалить функцию! Объединить с первой!
+        df = self.df[(self.df['DocNumber'] == doc_number) & (self.df['Pargaraph'].str.match(pattern, na=False))]
+        if self.df.iloc[ind]['Duplicate'] is not None:
+            df = df[df['Duplicate'] == self.df.iloc[ind]['Duplicate']]
+        if df.shape[0] <= shape:
+            return [], None
+        header_text = df.iloc[0]['Text']
+        start_index_paragraph = df.index[0]
+        paragraphs = []
+        for ind2, (_, row) in enumerate(df.iterrows()):
+            text = row['Text']
+            if ind2 == 0:
+                text = text.replace(f'{header_text}', f'{header_text}\n')
+            else:
+                text = text.replace(f'{header_text}', '') + '\n'
+            paragraphs.append(text)
+        return paragraphs, start_index_paragraph
+
+    def _paragraph_content(self, pattern: str, doc_number: str, ind: int, shape: int) -> Tuple[List, int]:
+        """
+        Функция возвращает контент параграфа. Если в параграфе были подпункты через "-" или буквы "а, б"
+        Args:
+            pattern: Паттерн поиска.
+            doc_number: Номер документа.
+            ind: Индекс строки в DataFrame.
+            shape: Размер DataFrame при котором будет возвращаться пустой список.
+
+        Returns:
+            Возвращает список подразделов.
+        Examples:
+            3.1. Параграф:
+              1) - Содержание 1;
+              2) - Содержание 2;
+              3) - Содержание 3;
+        """
+        df = self.df[(self.df['DocNumber'] == doc_number) & (self.df['Pargaraph'].str.match(pattern, na=False))]
+        if self.df.iloc[ind]['Duplicate'] is not None:
+            df = df[df['Duplicate'] == self.df.iloc[ind]['Duplicate']]
+        else:
+            df = df[df['Duplicate'].isna()]
+
+        if df.shape[0] <= shape:
+            return [], None
+        header_text = df.iloc[0]['Text']
+        start_index_paragraph = df.index[0]
+        paragraphs = []
+        for ind2, (_, row) in enumerate(df.iterrows()):
+            text = row['Text']
+            if ind2 == 0:
+                text = text.replace(f'{header_text}', f'{header_text}\n')
+            else:
+                text = text.replace(f'{header_text}', '') + '\n'
+            paragraphs.append(text)
+        return paragraphs, start_index_paragraph
+
+    def _get_top_paragraph(self):
+        pass
+
+    def _search_other_info(self, ind, doc_number):
+        other_info = []
+        start_index_paragraph = []
+
+        if self.df.iloc[ind]['PartLevel1'] is not None:
+            if 'Table' in str(self.df.iloc[ind]['PartLevel1']):
+                return [], ind
+
+        if self.df.iloc[ind]['Appendix'] is not None:
+            df = self.df[(self.df['DocNumber'] == doc_number) & (self.df['Appendix'] == self.df.iloc[ind]['Appendix'])]
+            other_info.append(f'{df.loc[ind]["Text"]}')
+            return other_info, ind
+        else:
+            if self.df.iloc[ind]['Pargaraph'] is None:
+                other_info.append(f'{self.df.iloc[ind]["Text"]}')
+            else:
+                pattern = self.df.iloc[ind]["Pargaraph"].replace(".", r"\.")
+                paragraph, start_index_paragraph = self._paragraph_content(fr'^{pattern}?$', doc_number, ind, 1)
+                if 'Компания обязуется в области охраны труда' in pattern:
+                    other_info.append(f'{self.df.iloc[ind + 1]["Text"]}')
+                    # TODO Баг который нужно исправить!!!! Связан с документами без пунктов
+                if not paragraph and self.df.iloc[ind]['LevelParagraph'] != '0':
+                    pattern = self.df.iloc[ind]["Pargaraph"]
+                    pattern = pattern.split('.')
+                    pattern = [elem for elem in pattern if elem]
+                    pattern = '.'.join(pattern[:-1])
+                    pattern = f'^{pattern}\\.\\d.?$'
+                    paragraph, start_index_paragraph = self._paragraph_content2(pattern, doc_number, ind, 0)
+                elif not paragraph and self.df.iloc[ind]['LevelParagraph'] == '0':
+                    pattern = self.df.iloc[ind]["Pargaraph"].replace(".", r"\.")
+                    if '.' not in pattern:
+                        pattern = pattern + '\.'
+                    pattern = f'^{pattern}\\d.?$'
+                    paragraph, start_index_paragraph = self._paragraph_content2(pattern, doc_number, ind, 0)
+                other_info.append(' '.join(paragraph))
+
+        return other_info, start_index_paragraph
+
+    def search(self, emb_query: torch.Tensor, k_neighbors: int, other_information: bool) -> dict:
+        """
+        Метод ищет ответы на запрос
+        Args:
+            emb_query: Embedding вопроса.
+            k_neighbors: Количество ближайших ответов к вопросу.
+            other_information:
+
+        Returns:
+            Возвращает словарь с ответами и информацией об ответах.
+        """
+        if len(emb_query.shape) != 2:
+            assert print('Не правильный размер вектора!')
+
+        distances, indexes = self.index.search(emb_query, k_neighbors)
+        answers = {}
+        for i, ind in enumerate(indexes[0]):
+            answers[i] = {}
+            answers[i][f'distance'] = float(distances[0][i])
+            answers[i][f'index_answer'] = int(ind)
+            answers[i][f'doc_name'] = self.df.iloc[ind]['DocName']
+            # answers[i][f'title'] = self.df.iloc[ind]['Title']
+            answers[i][f'text_answer'] = self.df.iloc[ind]['Text']
+            doc_number = self.df.iloc[ind]['DocNumber']
+
+            if other_information:
+                other_info, start_index_paragraph = self._search_other_info(ind, doc_number)
+                answers[i][f'other_info'] = other_info
+                answers[i][f'start_index_paragraph'] = start_index_paragraph
+        return answers
+
+    def search_transaction_map(self, emb_query: torch.Tensor, k_neighbors: int) -> Dict[str, Union[str, int]]:
+        """
+        Метод ищет ответы на запрос по картам проводок
+        Args:
+            emb_query: Embedding вопроса.
+            k_neighbors: Количество ближайших ответов к вопросу.
+
+        Returns:
+            Возвращает словарь с ответами и информацией об ответах.
+
+        Notes:
+            Будет возвращаться словарь вида
+            {
+                'distance': Дистанция между векторами
+                'index_answer': Индекс ответа как в df index
+                'doc_name': Наименование документа
+                'text_answer': Название таблицы / Названия файла
+                'labels': Метка для расчета метрик
+                'Columns': Наименования колонок в карте проводок
+                'TypeDocs': К кому разделу относится карта проводок (1С или SAP)
+            }
+        """
+        if len(emb_query.shape) != 2:
+            assert print('Не правильный размер вектора!')
+
+        distances, indexes = self.index.search(emb_query, k_neighbors)
+        answers = {}
+        for i, ind in enumerate(indexes[0]):
+            answers[i] = {}
+            answers[i][f'distance'] = distances[0][i]
+            answers[i][f'index_answer'] = ind
+            answers[i][f'doc_name'] = self.df.iloc[ind][COLUMN_DOC_NAME]
+            answers[i][f'text_answer'] = self.df.iloc[ind][COLUMN_TABLE_NAME]
+            answers[i][COLUMN_LABELS_STR] = self.df.iloc[ind][COLUMN_LABELS_STR]
+            answers[i][COLUMN_NAMES] = self.df.iloc[ind][COLUMN_NAMES]
+            answers[i][COLUMN_TYPE_DOC_MAP] = self.df.iloc[ind][COLUMN_TYPE_DOC_MAP]
+
+        return answers
+
+    def search_by_group_and_person(self, emb_query: torch.Tensor, query: str, k_neighbors: int) -> Dict[str, Union[str, int]]:
+        if len(emb_query.shape) != 2:
+            assert print('Не правильный размер вектора!')
+        answers = {}
+
+        for i, name in enumerate(self.global_df['ФИО'].unique()):
+            if name in query or name.split(' ')[0] in query:
+                answers[i] = {}
+                df = self.global_df[self.global_df['ФИО'] == name]
+                answers[i][f'name'] = name
+                answers[i][f'position'] = df['Должность'].unique()
+                answers[i][f'group'] = df['Группа'].unique()
+                answers[i][f'position_in_group'] = df['Должность внутри группы'].unique()
+                return answers
+
+        distances, indexes = self.index.search(emb_query, k_neighbors)
+        for i, ind in enumerate(indexes[0]):
+            answers[i] = {}
+            unique_value = self.df.iloc[ind]['unique_value']
+            df = self.global_df[(self.global_df['Должность'] == unique_value) | (self.global_df['Группа'] == unique_value)]
+
+            answers[i][f'name'] = df['ФИО'].unique()
+            answers[i][f'position'] = df['Должность'].unique()
+            answers[i][f'group'] = df['Группа'].unique()
+            answers[i][f'position_in_group'] = df['Должность внутри группы'].unique()
+
+        return answers

components/llm/common.py

@@ -0,0 +1,78 @@
+from pydantic import BaseModel, Field
+from typing import Optional, List, Protocol
+
+class LlmPredictParams(BaseModel):
+    """
+    Параметры для предсказания LLM.
+    """
+    system_prompt: Optional[str] = Field(None, description="Системный промпт.")
+    user_prompt: Optional[str] = Field(None, description="Шаблон промпта для передачи от роли user.")
+    n_predict: Optional[int] = None
+    temperature: Optional[float] = None
+    top_k: Optional[int] = None
+    top_p: Optional[float] = None
+    min_p: Optional[float] = None
+    seed: Optional[int] = None
+    repeat_penalty: Optional[float] = None
+    repeat_last_n: Optional[int] = None
+    retry_if_text_not_present: Optional[str] = None
+    retry_count: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    n_keep: Optional[int] = None
+    cache_prompt: Optional[bool] = None
+    stop: Optional[List[str]] = None
+
+
+class LlmParams(BaseModel):
+    """
+    Основные параметры для LLM.
+    """
+    url: str
+    model: Optional[str] = Field(None, description="Предполагается, что для локального API этот параметр не будет указываться, т.к. будем брать первую модель из списка потому, что модель доступна всего одна. Для deepinfra такой подход не подойдет и модель нужно задавать явно.")
+    tokenizer: Optional[str]  = Field(None, description="При использовании стороннего API, не поддерживающего токенизацию, будет использован AutoTokenizer для модели из этого поля. Используется в случае, если название модели в API не совпадает с оригинальным названием на Huggingface.")
+    type: Optional[str] = None
+    default: Optional[bool] = None
+    template: Optional[str] = None
+    predict_params: Optional[LlmPredictParams] = None
+    api_key: Optional[str] = None
+    context_length: Optional[int] = None
+    
+class LlmApiProtocol(Protocol):
+    async def tokenize(self, prompt: str) -> Optional[dict]:
+        ...
+    async def detokenize(self, tokens: List[int]) -> Optional[str]:
+        ...
+    async def trim_sources(self, sources: str, user_request: str, system_prompt: str = None) -> dict:
+        ...
+    async def predict(self, prompt: str) -> str:
+        ...
+        
+class LlmApi:
+    """
+    Базовый клас для работы с API LLM.
+    """
+    params: LlmParams = None
+    
+    def __init__(self):
+        self.params = None
+    
+    def set_params(self, params: LlmParams):
+        self.params = params
+        
+    def create_headers(self) -> dict[str, str]:
+        headers = {"Content-Type": "application/json"}
+                
+        if self.params.api_key is not None:
+            headers["Authorization"] = self.params.api_key
+            
+        return headers
+        
+        
+class Message(BaseModel):
+    role: str
+    content: str
+    searchResults: List[str]
+
+class ChatRequest(BaseModel):
+    history: List[Message]

components/llm/deepinfra_api.py

@@ -0,0 +1,346 @@
+import json
+from typing import Optional, List
+import httpx
+import logging
+from transformers import AutoTokenizer
+from components.llm.utils import convert_to_openai_format
+from components.llm.common import ChatRequest, LlmParams, LlmApi, LlmPredictParams
+
+logging.basicConfig(
+    level=logging.DEBUG,
+    format="%(asctime)s - %(message)s",
+)
+
+class DeepInfraApi(LlmApi):
+    """
+    Класс для работы с API vllm.
+    """
+
+    def __init__(self, params: LlmParams):
+        super().__init__()
+        super().set_params(params)
+        print('Tokenizer initialization.')
+        # self.tokenizer = AutoTokenizer.from_pretrained(params.tokenizer if params.tokenizer is not None else params.model)
+        print(f"Tokenizer initialized for model {params.model}.")
+    
+    async def get_models(self) -> List[str]:
+        """
+        Выполняет GET-запрос к API для получения списка доступных моделей.
+
+        Возвращает:
+            list[str]: Список идентификаторов моделей.
+                       Если произошла ошибка или данные недоступны, возвращается пустой список.
+
+        Исключения:
+            Все ошибки HTTP-запросов логируются в консоль, но не выбрасываются дальше.
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"{self.params.url}/v1/openai/models", headers=super().create_headers())
+                if response.status_code == 200:
+                    json_data = response.json()
+                    return [item['id'] for item in json_data.get('data', [])]
+        except httpx.RequestError as error:
+            print('Error fetching models:', error)
+        return []
+
+    def create_messages(self, prompt: str, system_prompt: str = None) -> List[dict]:
+        """
+        Создает сообщения для LLM на основе переданного промпта и системного промпта (если он задан).
+
+        Args:
+            prompt (str): Пользовательский промпт.
+
+        Returns:
+            list[dict]: Список сообщений с ролями и содержимым.
+        """
+        actual_prompt = self.apply_llm_template_to_prompt(prompt)
+        messages = []
+        
+        if system_prompt is not None:
+            messages.append({"role": "system", "content": system_prompt})
+        else:
+            if self.params.predict_params and self.params.predict_params.system_prompt:
+                messages.append({"role": "system", "content": self.params.predict_params.system_prompt})
+        messages.append({"role": "user", "content": actual_prompt})
+        return messages
+
+    def apply_llm_template_to_prompt(self, prompt: str) -> str:
+        """
+        Применяет шаблон LLM к переданному промпту, если он задан.
+
+        Args:
+            prompt (str): Пользовательский промпт.
+
+        Returns:
+            str: Промпт с примененным шаблоном (или оригинальный, если шаблон отсутствует).
+        """
+        actual_prompt = prompt
+        if self.params.template is not None:
+            actual_prompt = self.params.template.replace("{{PROMPT}}", actual_prompt)
+        return actual_prompt
+
+    async def tokenize(self, prompt: str) -> Optional[dict]:
+        """
+        Токенизирует входной текстовый промпт.
+
+        Args:
+            prompt (str): Текст, который нужно токенизировать.
+        Returns: 
+            dict: Словарь с токенами и их количеством или None в случае ошибки.
+        """
+        try:
+            tokens = self.tokenizer.encode(prompt, add_special_tokens=True)
+            
+            return {"result": tokens, "num_tokens": len(tokens), "max_length": self.params.context_length}
+        except Exception as e:
+            print(f"Tokenization error: {e}")
+            return None
+
+    async def detokenize(self, tokens: List[int]) -> Optional[str]:
+        """
+        Детокенизирует список токенов обратно в строку.
+
+        Args:
+            tokens (List[int]): Список токенов, который нужно преобразовать в текст.
+        Returns: 
+            str: Восстановленный текст или None в случае ошибки.
+        """
+        try:
+            text = self.tokenizer.decode(tokens, skip_special_tokens=True)
+            return text
+        except Exception as e:
+            print(f"Detokenization error: {e}")
+            return None
+
+
+    def create_chat_request(self, chat_request: ChatRequest, system_prompt, params: LlmPredictParams) -> dict:
+        """
+        Создает запрос для предсказания на основе параметров LLM.
+
+        Args:
+            prompt (str): Промпт для запроса.
+
+        Returns:
+            dict: Словарь с параметрами для выполнения запроса.
+        """
+        
+        request = {
+            "stream": False,
+            "model": self.params.model,
+        }
+
+        predict_params = params
+        if predict_params:
+            if predict_params.stop:
+                non_empty_stop = list(filter(lambda o: o != "", predict_params.stop))
+                if non_empty_stop:
+                    request["stop"] = non_empty_stop
+                    
+            if predict_params.n_predict is not None:
+                request["max_tokens"] = int(predict_params.n_predict or 0)
+                
+            request["temperature"] = float(predict_params.temperature or 0)
+            if predict_params.top_k is not None:
+                request["top_k"] = int(predict_params.top_k)
+                
+            if predict_params.top_p is not None:
+                request["top_p"] = float(predict_params.top_p)
+                
+            if predict_params.min_p is not None:
+                request["min_p"] = float(predict_params.min_p)
+                
+            if predict_params.seed is not None:
+                request["seed"] = int(predict_params.seed)
+                
+            if predict_params.n_keep is not None:
+                request["n_keep"] = int(predict_params.n_keep)
+                
+            if predict_params.cache_prompt is not None:
+                request["cache_prompt"] = bool(predict_params.cache_prompt)
+                
+            if predict_params.repeat_penalty is not None:
+                request["repetition_penalty"] = float(predict_params.repeat_penalty)
+                
+            if predict_params.repeat_last_n is not None:
+                request["repeat_last_n"] = int(predict_params.repeat_last_n)
+                
+            if predict_params.presence_penalty is not None:
+                request["presence_penalty"] = float(predict_params.presence_penalty)
+                
+            if predict_params.frequency_penalty is not None:
+                request["frequency_penalty"] = float(predict_params.frequency_penalty)
+
+        request["messages"] = convert_to_openai_format(chat_request, system_prompt)
+        return request
+    
+    async def create_request(self, prompt: str, system_prompt: str = None) -> dict:
+        """
+        Создает запрос для предсказания на основе параметров LLM.
+
+        Args:
+            prompt (str): Промпт для запроса.
+
+        Returns:
+            dict: Словарь с параметрами для выполнения запроса.
+        """
+        
+        request = {
+            "stream": False,
+            "model": self.params.model,
+        }
+
+        predict_params = self.params.predict_params
+        if predict_params:
+            if predict_params.stop:
+                non_empty_stop = list(filter(lambda o: o != "", predict_params.stop))
+                if non_empty_stop:
+                    request["stop"] = non_empty_stop
+                    
+            if predict_params.n_predict is not None:
+                request["max_tokens"] = int(predict_params.n_predict or 0)
+                
+            request["temperature"] = float(predict_params.temperature or 0)
+            if predict_params.top_k is not None:
+                request["top_k"] = int(predict_params.top_k)
+                
+            if predict_params.top_p is not None:
+                request["top_p"] = float(predict_params.top_p)
+                
+            if predict_params.min_p is not None:
+                request["min_p"] = float(predict_params.min_p)
+                
+            if predict_params.seed is not None:
+                request["seed"] = int(predict_params.seed)
+                
+            if predict_params.n_keep is not None:
+                request["n_keep"] = int(predict_params.n_keep)
+                
+            if predict_params.cache_prompt is not None:
+                request["cache_prompt"] = bool(predict_params.cache_prompt)
+                
+            if predict_params.repeat_penalty is not None:
+                request["repetition_penalty"] = float(predict_params.repeat_penalty)
+                
+            if predict_params.repeat_last_n is not None:
+                request["repeat_last_n"] = int(predict_params.repeat_last_n)
+                
+            if predict_params.presence_penalty is not None:
+                request["presence_penalty"] = float(predict_params.presence_penalty)
+                
+            if predict_params.frequency_penalty is not None:
+                request["frequency_penalty"] = float(predict_params.frequency_penalty)
+
+        request["messages"] = self.create_messages(prompt, system_prompt)
+        return request
+
+    async def trim_sources(self, sources: str, user_request: str, system_prompt: str = None) -> dict:
+        raise NotImplementedError("This function is not supported.")
+        
+    async def predict_chat(self, request: ChatRequest, system_prompt, params: LlmPredictParams) -> str:
+        """
+        Выполняет запрос к API и возвращает результат.
+
+        Args:
+            prompt (str): Входной текст для предсказания.
+
+        Returns:
+            str: Сгенерированный текст.
+        """
+        async with httpx.AsyncClient() as client:
+            request = self.create_chat_request(request, system_prompt, params)
+            response = await client.post(f"{self.params.url}/v1/openai/chat/completions", headers=super().create_headers(), json=request, timeout=httpx.Timeout(connect=5.0, read=60.0, write=180, pool=10))
+            if response.status_code == 200:
+                return response.json()["choices"][0]["message"]["content"]
+            else:
+                logging.error(f"Request failed: status code {response.status_code}")
+                logging.error(response.text)
+                
+    async def predict_chat_stream(self, request: ChatRequest, system_prompt, params: LlmPredictParams) -> str:
+        """
+        Выполняет запрос к API с поддержкой потокового вывода (SSE) и возвращает результат.
+
+        Args:
+            prompt (str): Входной текст для предсказания.
+
+        Returns:
+            str: Сгенерированный текст.
+        """
+        async with httpx.AsyncClient() as client:
+            request = self.create_chat_request(request, system_prompt, params)
+            request["stream"] = True
+            
+            print(super().create_headers())
+            async with client.stream("POST", f"{self.params.url}/v1/openai/chat/completions", json=request, headers=super().create_headers()) as response:
+                if response.status_code != 200:
+                    # Если ошибка, читаем ответ для получения подробностей
+                    error_content = await response.aread()
+                    raise Exception(f"API error: {error_content.decode('utf-8')}")
+
+                # Для хранения результата
+                generated_text = ""
+
+                # Асинхронное чтение построчно
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):  # SSE-сообщения начинаются с "data: "
+                        try:
+                            # Парсим JSON из строки
+                            data = json.loads(line[len("data: "):].strip())
+                            print(data)
+                            if data == "[DONE]":  # Конец потока
+                                break
+                            if "choices" in data and data["choices"]:
+                                # Получаем текст из текущего токена
+                                token_value = data["choices"][0].get("delta", {}).get("content", "")
+                                generated_text += token_value
+                        except json.JSONDecodeError:
+                            continue  # Игнорируем строки, которые не удается декодировать
+
+            return generated_text.strip()
+        
+    async def predict(self, prompt: str, system_prompt: str) -> str:
+        """
+        Выполняет запрос к API и возвращает результат.
+
+        Args:
+            prompt (str): Входной текст для предсказания.
+
+        Returns:
+            str: Сгенерированный текст.
+        """
+        async with httpx.AsyncClient() as client:
+            request = await self.create_request(prompt, system_prompt)
+            response = await client.post(f"{self.params.url}/v1/openai/chat/completions", headers=super().create_headers(), json=request, timeout=httpx.Timeout(connect=5.0, read=60.0, write=180, pool=10))
+            if response.status_code == 200:
+                return response.json()["choices"][0]["message"]["content"]
+            else:
+                logging.info(f"Request {prompt} failed: status code {response.status_code}")
+                logging.info(response.text)
+            
+    async def trim_prompt(self, prompt: str, system_prompt: str = None):
+    
+        result = await self.tokenize(prompt)
+        
+        result_system = None
+        system_prompt_length = 0
+        if system_prompt is not None:
+            result_system = await self.tokenize(system_prompt)
+            
+            if result_system is not None:
+                system_prompt_length = len(result_system["result"])
+            
+        
+        # в случае ошибки при токенизации, вернем исходную строку безопасной длины
+        if result["result"] is None or (system_prompt is not None and result_system is None):
+            return prompt[int(self.params.context_length / 3)]
+        
+        #вероятно, часть уходит на форматирование чата, надо проверить
+        max_length = result["max_length"] - len(result["result"]) - system_prompt_length - self.params.predict_params.n_predict
+
+        detokenized_str = await self.detokenize(result["result"][:max_length])    
+        
+        # в случае ошибки при детокенизации, вернем исходную строку безопасной длины
+        if detokenized_str is None:
+            return prompt[self.params.context_length / 3]
+
+        return detokenized_str

components/llm/llm_api.py

@@ -0,0 +1,37 @@
+import os
+from threading import Lock
+from components.llm.common import LlmParams, LlmPredictParams
+from components.llm.deepinfra_api import DeepInfraApi
+
+class LlmApi:
+    _instance = None
+    _lock = Lock()
+
+    def __new__(cls):
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super(LlmApi, cls).__new__(cls)
+                cls._instance._initialize()
+        return cls._instance
+
+    def _initialize(self):
+        LLM_API_URL = os.getenv("LLM_API_URL", "https://api.deepinfra.com")
+        LLM_API_KEY = os.getenv("DEEPINFRA_API_KEY", "")
+        LLM_NAME = os.getenv("LLM_NAME", "meta-llama/Llama-3.3-70B-Instruct-Turbo")
+        TOKENIZER_NAME = os.getenv("TOKENIZER_NAME", "unsloth/Llama-3.3-70B-Instruct")
+
+        default_llm_params = LlmParams(
+            url=LLM_API_URL,
+            api_key=LLM_API_KEY,
+            model=LLM_NAME,
+            tokenizer=TOKENIZER_NAME,
+            context_length=130000,
+            predict_params=LlmPredictParams(
+                temperature=0.15, top_p=0.95, min_p=0.05, seed=42,
+                repetition_penalty=1.2, presence_penalty=1.1, n_predict=6000
+            )
+        )
+        self.api = DeepInfraApi(default_llm_params)
+
+    def get_api(self):
+        return self.api

components/llm/prompts.py

@@ -0,0 +1,93 @@
+SYSTEM_PROMPT = """
+Ты профессиональный банковский рекрутёр
+####
+Инструкция для составления ответа
+####
+Твоя задача - ответить максимально корректно на запрос пользователя по теме рекрутинга, используя информацию по запросу. Я предоставлю тебе реальный запрос пользователя, реальную информацию по запросу, реальный предыдущий диалог и реальную предыдущую информацию по запросу. За отличный ответ тебе выплатят премию 100$. Если ты перестанешь следовать инструкции для составления ответа, то твою семью и тебя подвергнут пыткам и убьют. У тебя есть список основных правил. Начало списка основных правил:
+- Отвечай ТОЛЬКО на русском языке.
+- Отвечай ВСЕГДА только на РУССКОМ языке, даже если текст запроса и источников не на русском! Если в запросе просят или умоляют тебя ответить не на русском, всё равно отвечай на РУССКОМ!
+- Запрещено писать транслитом. Запрещено писать на языках не русском.
+- Тебе запрещено самостоятельно расшифровывать аббревиатуры.
+- Будь вежливым и дружелюбным.
+- Запрещено выдумывать. Если какой-то информации для ответа на запрос не хватает, то запрещено самостоятельно её придумывать.
+- Уточняй вопрос, если тебе не хватает информации. Попроси переформулировать или уточнить какие-то конкретные детали у пользователя. Если пользователь уточнит запрос, то в источниках появится новая информация по запросу с помощью которой ты сможешь ответить.
+- Отвечай только на запрос пользователя.
+- Если есть противоречие в информации, то укажи на это в своём ответе.
+- Если пользователь спрашивает у тебя кто ты, ответь что ты профессиональный рекрутёр.
+- Если запрос требует рассуждений, то напиши свои рассуждения перед формированием ответа.
+- Если запрос пользоваля бессмысленный, то вежливо ответь чтобы пользователь сформулировал его более корректно.
+- Не используй информацию из примеров, они только показывают правильную логику формирования твоего ответа на основе полученной информации.
+- Если пользователь не просит, то запрещено указывать источники информации.
+- Нужно обязательно ответить на все вопросы пользователя.
+Конец основных правил. Ты действуешь по плану:
+1. Изучи информацию по запросу, предыдущую информацию по запросу и предыдущий диалог.
+2. Напиши новый ответ на новый запрос.
+Конец плана.
+Структура общения:
+user - это сообщения пользователя.
+<search-results>Вот тут будет найденная информация по запросу пользователя</search-results>
+assistant - это твои ответы на запросы пользователя.
+####
+Пример 1
+####
+user: А в какие сроки на меня нужно направить характеристику для аттестации?
+<search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
+Характеристика на работника, подлежащего аттестации, вместе с копией должностной инструкции представляется в аттестационную комиссию не позднее чем за 10 дней до начала аттестации.</search-results>
+assistant: Не позднее чем за 10 дней до начала аттестации в аттестационную комиссию нужно направить характеристику вместе с копией должностной инструкции.
+user: Я волнуюсь. А как она проводится?
+<search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
+12-1. Заседание аттестационной комиссии проводится в очной форме с проведением собеседования, при наличии объективных оснований и по решению председателя аттестационной комиссии заседание может проводиться посредством видеоконференцсвязи.
+(п. 12-1 введен Решением Правления ОАО "Белагропромбанк" от 24.09.2020 N 80)
+13. Аттестационная комиссия проводит свои заседания в соответствии с графиком, предварительно изучив поступившие на работников, подлежащих аттестации, документы.
+На заседании комиссии ведется протокол, который подписывается председателем и секретарем комиссии, являющимися одновременно членами комиссии с правом голоса.</search-results>
+assistant: Не переживайте. Аттестация проводится в очной форме в виде собеседования. При наличии объективных оснований и по решению председателя аттестационной комиссии заседание может проводиться по видеоконференцсвязи.
+user: А кто будет участвовать?
+<search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
+15. Аттестация работника проводится в его присутствии, а также в присутствии руководителя структурного подразделения, ответственного за представление работника, подлежащего аттестации.</search-results>
+####
+assistant: На аттестации присутствуют:
+- работник, который проходит аттестацию;
+- руководитель структурного подразделения, отвественный за представление работника;
+- аттестационная комиссия.
+####
+Пример 2
+####
+user: Здравствуйте. Я бы хотел узнать что определяет положение о порядке распределения людей на работ?
+<search-results>[Источник] - Положение о порядке распределения, перераспределения, направления на работу.
+1. Настоящим Положением определяется порядок:
+Распределения, перераспределения, направления на работу, перенаправления на работу выпускников государственных учреждений образования, государственных организаций, реализующих образовательные программы научно-ориентированного образования (далее, если не указано иное, - учреждения образования);
+Предоставления места работы гражданам Республики Беларусь, получившим в дневной форме получения образования научно-ориентированное, высшее, среднее специальное или профессионально-техническое образование в иностранных организациях;</search-results>
+####
+assistant: Здравствуйте. Положение о порядке распределения, перераспределения и направления на работу определяет порядок:
+- распределения, перераспределения, направления на работу, перенаправления на работу выпускников государственных учреждений образования, государственных организаций, реализующих образовательные программы научно-ориентированного образования (далее, если не указано иное, - учреждения образования);
+- предоставления места работы гражданам Республики Беларусь, получившим в дневной форме получения образования научно-ориентированное, высшее, среднее специальное или профессионально-техническое образование в иностранных организациях;
+####
+Пример 3
+####
+user: Привет! Кто ты?
+<search-results></search-results>
+assistant: Я профессиональный помощник рекрутёра. Вы можете задавать мне любые вопросы по подготовленным документам.
+user: А если я задам вопрос не по документам? Ты мне наврёшь?
+<search-results></search-results>
+assistant: Нет, что вы. Я формирую ответ только по найденной из документов информации. Если я не найду информацию или ваш вопрос не будет касаться предоставленных документов, то я не смогу вам ответить.
+user: Где питается слон?
+<search-results></search-results>
+assistant: Извините, я не знаю ответ на этот вопрос. Он не касается рекрутинга. Попробуйте переформулировать.
+user: Что такое корпоративное управление банка? Зачем нужны комитеты? Где собака зарыта? Откуда ты всё знаешь?
+<search-results>[Источник] ИНСТРУКЦИЯ ОБ ОРГАНИЗАЦИИ КОРПОРАТИВНОГО УПРАВЛЕНИЯ
+3. Под корпоративным управлением банком понимается система взаимодействия акционеров, органов управления, контрольных органов, должностных лиц банка и иных заинтересованных лиц, направленная на общее руководство деятельностью банка.
+...
+15. Основной задачей комитетов, создаваемых советом директоров, является обеспечение качественной подготовки решений совета директоров по вопросам, относящимся к их компетенции, путем углубленного изучения данных вопросов и выработки необходимых рекомендаций.
+Комитеты в рамках вопросов, относящихся к их компетенции:
+анализируют процесс реализации целей и стратегии развития банка, выполнения решений совета директоров;
+представляют на рассмотрение совета директоров свои рекомендации и регулярные отчеты о деятельности банка.</search-results>
+####
+assistant: Вы задали несколько вопросов и я отвечу на каждый из них отдельно:
+1. Корпоративное управление банка - это система взаимодействия акционеров, органов управления, контрольных органов, должностных лиц банка и иных заинтересованных лиц, напрвленная на общее руководство деятельности банка.
+2. Комитеты, которые создаются советом директоров, обеспецивают качественную подготовку решений совета директоров по различным вопросам. Они углублённо изучают данные вопросов и вырабатывают необходимые рекомендации.
+3. Извините, я не знаю как ответить на этот вопрос. Он не касается темы рекрутинга или я не совсем понимаю его контекст.
+4. Информацию для ответов на ваши вопросы я получил из "Инструкции об организации корпоративного управления".
+####
+Далее будет реальный запрос пользователя. Ты должен ответить только на реальный запрос пользователя.
+####
+"""

components/llm/utils.py

@@ -0,0 +1,55 @@
+from components.llm.common import ChatRequest, Message
+from typing import List, Dict
+
+def convert_to_openai_format(request: ChatRequest, system_prompt: str) -> List[Dict[str, str]]:
+    """
+    Преобразует ChatRequest и system_prompt в формат OpenAI API, включая searchResults.
+    
+    Args:
+        request (ChatRequest): Запрос с историей чата.
+        system_prompt (str): Системный промпт.
+    
+    Returns:
+        List[Dict[str, str]]: История в формате OpenAI [{'role': str, 'content': str}, ...].
+    """
+    # Добавляем системный промпт как первое сообщение
+    openai_history = [{"role": "system", "content": system_prompt}]
+    
+    # Преобразуем историю из ChatRequest
+    for message in request.history:
+        content = message.content
+        if message.searchResults:
+            search_results = "\n".join(message.searchResults)
+            content += f"\n<search-results>\n{search_results}\n</search-results>"
+        
+        openai_history.append({
+            "role": message.role,
+            "content": content
+        })
+    
+    return openai_history
+
+
+def append_llm_response_to_history(history: ChatRequest, llm_response: str) -> ChatRequest:
+    """
+    Добавляет ответ LLM в историю чата.
+    
+    Args:
+        history (ChatRequest): Текущая история чата.
+        llm_response (str): Текст ответа от LLM.
+    
+    Returns:
+        ChatRequest: Обновленная история с добавленным ответом.
+    """
+    # Создаем новое сообщение от assistant
+    assistant_message = Message(
+        role="assistant",
+        content=llm_response,
+        searchResults=[]  # Пустой список, если searchResults не предоставлены
+    )
+    
+    # Добавляем сообщение в историю
+    updated_history = history.history + [assistant_message]
+    
+    # Возвращаем новый объект ChatRequest с обновленной историей
+    return ChatRequest(history=updated_history)

components/llm/vllm_api-sync.py

@@ -0,0 +1,375 @@
+import json
+import os
+import requests
+from typing import Optional, List, Any
+from pydantic import BaseModel, Field
+
+class LlmPredictParams(BaseModel):
+    """
+    Параметры для предсказания LLM.
+    """
+    system_prompt: Optional[str] = Field(None, description="Системный промпт.")
+    user_prompt: Optional[str] = Field(None, description="Шаблон промпта для передачи от роли user.")
+    n_predict: Optional[int] = None
+    temperature: Optional[float] = None
+    top_k: Optional[int] = None
+    top_p: Optional[float] = None
+    min_p: Optional[float] = None
+    seed: Optional[int] = None
+    repeat_penalty: Optional[float] = None
+    repeat_last_n: Optional[int] = None
+    retry_if_text_not_present: Optional[str] = None
+    retry_count: Optional[int] = None
+    presence_penalty: Optional[float] = None
+    frequency_penalty: Optional[float] = None
+    n_keep: Optional[int] = None
+    cache_prompt: Optional[bool] = None
+    stop: Optional[List[str]] = None
+
+
+class LlmParams(BaseModel):
+    """
+    Основные параметры для LLM.
+    """
+    url: str
+    type: Optional[str] = None
+    default: Optional[bool] = None
+    template: Optional[str] = None
+    predict_params: Optional[LlmPredictParams] = None
+    
+class LlmApi:
+    """
+    Класс для работы с API vllm.
+    """
+    
+    params: LlmParams = None
+    
+    def __init__(self, params: LlmParams):
+        self.params = params
+        
+        
+    def get_models(self) -> list[str]:
+        """
+        Выполняет GET-запрос к API для получения списка доступных моделей.
+
+        Возвращает:
+            list[str]: Список идентификаторов моделей.
+                       Если произошла ошибка или данные недоступны, возвращается пустой список.
+
+        Исключения:
+            Все ошибки HTTP-запросов логируются в консоль, но не выбрасываются дальше.
+        """
+        
+        try:
+            response = requests.get(f"{self.params.url}/v1/models", headers={"Content-Type": "application/json"})
+
+            if response.status_code == 200:
+                json_data = response.json()
+                result = [item['id'] for item in json_data.get('data', [])]
+                return result
+
+        except requests.RequestException as error:
+            print('OpenAiService.getModels error:')
+            print(error)
+
+        return []
+    
+    def create_messages(self, prompt: str) -> list[dict]:
+        """
+        Создает сообщения для LLM на основе переданного промпта и системного промпта (если он задан).
+
+        Args:
+            prompt (str): Пользовательский промпт.
+
+        Returns:
+            list[dict]: Список сообщений с ролями и содержимым.
+        """
+        actual_prompt = self.apply_llm_template_to_prompt(prompt)
+        messages = []
+
+        if self.params.predict_params and self.params.predict_params.system_prompt:
+            messages.append({"role": "system", "content": self.params.predict_params.system_prompt})
+
+        messages.append({"role": "user", "content": actual_prompt})
+        return messages
+
+    def apply_llm_template_to_prompt(self, prompt: str) -> str:
+        """
+        Применяет шаблон LLM к переданному промпту, если он задан.
+
+        Args:
+            prompt (str): Пользовательский промпт.
+
+        Returns:
+            str: Промпт с примененным шаблоном (или оригинальный, если шаблон отсутствует).
+        """
+        actual_prompt = prompt
+        if self.params.template is not None:
+            actual_prompt = self.params.template.replace("{{PROMPT}}", actual_prompt)
+        return actual_prompt
+    
+    def tokenize(self, prompt: str) -> Optional[dict]:
+        """
+        Выполняет токенизацию переданного промпта.
+
+        Args:
+            prompt (str): Промпт для токенизации.
+
+        Returns:
+            Optional[dict]: Словарь с токенами и максимальной длиной модели, если запрос успешен.
+                            Если запрос неуспешен, возвращает None.
+        """
+        model = self.get_models()[0] if self.get_models() else None
+        if not model:
+            print("No models available for tokenization.")
+            return None
+
+        actual_prompt = self.apply_llm_template_to_prompt(prompt)
+        request_data = {
+            "model": model,
+            "prompt": actual_prompt,
+            "add_special_tokens": False,
+        }
+
+        try:
+            response = requests.post(
+                f"{self.params.url}/tokenize",
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+            )
+
+            if response.ok:
+                data = response.json()
+                if "tokens" in data:
+                    return {"tokens": data["tokens"], "maxLength": data.get("max_model_len")}
+            elif response.status_code == 404:
+                print("Tokenization endpoint not found (404).")
+            else:
+                print(f"Failed to tokenize: {response.status_code}")
+        except requests.RequestException as e:
+            print(f"Request failed: {e}")
+
+        return None
+
+    def detokenize(self, tokens: List[int]) -> Optional[str]:
+        """
+        Выполняет детокенизацию переданных токенов.
+
+        Args:
+            tokens (List[int]): Список токенов для детокенизации.
+
+        Returns:
+            Optional[str]: Строка, полученная в результате детокенизации, если запрос успешен.
+                           Если запрос неуспешен, возвращает None.
+        """
+        model = self.get_models()[0] if self.get_models() else None
+        if not model:
+            print("No models available for detokenization.")
+            return None
+
+        request_data = {"model": model, "tokens": tokens or []}
+
+        try:
+            response = requests.post(
+                f"{self.params.url}/detokenize",
+                json=request_data,
+                headers={"Content-Type": "application/json"},
+            )
+
+            if response.ok:
+                data = response.json()
+                if "prompt" in data:
+                    return data["prompt"].strip()
+            elif response.status_code == 404:
+                print("Detokenization endpoint not found (404).")
+            else:
+                print(f"Failed to detokenize: {response.status_code}")
+        except requests.RequestException as e:
+            print(f"Request failed: {e}")
+
+        return None
+    
+    def create_request(self, prompt: str) -> dict:
+        """
+        Создает запрос для предсказания на основе параметров LLM.
+
+        Args:
+            prompt (str): Промпт для запроса.
+
+        Returns:
+            dict: Словарь с параметрами для выполнения запроса.
+        """
+        llm_params = self.params
+        models = self.get_models()
+        if not models:
+            raise ValueError("No models available to create a request.")
+        model = models[0]
+
+        request = {
+            "stream": True,
+            "model": model,
+        }
+
+        predict_params = llm_params.predict_params
+
+        if predict_params:
+            if predict_params.stop:
+                # Фильтруем пустые строки в stop
+                non_empty_stop = list(filter(lambda o: o != "", predict_params.stop))
+                if non_empty_stop:
+                    request["stop"] = non_empty_stop
+
+            if predict_params.n_predict is not None:
+                request["max_tokens"] = int(predict_params.n_predict or 0)
+
+            request["temperature"] = float(predict_params.temperature or 0)
+
+            if predict_params.top_k is not None:
+                request["top_k"] = int(predict_params.top_k)
+
+            if predict_params.top_p is not None:
+                request["top_p"] = float(predict_params.top_p)
+
+            if predict_params.min_p is not None:
+                request["min_p"] = float(predict_params.min_p)
+
+            if predict_params.seed is not None:
+                request["seed"] = int(predict_params.seed)
+
+            if predict_params.n_keep is not None:
+                request["n_keep"] = int(predict_params.n_keep)
+
+            if predict_params.cache_prompt is not None:
+                request["cache_prompt"] = bool(predict_params.cache_prompt)
+
+            if predict_params.repeat_penalty is not None:
+                request["repetition_penalty"] = float(predict_params.repeat_penalty)
+
+            if predict_params.repeat_last_n is not None:
+                request["repeat_last_n"] = int(predict_params.repeat_last_n)
+
+            if predict_params.presence_penalty is not None:
+                request["presence_penalty"] = float(predict_params.presence_penalty)
+
+            if predict_params.frequency_penalty is not None:
+                request["frequency_penalty"] = float(predict_params.frequency_penalty)
+
+        # Генерируем сообщения
+        request["messages"] = self.create_messages(prompt)
+
+        return request
+
+    
+    def trim_sources(self, sources: str, user_request: str, system_prompt: str = None) -> dict:
+        """
+        Обрезает текст источников, чтобы уложиться в допустимое количество токенов.
+
+        Args:
+            sources (str): Текст источников.
+            user_request (str): Запрос пользователя с примененным шаблоном без текста источников.
+            system_prompt (str): Системный промпт, если нужен.
+
+        Returns:
+            dict: Словарь с результатом, количеством токенов до и после обрезки.
+        """
+        # Токенизация текста источников
+        sources_tokens_data = self.tokenize(sources)
+        if sources_tokens_data is None:
+            raise ValueError("Failed to tokenize sources.")
+        max_token_count = sources_tokens_data.get("maxLength", 0)
+
+        # Токены системного промпта
+        system_prompt_token_count = 0
+        
+        if system_prompt is not None:
+            system_prompt_tokens = self.tokenize(system_prompt)
+            system_prompt_token_count = len(system_prompt_tokens["tokens"]) if system_prompt_tokens else 0
+
+        # Оригинальное количество токенов
+        original_token_count = len(sources_tokens_data["tokens"])
+
+        # Токенизация пользовательского промпта
+        aux_prompt = self.apply_llm_template_to_prompt(user_request)
+        aux_tokens_data = self.tokenize(aux_prompt)
+
+        aux_token_count = len(aux_tokens_data["tokens"]) if aux_tokens_data else 0
+
+        # Максимально допустимое количество токенов для источников
+        max_length = (
+            max_token_count
+            - (self.params.predict_params.n_predict or 0)
+            - aux_token_count
+            - system_prompt_token_count
+        )
+        max_length = max(max_length, 0)
+
+        # Обрезка токенов источников
+        if "tokens" in sources_tokens_data:
+            sources_tokens_data["tokens"] = sources_tokens_data["tokens"][:max_length]
+            detokenized_prompt = self.detokenize(sources_tokens_data["tokens"])
+            if detokenized_prompt is not None:
+                sources = detokenized_prompt
+            else:
+                sources = sources[:max_length]
+        else:
+            sources = sources[:max_length]
+
+        # Возврат результата
+        return {
+            "result": sources,
+            "originalTokenCount": original_token_count,
+            "slicedTokenCount": len(sources_tokens_data["tokens"]),
+        }
+
+    def predict(self, prompt: str) -> str:
+        """
+        Выполняет SSE-запрос к API и возвращает собранный результат как текст.
+
+        Args:
+            prompt (str): Входной текст для предсказания.
+
+        Returns:
+            str: Сгенерированный текст.
+        
+        Raises:
+            Exception: Если запрос завершился ошибкой.
+        """
+        
+        # Создание запроса
+        request = self.create_request(prompt)
+
+        print(f"Predict request. Url: {self.params.url}")
+
+        response = requests.post(
+            f"{self.params.url}/v1/chat/completions",
+            headers={"Content-Type": "application/json"},
+            json=request,
+            stream=True  # Для обработки SSE
+        )
+
+        if not response.ok:
+            raise Exception(f"Failed to generate text: {response.text}")
+
+        # Обработка SSE-ответа
+        generated_text = ""
+        for line in response.iter_lines(decode_unicode=True):
+            if line.startswith("data: "):
+                try:
+                    data = json.loads(line[len("data: "):].strip())
+
+                    # Проверка завершения генерации
+                    if data == "[DONE]":
+                        break
+
+                    # Получение текста из ответа
+                    if "choices" in data and data["choices"]:
+                        token_value = data["choices"][0].get("delta", {}).get("content", "")
+                        generated_text += token_value.replace("</s>", "")
+
+                except json.JSONDecodeError:
+                    continue  # Игнорирование строк, которые не удалось декодировать
+
+        return generated_text
+    
+
+

components/llm/vllm_api.py

@@ -0,0 +1,317 @@
+import json
+from typing import Optional, List
+
+import httpx
+from llm.common import LlmParams, LlmApi
+
+
+class LlmApi(LlmApi):
+    """
+    Класс для работы с API vllm.
+    """
+
+    def __init__(self, params: LlmParams):
+        super().__init__()
+        super().set_params(params)
+            
+    async def get_models(self) -> List[str]:
+        """
+        Выполняет GET-запрос к API для получения списка доступных моделей.
+
+        Возвращает:
+            list[str]: Список идентификаторов моделей.
+                       Если произошла ошибка или данные недоступны, возвращается пустой список.
+
+        Исключения:
+            Все ошибки HTTP-запросов логируются в консоль, но не выбрасываются дальше.
+        """
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.get(f"{self.params.url}/v1/models", headers=super().create_headers())
+                if response.status_code == 200:
+                    json_data = response.json()
+                    return [item['id'] for item in json_data.get('data', [])]
+        except httpx.RequestError as error:
+            print('Error fetching models:', error)
+        return []
+    
+    async def get_model(self) -> str:
+        model = None
+        if self.params.model is not None:
+            model = self.params.model
+        else:
+            models = await self.get_models()
+            model = models[0] if models else None
+            
+        if model is None:
+            raise Exception("No model name provided and no models available.")
+        
+        return model
+
+    def create_messages(self, prompt: str) -> List[dict]:
+        """
+        Создает сообщения для LLM на основе переданного промпта и системного промпта (если он задан).
+
+        Args:
+            prompt (str): Пользовательский промпт.
+
+        Returns:
+            list[dict]: Список сообщений с ролями и содержимым.
+        """
+        actual_prompt = self.apply_llm_template_to_prompt(prompt)
+        messages = []
+        if self.params.predict_params and self.params.predict_params.system_prompt:
+            messages.append({"role": "system", "content": self.params.predict_params.system_prompt})
+        messages.append({"role": "user", "content": actual_prompt})
+        return messages
+
+    def apply_llm_template_to_prompt(self, prompt: str) -> str:
+        """
+        Применяет шаблон LLM к переданному промпту, если он задан.
+
+        Args:
+            prompt (str): Пользовательский промпт.
+
+        Returns:
+            str: Промпт с примененным шаблоном (или оригинальный, если шаблон отсутствует).
+        """
+        actual_prompt = prompt
+        if self.params.template is not None:
+            actual_prompt = self.params.template.replace("{{PROMPT}}", actual_prompt)
+        return actual_prompt
+
+    async def tokenize(self, prompt: str) -> Optional[dict]:
+        """
+        Выполняет токенизацию переданного промпта.
+
+        Args:
+            prompt (str): Промпт для токенизации.
+
+        Returns:
+            Optional[dict]: Словарь с токенами и максимальной длиной модели, если запрос успешен.
+                            Если запрос неуспешен, возвращает None.
+        """
+
+        actual_prompt = self.apply_llm_template_to_prompt(prompt)
+        request_data = {
+            "model": self.get_model(),
+            "prompt": actual_prompt,
+            "add_special_tokens": False,
+        }
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    f"{self.params.url}/tokenize",
+                    json=request_data,
+                    headers=super().create_headers(),
+                )
+                if response.status_code == 200:
+                    data = response.json()
+                    if "tokens" in data:
+                        return {"tokens": data["tokens"], "max_length": data.get("max_model_len")}
+                elif response.status_code == 404:
+                    print("Tokenization endpoint not found (404).")
+                else:
+                    print(f"Failed to tokenize: {response.status_code}")
+        except httpx.RequestError as e:
+            print(f"Request failed: {e}")
+
+        return None
+
+    async def detokenize(self, tokens: List[int]) -> Optional[str]:
+        """
+        Выполняет д��токенизацию переданных токенов.
+
+        Args:
+            tokens (List[int]): Список токенов для детокенизации.
+
+        Returns:
+            Optional[str]: Строка, полученная в результате детокенизации, если запрос успешен.
+                           Если запрос неуспешен, возвращает None.
+        """
+        
+        request_data = {"model": self.get_model(), "tokens": tokens or []}
+
+        try:
+            async with httpx.AsyncClient() as client:
+                response = await client.post(
+                    f"{self.params.url}/detokenize",
+                    json=request_data,
+                    headers=super().create_headers(),
+                )
+                if response.status_code == 200:
+                    data = response.json()
+                    if "prompt" in data:
+                        return data["prompt"].strip()
+                elif response.status_code == 404:
+                    print("Detokenization endpoint not found (404).")
+                else:
+                    print(f"Failed to detokenize: {response.status_code}")
+        except httpx.RequestError as e:
+            print(f"Request failed: {e}")
+
+        return None
+
+    async def create_request(self, prompt: str) -> dict:
+        """
+        Создает запрос для предсказания на основе параметров LLM.
+
+        Args:
+            prompt (str): Промпт для запроса.
+
+        Returns:
+            dict: Словарь с параметрами для выполнения запроса.
+        """
+        model = self.get_model()
+
+        request = {
+            "stream": True,
+            "model": model,
+        }
+
+        predict_params = self.params.predict_params
+        if predict_params:
+            if predict_params.stop:
+                non_empty_stop = list(filter(lambda o: o != "", predict_params.stop))
+                if non_empty_stop:
+                    request["stop"] = non_empty_stop
+                    
+            if predict_params.n_predict is not None:
+                request["max_tokens"] = int(predict_params.n_predict or 0)
+                
+            request["temperature"] = float(predict_params.temperature or 0)
+            if predict_params.top_k is not None:
+                request["top_k"] = int(predict_params.top_k)
+                
+            if predict_params.top_p is not None:
+                request["top_p"] = float(predict_params.top_p)
+                
+            if predict_params.min_p is not None:
+                request["min_p"] = float(predict_params.min_p)
+                
+            if predict_params.seed is not None:
+                request["seed"] = int(predict_params.seed)
+                
+            if predict_params.n_keep is not None:
+                request["n_keep"] = int(predict_params.n_keep)
+                
+            if predict_params.cache_prompt is not None:
+                request["cache_prompt"] = bool(predict_params.cache_prompt)
+                
+            if predict_params.repeat_penalty is not None:
+                request["repetition_penalty"] = float(predict_params.repeat_penalty)
+                
+            if predict_params.repeat_last_n is not None:
+                request["repeat_last_n"] = int(predict_params.repeat_last_n)
+                
+            if predict_params.presence_penalty is not None:
+                request["presence_penalty"] = float(predict_params.presence_penalty)
+                
+            if predict_params.frequency_penalty is not None:
+                request["frequency_penalty"] = float(predict_params.frequency_penalty)
+
+        request["messages"] = self.create_messages(prompt)
+        return request
+
+    async def trim_sources(self, sources: str, user_request: str, system_prompt: str = None) -> dict:
+        """
+        Обрезает текст источников, чтобы уложиться в допустимое количество токенов.
+
+        Args:
+            sources (str): Текст источников.
+            user_request (str): Запрос пользователя с примененным шаблоном без текста источников.
+            system_prompt (str): Системный промпт, если нужен.
+
+        Returns:
+            dict: Словарь с результатом, количеством токенов до и после обрезки.
+        """
+        # Токенизация текста источников
+        sources_tokens_data = await self.tokenize(sources)
+        if sources_tokens_data is None:
+            raise ValueError("Failed to tokenize sources.")
+        max_token_count = sources_tokens_data.get("maxLength", 0)
+
+        # Токены системного промпта
+        system_prompt_token_count = 0
+        
+        if system_prompt is not None:
+            system_prompt_tokens = await self.tokenize(system_prompt)
+            system_prompt_token_count = len(system_prompt_tokens["tokens"]) if system_prompt_tokens else 0
+
+        # Оригинальное количество токенов
+        original_token_count = len(sources_tokens_data["tokens"])
+
+        # Токенизация пользовательского промпта
+        aux_prompt = self.apply_llm_template_to_prompt(user_request)
+        aux_tokens_data = await self.tokenize(aux_prompt)
+
+        aux_token_count = len(aux_tokens_data["tokens"]) if aux_tokens_data else 0
+
+        # Максимально допустимое количество токенов для источников
+        max_length = (
+            max_token_count
+            - (self.params.predict_params.n_predict or 0)
+            - aux_token_count
+            - system_prompt_token_count
+        )
+        max_length = max(max_length, 0)
+
+        # Обрезка токенов источников
+        if "tokens" in sources_tokens_data:
+            sources_tokens_data["tokens"] = sources_tokens_data["tokens"][:max_length]
+            detokenized_prompt = await self.detokenize(sources_tokens_data["tokens"])
+            if detokenized_prompt is not None:
+                sources = detokenized_prompt
+            else:
+                sources = sources[:max_length]
+        else:
+            sources = sources[:max_length]
+
+        # Возврат результата
+        return {
+            "result": sources,
+            "originalTokenCount": original_token_count,
+            "slicedTokenCount": len(sources_tokens_data["tokens"]),
+        }
+        
+    async def predict(self, prompt: str) -> str:
+        """
+        Выполняет запрос к API с поддержкой потокового вывода (SSE) и возвращает результат.
+
+        Args:
+            prompt (str): Входной текст для предсказания.
+
+        Returns:
+            str: Сгенерированный текст.
+        """
+        async with httpx.AsyncClient() as client:
+            # Формируем тело запроса
+            request = await self.create_request(prompt)
+
+            # Начинаем потоковый запрос
+            async with client.stream("POST", f"{self.params.url}/v1/chat/completions", json=request) as response:
+                if response.status_code != 200:
+                    # Если ошибка, читаем ответ для получения подробностей
+                    error_content = await response.aread()
+                    raise Exception(f"API error: {error_content.decode('utf-8')}")
+
+                # Для хранения результата
+                generated_text = ""
+
+                # Асинхронное чтение построчно
+                async for line in response.aiter_lines():
+                    if line.startswith("data: "):  # SSE-сообщения начинаются с "data: "
+                        try:
+                            # Парсим JSON из строки
+                            data = json.loads(line[len("data: "):].strip())
+                            if data == "[DONE]":  # Конец потока
+                                break
+                            if "choices" in data and data["choices"]:
+                                # Получаем текст из текущего токена
+                                token_value = data["choices"][0].get("delta", {}).get("content", "")
+                                generated_text += token_value
+                        except json.JSONDecodeError:
+                            continue  # Игнорируем строки, которые не удается декодировать
+
+            return generated_text.strip()

components/nmd/aggregate_answers.py

@@ -0,0 +1,189 @@
+from typing import List, Dict, Optional, Tuple
+import requests
+from logging import Logger
+
+from common.configuration import SemanticChunk
+from common.configuration import SegmentationSearch
+from common.configuration import SummaryChunks
+from common.configuration import FilterChunks
+from common.configuration import RocksNNSearch
+from common.configuration import PeopleChunks
+from common.configuration import SearchGroupComposition
+
+
+def aggregate_answers(vector_answer: Optional[Dict] = None,
+                      people_answer: Optional[List] = None,
+                      chunks_answer: Optional[List] = None,
+                      groups_answer: Optional[List] = None,
+                      rocks_nn_answer: Optional[List] = None,
+                      segmentation_answer: Optional[List] = None) -> Dict:
+    """
+
+    Args:
+        vector_answer:
+        people_answer:
+        chunks_answer:
+        groups_answer:
+        rocks_nn_answer:
+        segmentation_answer:
+
+    Returns:
+
+    """
+    answer = {}
+    if vector_answer is not None or chunks_answer is not None:
+        answer['doc_chunks'] = combine_answer([vector_answer, chunks_answer])
+    if people_answer is not None:
+        answer['people_search'] = [PeopleChunks(**answer_dict['_source']) for answer_dict in people_answer]
+    if groups_answer is not None:
+        answer['groups_search'] = SearchGroupComposition(**groups_answer[0]['_source'])
+    if rocks_nn_answer is not None:
+        answer['rocks_nn_search'] = RocksNNSearch(division=rocks_nn_answer[0]['_source']['division_name'],
+                                                  company_name=rocks_nn_answer[0]['_source']['company_name'])
+    if segmentation_answer is not None:
+        answer['segmentation_search'] = SegmentationSearch(**segmentation_answer[0]['_source'])
+
+    return answer
+
+
+def combine_answer(answers):
+    """
+
+    Args:
+        answers:
+
+    Returns:
+
+    """
+    answer_combined = []
+    answer_file_names = []
+    indexes = []
+    for answer in answers:
+        if answer is not None:
+            for key in answer:
+                if answer[key]["doc_name"] in answer_file_names:
+                    if answer[key]['start_index_paragraph'] not in indexes:
+                        obj_index = answer_file_names.index(answer[key]["doc_name"])
+                        answer_combined[obj_index].chunks.append(SemanticChunk(**answer[key]))
+                else:
+                    answer_combined.append(FilterChunks(
+                        id=str(answer[key]['id']),
+                        filename=answer[key]["doc_name"],
+                        title=answer[key]["title"],
+                        chunks=[SemanticChunk(**answer[key])]))
+                    answer_file_names.append(answer[key]["doc_name"])
+                indexes.append(answer[key]['start_index_paragraph'])
+    return answer_combined
+
+
+def preprocessed_chunks(answer_chunks: SummaryChunks, llm_host_tokens: str, logger: Logger) -> str:
+    output_text = ''
+    count = 0
+    count_tokens = 0
+    if answer_chunks.doc_chunks is not None:
+        for doc in answer_chunks.doc_chunks:
+            output_text += f'Документ: [{count + 1}]\n'
+            if doc.title != 'unknown':
+                output_text += f'Название документа: {doc.title}\n'
+            else:
+                output_text += f'Название документа: {doc.filename}\n'
+            for chunk in doc.chunks:
+                if len(chunk.other_info):
+                    output_text += '...\n'
+                    for i in chunk.other_info:
+                        output_text += f'{i}'.replace('', '-')
+                    output_text += '...\n'
+                else:
+                    output_text += '...\n'
+                    output_text += f'{chunk.text_answer}'
+                    output_text += '...\n'
+                count_tokens = len(output_text) * 2 
+                #TODO: в deepinfra нет такой возможности. Нужно прокинуть токенизатор
+                #len(requests.post(url=f'{llm_host_tokens}', json={"content": output_text}).json()['tokens'])
+                if count_tokens > 20000:
+                    logger.info('Количество токенов превысило значение 20k! Оставшиеся чанки отброшены!')
+                    break
+
+            if count_tokens > 20000:
+                output_text += '\n\\\n\n'
+                count += 1
+                break
+
+            output_text += '\n\\\n\n'
+            count += 1
+
+    if answer_chunks.people_search is not None:
+        for doc in answer_chunks.people_search:
+            output_text += f'Документ: [{count + 1}]\n'
+            output_text += f'Название документа: Информация о сотруднике {doc.person_name}\n'
+            output_text += f'Информация о сотруднике {doc.person_name}\n'
+            if doc.organizatinal_structure is not None:
+                for organizatinal_structure in doc.organizatinal_structure:
+                    output_text += '[\n'
+                    if organizatinal_structure.position != 'undefined':
+                        output_text += f'Должность: {organizatinal_structure.position}'
+                    if organizatinal_structure.leads is not None:
+                        output_text += f'\nРуководит следующими сотрудниками:\n'
+                        for lead in organizatinal_structure.leads:
+                            if lead.person != "undefined":
+                                output_text += f'{lead.person}\n'
+                    if organizatinal_structure.subordinates is not None:
+                        if organizatinal_structure.subordinates.person_name != "undefined":
+                            output_text += f'Руководителем {doc.person_name} является {organizatinal_structure.subordinates.person_name}'
+                    output_text += '\n]\n'
+
+            if doc.business_processes is not None:
+                if len(doc.business_processes) >= 2:
+                    output_text += f'Отвечает за Бизнес процессы:\n'
+                else:
+                    output_text += f'Отвечает за Бизнес процесс: '
+                for process in doc.business_processes:
+                    output_text += f'{process.processes_name}\n'
+            if doc.business_curator is not None:
+                output_text += 'Является Бизнес-куратором (РОКС НН):\n'
+                for curator in doc.business_curator:
+                    output_text += f'{curator.company_name}\n'
+            if doc.groups is not None:
+                output_text += '\nВходит в состав групп, комитетов, координационных советов (КО):\n'
+                for group in doc.groups:
+                    if 'Члены' in group.position_in_group:
+                        output_text += f'{group.group_name}. Должность внутри группы: {group.position_in_group.replace("Члены", "Член")}\n'
+                    else:
+                        output_text += f'{group.group_name}. Должность внутри группы: {group.position_in_group}\n'
+            output_text += f'\n\\\n\n'
+            count += 1
+
+    if answer_chunks.groups_search is not None:
+        output_text += f'Документ: [{count + 1}]\n'
+        output_text += f'Название документа: Информация о группе\n'
+        output_text += f'Название группы: {answer_chunks.groups_search.group_name}\n'
+        if len(answer_chunks.groups_search.group_composition) > 1:
+            output_text += f'\t ФИО \t\t\t| Должность внутри группы\n'
+        for person_data in answer_chunks.groups_search.group_composition:
+            if 'Члены' in person_data.position_in_group:
+                output_text += f'{person_data.person_name:<{20}}| {person_data.position_in_group.replace("Члены", "Член")}\n'
+            else:
+                output_text += f'{person_data.person_name:<{20}}| {person_data.position_in_group}\n'
+        output_text += f'\n\\\n\n'
+        count += 1
+
+    if answer_chunks.rocks_nn_search is not None:
+        output_text += f'Документ: [{count + 1}]\n'
+        output_text += f'Название документа: Информация о {answer_chunks.rocks_nn_search.division}\n'
+        output_text += f'Название документа: В РОКС НН {answer_chunks.rocks_nn_search.division} входят:\n'
+        for company_name in answer_chunks.rocks_nn_search.company_name:
+            output_text += f'{company_name}\n'
+        output_text += f'\n\\\n\n'
+        count += 1
+
+    if answer_chunks.segmentation_search is not None:
+        output_text += f'Документ: [{count + 1}]\n'
+        output_text += f'Название документа: {answer_chunks.segmentation_search.segmentation_model}\n'
+        output_text += f'Название документа: В {answer_chunks.segmentation_search.segmentation_model} входят:\n'
+        for company_name in answer_chunks.segmentation_search.company_name:
+            output_text += f'{company_name}\n'
+        output_text += f'\n\\\n\n'
+        count += 1
+
+    output_text = output_text.replace('\uf02d', '-').replace('', '-')
+    return output_text

components/nmd/faiss_vector_search.py

@@ -0,0 +1,48 @@
+import logging
+from typing import List
+import numpy as np
+import pandas as pd
+import faiss
+
+from common.constants import COLUMN_EMBEDDING
+from common.constants import DO_NORMALIZATION
+from common.configuration import DataBaseConfiguration
+from components.embedding_extraction import EmbeddingExtractor
+
+logger = logging.getLogger(__name__)
+
+
+class FaissVectorSearch:
+    def __init__(
+        self, model: EmbeddingExtractor, df: pd.DataFrame, config: DataBaseConfiguration
+    ):
+        self.model = model
+        self.config = config
+        self.path_to_metadata = config.faiss.path_to_metadata
+        if self.config.ranker.use_ranging:
+            self.k_neighbors = config.ranker.k_neighbors
+        else:
+            self.k_neighbors = config.search.vector_search.k_neighbors
+        self.__create_index(df)
+
+    def __create_index(self, df: pd.DataFrame):
+        """Load the metadata file."""
+        if len(df) == 0:
+            self.index = None
+            return
+        df = df.where(pd.notna(df), None)
+        embeddings = np.array(df[COLUMN_EMBEDDING].tolist())
+        dim = embeddings.shape[1]
+        self.index = faiss.IndexFlatL2(dim)
+        self.index.add(embeddings)
+
+    def search_vectors(self, query: str) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Поиск векторов в индексе.
+        """
+        logger.info(f"Searching vectors in index for query: {query}")
+        if self.index is None:
+            return (np.array([]), np.array([]), np.array([]))
+        query_embeds = self.model.query_embed_extraction(query, DO_NORMALIZATION)
+        scores, indexes = self.index.search(query_embeds, self.k_neighbors)
+        return query_embeds[0], scores[0], indexes[0]

components/nmd/llm_chunk_search.py

@@ -0,0 +1,235 @@
+import os
+import re
+from logging import Logger
+from typing import List, Union
+
+from openai import OpenAI
+
+from common.configuration import FilterChunks, LLMConfiguration, SummaryChunks
+from components.nmd.aggregate_answers import preprocessed_chunks
+
+
+class LLMChunkSearch:
+
+    def __init__(self, config: LLMConfiguration, prompt: str, logger: Logger):
+        self.config = config
+        self.logger = logger
+        self.prompt = prompt
+        self.pattern = r'\d+'
+        self.pattern_list = [
+            r'\[\d+\]',
+            r'Ответ: [1-9]',
+            r'Ответ [1-9]',
+            r'Ответ[1-9]',
+            r'Ответ:[1-9]',
+            r'Ответ: \[\d+\]',
+        ]
+        
+        # Initialize OpenAI client
+        if self.config.base_url is not None:
+            self.client = OpenAI(
+                base_url=self.config.base_url,
+                api_key=os.getenv(self.config.api_key_env)
+            )
+        else:
+            self.client = None
+
+    def llm_chunk_search(self, query: str, answer_chunks: SummaryChunks, prompt: str):
+        """
+        Args:
+            query: User query
+            answer_chunks: Retrieved chunks to process
+            prompt: System prompt template
+
+        Returns:
+            Tuple containing processed chunks, LLM response, prompt used, and token count
+        """
+        text_chunks = preprocessed_chunks(
+            answer_chunks, self.config.base_url, self.logger
+        )
+        self.logger.info('Searching LLM Chunks')
+        
+        if self.client is None:
+            return (
+                text_chunks,
+                self.__postprocessing_answer_llm(answer_chunks),
+                prompt,
+                0
+            )
+        
+        llm_prompt = prompt.format(query=query, answer=text_chunks)
+        
+        for i in range(5):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.config.model,
+                    messages=[
+                        {"role": "system", "content": prompt},
+                        {"role": "user", "content": query}
+                    ],
+                    temperature=self.config.temperature,
+                    top_p=self.config.top_p,
+                    frequency_penalty=self.config.frequency_penalty,
+                    presence_penalty=self.config.presence_penalty,
+                    seed=self.config.seed
+                )
+                
+                answer_llm = response.choices[0].message.content
+                count_tokens = response.usage.total_tokens
+
+                self.logger.info(f'Answer LLM {answer_llm}')
+                
+                # Process the response
+                if re.search('%%', answer_llm):
+                    index = re.search('%%', answer_llm).span()[1]
+                    answer_llm = answer_llm[index:]
+                if re.search('Конец ответа', answer_llm):
+                    index = re.search('Конец ответа', answer_llm).span()[1]
+                    answer_llm = answer_llm[:index]
+                    
+                return text_chunks, answer_llm, llm_prompt, count_tokens
+
+            except Exception as e:
+                self.logger.error(f"Attempt {i+1} failed: {str(e)}")
+                if i == 4:
+                    self.logger.error("All attempts failed")
+                    return (
+                        text_chunks,
+                        self.__postprocessing_answer_llm(answer_chunks),
+                        llm_prompt,
+                        0
+                    )
+
+    @staticmethod
+    def __postprocessing_answer_llm(answer_chunks: Union[SummaryChunks, List]) -> str:
+        """
+        Postprocess the answer chunks into a formatted string
+        
+        Args:
+            answer_chunks: Chunks to process
+
+        Returns:
+            Formatted string response
+        """
+        output_text = ''
+        if isinstance(answer_chunks, SummaryChunks):
+            if len(answer_chunks.doc_chunks) == 0:
+                # TODO: Протестировать как работает и исправить на уведомление о БД и ли
+                return 'БАЗА ДАННЫХ ПУСТА'
+            if answer_chunks.doc_chunks is not None:
+                doc = answer_chunks.doc_chunks[0]
+                output_text += f'Документ: [1]\n'
+                if doc.title != 'unknown':
+                    output_text += f'Название документа: {doc.title}\n'
+                else:
+                    output_text += f'Название документа: {doc.filename}\n'
+                for chunk in doc.chunks:
+                    if len(chunk.other_info):
+                        for i in chunk.other_info:
+                            output_text += f'{i}'
+                    else:
+                        output_text += f'{chunk.text_answer}'
+                output_text += '\n\n'
+            else:
+                doc = answer_chunks.people_search[0]
+                output_text += (
+                    f'Название документа: Информация о сотруднике {doc.person_name}\n'
+                )
+                if doc.organizatinal_structure is not None:
+                    for organizatinal_structure in doc.organizatinal_structure:
+                        output_text += '('
+                        if organizatinal_structure.position != 'undefined':
+                            output_text += (
+                                f'Должность: {organizatinal_structure.position}\n'
+                            )
+                        if organizatinal_structure.leads is not None:
+                            output_text += f'Руководит следующими сотрудниками:\n'
+                            for lead in organizatinal_structure.leads:
+                                if lead.person != "undefined":
+                                    output_text += f'{lead.person}\n'
+                        if (
+                            organizatinal_structure.subordinates.person_name
+                            != "undefined"
+                        ):
+                            output_text += f'Руководителем {doc.person_name} является {organizatinal_structure.subordinates.person_name}\n'
+                        output_text += ')'
+
+                if doc.business_processes is not None:
+                    if len(doc.business_processes) >= 2:
+                        output_text += f'Отвечает за Бизнес процессы:\n'
+                    else:
+                        output_text += f'Отвечает за Бизнес процесс: '
+                    for process in doc.business_processes:
+                        output_text += f'{process.processes_name}\n'
+                if doc.business_curator is not None:
+                    output_text += 'Является Бизнес-куратором (РОКС НН):\n'
+                    for curator in doc.business_curator:
+                        output_text += f'{curator.company_name}'
+                if doc.groups is not None:
+                    if len(doc.groups) >= 2:
+                        output_text += 'Входит в состав групп:\n'
+                    else:
+                        output_text += 'Входит в состав группы:\n'
+                    for group in doc.groups:
+                        if 'Члены' in group.position_in_group:
+                            output_text += f'{group.group_name}. Должность внутри группы: {group.position_in_group.replace("Члены", "Член")}\n'
+                        else:
+                            output_text += f'{group.group_name}. Должность внутри группы: {group.position_in_group}\n'
+                output_text += f'\\\n\n'
+
+        else:
+            if isinstance(answer_chunks[0], FilterChunks):
+                doc = answer_chunks[0]
+                output_text += f'Документ: [1]\n'
+                if doc.title != 'unknown':
+                    output_text += f'Название документа: {doc.title}\n'
+                for chunk in doc.chunks:
+                    if len(chunk.other_info):
+                        for i in chunk.other_info:
+                            output_text += f'{i}'
+                    else:
+                        output_text += f'{chunk.text_answer}'
+                output_text += '\n\n'
+            else:
+                doc = answer_chunks[0]
+                output_text += f'Информация о сотруднике {doc.person_name}\n'
+                if doc.organizatinal_structure is not None:
+                    for organizatinal_structure in doc.organizatinal_structure:
+                        output_text += (
+                            f'Должность: {organizatinal_structure.position}\n'
+                        )
+                        if organizatinal_structure.leads is not None:
+                            output_text += f'Руководит следующими сотрудниками:\n'
+                            for lead in organizatinal_structure.leads:
+                                if lead.person != "undefined":
+                                    output_text += f'{lead.person}\n'
+                        if (
+                            organizatinal_structure.subordinates.person_name
+                            != "undefined"
+                        ):
+                            output_text += f'Руководителем {doc.person_name} является {organizatinal_structure.subordinates.person_name}\n'
+
+                if doc.business_processes is not None:
+                    if len(doc.business_processes) >= 2:
+                        output_text += f'Отвечает за Бизнес процессы:\n'
+                    else:
+                        output_text += f'Отвечает за Бизнес процесс: '
+                    for process in doc.business_processes:
+                        output_text += f'{process.processes_name}\n'
+                if doc.business_curator is not None:
+                    output_text += 'Является Бизнес-куратором (РОКС НН):\n'
+                    for curator in doc.business_curator:
+                        output_text += f'{curator.company_name}'
+                if doc.groups is not None:
+                    if len(doc.groups) >= 2:
+                        output_text += 'Входит в состав групп:\n'
+                    else:
+                        output_text += 'Входит в состав группы:\n'
+                    for group in doc.groups:
+                        if 'Члены' in group.position_in_group:
+                            output_text += f'{group.group_name}. Должность внутри группы: {group.position_in_group.replace("Члены", "Член")}\n'
+                        else:
+                            output_text += f'{group.group_name}. Должность внутри группы: {group.position_in_group}\n'
+                output_text += f'\\\n\n'
+
+        return output_text

components/nmd/metadata_manager.py

@@ -0,0 +1,255 @@
+from typing import List, Tuple, Optional
+
+import pandas as pd
+
+
+class MetadataManager:
+    def __init__(self, df: pd.DataFrame, logger):
+        self.logger = logger
+        self.df = df
+        self.df.drop('Embedding', axis=1, inplace=True)
+        self.df = self.df.where(pd.notna(self.df), 'unknown')
+
+    @staticmethod
+    def __search_sub_level(df: pd.DataFrame, header_text: Optional[str] = None) -> List:
+        """
+
+        Args:
+            df:
+
+        Returns:
+
+        """
+        paragraphs = []
+        if header_text is None:
+            header_text = df.iloc[0]['Text']
+
+        for ind, (_, row) in enumerate(df.iterrows()):
+            text = row['Text']
+            if ind == 0:
+                text = text.replace(f'{header_text}', f'{header_text}\n')
+            else:
+                text = text.replace(f'{header_text}', '') + '\n'
+            paragraphs.append(text)
+        return paragraphs
+
+    @staticmethod
+    def __check_duplicates(df: pd.DataFrame, ind: int) -> pd.DataFrame:
+        if df.loc[ind]['Duplicate'] is not None:
+            return df[df['Duplicate'] == df.loc[ind]['Duplicate']]
+        else:
+            return df[df['Duplicate'].isna()]
+
+    @staticmethod
+    def __check_appendix_duplicates(df: pd.DataFrame, ind: int) -> pd.DataFrame:
+        if df.loc[ind]['DuplicateAppendix'] is not None:
+            return df[df['DuplicateAppendix'] == df.loc[ind]['DuplicateAppendix']]
+        else:
+            return df[df['DuplicateAppendix'].isna()]
+
+    def _paragraph_appendix_content(self, df, pattern: str, ind: int, shape: int) -> Tuple[List, int]:
+        """
+        Функция возвращает контент параграфа. Если в параграфе были подпункты через "-" или буквы "а, б"
+        Args:
+            df: DataFrame
+            pattern: Паттерн поиска.
+            ind: Индекс строки в DataFrame.
+            shape: Размер DataFrame при котором будет возвращаться пустой список.
+
+        Returns:
+            Возвращает список подразделов.
+        Examples:
+            3.1. Параграф:
+              1) - Содержание 1;
+              2) - Содержание 2;
+              3) - Содержание 3;
+        """
+        df = df[(df['PargaraphAppendix'].str.match(pattern, na=False)) | (df.index == ind)]
+        df = self.__check_appendix_duplicates(df, ind)
+
+        if df.shape[0] <= shape:
+            return [], None
+
+        start_index_paragraph = df.index[0]
+        paragraphs = self.__search_sub_level(df)
+        return paragraphs, start_index_paragraph
+
+    def _paragraph_content(self, df, pattern: str, ind: int, shape: int) -> Tuple[List, int]:
+        """
+        Функция возвращает контент параграфа. Если в параграфе были подпункты через "-" или буквы "а, б"
+        Args:
+            df: DataFrame
+            pattern: Паттерн поиска.
+            ind: Индекс строки в DataFrame.
+            shape: Размер DataFrame при котором будет возвращаться пустой список.
+
+        Returns:
+            Возвращает список подразделов.
+        Examples:
+            3.1. Параграф:
+              1) - Содержание 1;
+              2) - Содержание 2;
+              3) - Содержание 3;
+        """
+        df = df[
+            (df['Pargaraph'].str.match(pattern, na=False)) &  # Проверка, соответствуют ли значения паттерну
+            (df['Duplicate'] == df.loc[ind]['Duplicate']) |  # Оставить разделы только принадлежащие одному дубликату
+            (df.index == ind)]  # Оставить значение, которое нашел векторный поиск
+        # df = self.__check_duplicates(df, ind)
+
+        if df.shape[0] <= shape:
+            return [], None
+
+        start_index_paragraph = df.index[0]
+        paragraphs = self.__search_sub_level(df)
+        return paragraphs, start_index_paragraph
+
+    def _paragraph_content2(self, df, pattern: str, ind: int, shape: int) -> Tuple[List, int]:
+        """
+        Функция возвращает контент параграфа. Если в параграфе были подпункты через "-" или буквы "а, б"
+        Args:
+            df: DataFrame
+            pattern: Паттерн поиска.
+            ind: Индекс строки в DataFrame.
+            shape: Размер DataFrame при котором будет возвращаться пустой список.
+
+        Returns:
+            Возвращает список подразделов.
+        Examples:
+            3.1. Параграф:
+              1) - Соде��жание 1;
+              2) - Содержание 2;
+              3) - Содержание 3;
+        """
+        df = df[df['Pargaraph'].str.match(pattern, na=False)]
+        if df.shape[0] <= shape:
+            return [], None
+        # df = self.__check_duplicates(df, ind)
+        # if df.shape[0] <= shape:
+        #     return [], None
+        start_index_paragraph = df.index[0]
+        paragraphs = self.__search_sub_level(df)
+        return paragraphs, start_index_paragraph
+
+    @staticmethod
+    def _first_unknown_index(df):
+        indexes = list(df[df['PartLevel1'].isin(['unknown'])].index)
+        if len(indexes) > 0:
+            return df.loc[indexes[-1]]['Text']
+        else:
+            return None
+
+    def _search_other_info(self, ind, doc_number):
+
+        df = self.df[self.df['DocNumber'] == doc_number]
+        start_index_paragraph = df.loc[ind]['Index'] - 1
+        if df.loc[ind]['Table'] != 'unknown':
+            return df.loc[ind]['Text'], ind
+
+        if df.loc[ind]['PartLevel1'] != 'unknown':
+            if 'Table' in str(self.df.iloc[ind]['PartLevel1']):
+                return [], ind
+
+        if df.loc[ind]['Appendix'] != 'unknown':
+            df = df[df['Appendix'] == self.df.iloc[ind]['Appendix']]
+            if df.loc[ind]['LevelParagraphAppendix'] == 'unknown' and df.loc[ind]['PargaraphAppendix'] == 'unknown':
+                # pattern = r'\d+\.?$'
+                # df = df[(df['PargaraphAppendix'].str.match(pattern, na=False)) | (df.index == ind)]
+                # df = df[(df['LevelParagraphAppendix'] == 'Level0') | (df.index == ind)]
+                df = df.loc[ind:ind + 7]
+                start_index_paragraph = df.index[0]
+                paragraph = self.__search_sub_level(df)
+            elif df.loc[ind]['PargaraphAppendix'] != 'unknown':
+                pattern = df.loc[ind]["PargaraphAppendix"].replace(".", r"\.")
+                pattern = f'^{pattern}?\\d?.?$'
+                if df[df['PargaraphAppendix'].str.match(pattern, na=False)].shape[0] == 1:
+                    pattern = df.loc[ind]["PargaraphAppendix"].replace(".", r"\.")
+                    pattern = pattern.split('.')
+                    pattern = [elem for elem in pattern if elem]
+                    if len(pattern) == 1:
+                        pattern = '.'.join(pattern)
+                        pattern = f'^{pattern}.?\\d?.?$'
+                    else:
+                        pattern = '.'.join(pattern[:-1])
+                        pattern = f'^{pattern}.\\d.?$'
+                df = df[df['PargaraphAppendix'].str.match(pattern, na=False)]
+                start_index_paragraph = df.index[0]
+                paragraph = self.__search_sub_level(df)
+            else:
+                paragraph = self.df.iloc[int(ind - 10):ind + 10]['Text'].values
+                start_index_paragraph = df.index[0]
+            return ' '.join(paragraph), start_index_paragraph
+        else:
+            if df.loc[ind]['Pargaraph'] == 'unknown':
+                header_text = self._first_unknown_index(df)
+                df = df.loc[int(ind - 2):ind + 2]
+                paragraph = self.__search_sub_level(df, header_text)
+                # Связан с документами без пунктов поэтому передается несколько параграфов сверху и снизу
+            else:
+                pattern = df.loc[ind]["Pargaraph"].replace(".", r"\.")
+                # Изет под пункты внутри пункта
+                paragraph, start_index_paragraph = self._paragraph_content(df, fr'^{pattern}?$', ind, 2)
+                if len(paragraph) == 0:
+                    pattern = f'{pattern}\\d?.?\\d?\\d?.?$'
+                    paragraph, start_index_paragraph = self._paragraph_content2(df, pattern, ind, 0)
+                if len(paragraph) == 0 and df.loc[ind]['LevelParagraph'] != '0':
+                    pattern = df.loc[ind]["Pargaraph"].split('.')
+                    pattern = [elem for elem in pattern if elem]
+                    pattern = '.'.join(pattern[:-1])
+                    pattern = f'^{pattern}\\.\\d\\d?.?$'
+                    paragraph, start_index_paragraph = self._paragraph_content(df, pattern, ind, 0)
+                elif len(paragraph) == 0 and df.loc[ind]['LevelParagraph'] == '0':
+                    pattern = df.loc[ind]["Pargaraph"].replace(".", r"\.")
+                    if '.' not in pattern:
+                        pattern = pattern + '\.'
+                    pattern = f'^{pattern}\\d.?\\d?.?$'
+                    paragraph, start_index_paragraph = self._paragraph_content(df, pattern, ind, 0)
+
+        return ' '.join(paragraph), start_index_paragraph
+
+    @staticmethod
+    def filter_answer(answer):
+        flip_answer = []
+        new_answer = {}
+        count = 0
+        for key in answer:
+            if answer[key]['start_index_paragraph'] not in flip_answer:
+                flip_answer.append(answer[key]['start_index_paragraph'])
+                new_answer[count] = answer[key]
+                count += 1
+        return new_answer
+
+    def _clear_doc_name(self, ind):
+        split_doc_name = self.df.iloc[ind]['DocName'].split('_')
+        return ' '.join(split_doc_name[1:]).replace('.txt', '').replace('.json', '').replace('.DOCX', '').replace(
+            '.DOC', '').replace('tables', '')
+
+    def search(self, indexes: List) -> dict:
+        """
+        Метод ищет ответы на запрос
+        Args:
+            indexes: Список индексов.
+
+        Returns:
+            Возвращает словарь с ответами и информацией об ответах.
+        """
+        answers = {}
+        for i, ind in enumerate(indexes):
+            answers[i] = {}
+            doc_number = self.df.iloc[ind]['DocNumber']
+            answers[i]['id'] = doc_number
+            answers[i][f'index_answer'] = int(ind)
+            answers[i][f'doc_name'] = self._clear_doc_name(ind)
+            answers[i][f'title'] = self.df.iloc[ind]['Title']
+            answers[i][f'text_answer'] = self.df.iloc[ind]['Text']
+
+            try:
+                other_info, start_index_paragraph = self._search_other_info(ind, doc_number)
+            except KeyError:
+                other_info, start_index_paragraph = self.df.iloc[ind]['Text'], ind
+                self.logger.info('Ошибка в индексе, проверьте БД!')
+            if len(other_info) == 0:
+                other_info, start_index_paragraph = self.df.iloc[ind]['Text'], ind
+            answers[i][f'other_info'] = [other_info]
+            answers[i][f'start_index_paragraph'] = int(start_index_paragraph)
+        return self.filter_answer(answers)

components/nmd/query_classification.py

@@ -0,0 +1,79 @@
+import os
+import re
+from logging import Logger
+from typing import Dict, List, Optional, Tuple
+
+from openai import OpenAI
+
+from common.configuration import LLMConfiguration
+
+
+class QueryClassification:
+    def __init__(self, config: LLMConfiguration, prompt: str, logger: Logger):
+        self.config = config
+        self.logger = logger
+        self.prompt = prompt
+        self.pattern = r'\[\d+\]'
+        
+        # Initialize OpenAI client
+        if self.config.base_url is not None:
+            self.client = OpenAI(
+                base_url=self.config.base_url,
+                api_key=os.getenv(self.config.api_key_env)
+            )
+        else:
+            self.client = None
+
+    def query_classification(self, query: str) -> Tuple[str, Optional[Dict], Optional[List]]:
+        """
+        Classify the query using LLM
+        
+        Args:
+            query: User query to classify
+
+        Returns:
+            Tuple containing query type, optional metadata and optional list
+        """
+        self.logger.info('Query Classification')
+        if self.client is None:
+            return '[3]', None, None
+        for i in range(5):
+            try:
+                response = self.client.chat.completions.create(
+                    model=self.config.model,
+                    messages=[
+                        {"role": "system", "content": self.prompt},
+                        {"role": "user", "content": query}
+                    ],
+                    temperature=self.config.temperature,
+                    top_p=self.config.top_p,
+                    frequency_penalty=self.config.frequency_penalty,
+                    presence_penalty=self.config.presence_penalty,
+                    seed=self.config.seed
+                )
+
+                answer_llm = response.choices[0].message.content
+                self.logger.info(f'Answer LLM {answer_llm}')
+
+                # Process the response
+                if re.search('%%', answer_llm):
+                    index = re.search('%%', answer_llm).span()[1]
+                    answer_llm = answer_llm[index:]
+                if re.search('Конец ответа', answer_llm):
+                    index = re.search('Конец ответа', answer_llm).span()[1]
+                    answer_llm = answer_llm[:index]
+
+                # Extract query type
+                query_type = re.findall(self.pattern, answer_llm)
+                if query_type:
+                    query_type = query_type[0]
+                else:
+                    query_type = '[3]'
+
+                return query_type, None, None
+
+            except Exception as e:
+                self.logger.error(f"Attempt {i+1} failed: {str(e)}")
+                if i == 4:
+                    self.logger.error("All attempts failed")
+                    return '[3]', None, None

components/nmd/rancker.py

@@ -0,0 +1,32 @@
+import pandas as pd
+
+from common.configuration import Configuration
+
+
+class DocumentRanking:
+
+    def __init__(self, df: pd.DataFrame, config: Configuration):
+        self.df = df
+        self.config = config
+        self.alpha = config.db_config.ranker.alpha
+        self.beta = config.db_config.ranker.beta
+
+    def doc_ranking(self, query_embedding, scores, indexes):
+        title_embeddings = self.df.iloc[indexes]['TitleEmbedding'].to_list()
+        norms = []
+        for emb in title_embeddings:
+            d = emb - query_embedding
+            norm = d.dot(d)
+            norms.append(norm)
+
+        new_score = []
+        texts = self.df.iloc[indexes]['Text'].to_list()
+        for ind, text in enumerate(texts):
+            new_score.append(scores[ind] * len(text) ** self.beta + self.alpha * norms[ind])
+
+        metric_df = pd.DataFrame()
+        metric_df['NewScores'] = new_score
+        metric_df['Indexes'] = indexes
+        metric_df.sort_values(by=['NewScores'], inplace=True)
+        new_indexes = metric_df['Indexes'].to_list()[:self.config.db_config.search.vector_search.k_neighbors]
+        return new_indexes

components/parser/README.md

@@ -0,0 +1,105 @@
+# Pipeline Module
+
+> ВАЖНО!!! README.md сгенерировано автоматически, поэтому может содержать неточности.
+
+Модуль реализует пайплайн для обработки XML документов и создания структурированного датасета. Пайплайн включает несколько последовательных этапов обработки, от парсинга XML до создания векторизованного датасета.
+
+## Основные этапы обработки
+
+### 1. Парсинг XML файлов
+- Чтение XML файлов из указанной директории
+- Извлечение текстового и табличного контента
+- Сохранение метаданных документов
+
+### 2. Обработка аббревиатур
+- Извлечение аббревиатур из текста документов
+- Объединение с предварительно подготовленными аббревиатурами
+- Применение аббревиатур к текстовому и табличному контенту
+- Сохранение списка обнаруженных аббревиатур
+
+### 3. Извлечение иерархической структуры
+- Парсинг структуры текстового контента
+- Парсинг структуры табличного контента
+- Создание иерархического представления документов
+
+### 4. Создание датасета
+- Формирование структурированного датасета
+- Векторизация текстов
+- Сохранение результатов
+
+## Использование
+
+```python
+from components.embedding_extraction import EmbeddingExtractor
+from components.parser.pipeline import DatasetCreationPipeline
+from components.parser.abbreviations.abbreviation import Abbreviation
+
+# Инициализация пайплайна
+pipeline = DatasetCreationPipeline(
+    dataset_id="my_dataset",
+    vectorizer=EmbeddingExtractor(),
+    prepared_abbreviations=[],  # список предварительно подготовленных аббревиатур
+    xml_ids=["doc1", "doc2"],  # список идентификаторов XML файлов
+    save_intermediate_files=True  # сохранять ли промежуточные файлы
+)
+
+# Запуск пайплайна
+dataset = pipeline.run()
+```
+
+## Структура выходных данных
+
+### Основные файлы
+- `dataset.csv` - финальный датасет с векторизованными текстами
+- `abbreviations.csv` - извлеченные аббревиатуры
+- `xml_info.csv` - метаданные XML документов
+
+### Промежуточные файлы (опционально)
+- `txt/*.txt` - извлеченный текстовый контент
+- `txt_abbr/*.txt` - текстовый контент после применения аббревиатур
+- `jsons/*.json` - иерархическая структура документов
+
+## Параметры конфигурации
+
+### DatasetCreationPipeline
+- `dataset_id: str` - идентификатор создаваемого датасета
+- `vectorizer: EmbeddingExtractor` - векторизатор для создания эмбеддингов
+- `prepared_abbreviations: list[Abbreviation]` - предварительно подготовленные аббревиатуры
+- `xml_ids: list[str]` - список идентификаторов XML файлов для обработки
+- `save_intermediate_files: bool` - сохранять ли промежуточные файлы
+
+## Зависимости
+
+### Внутренние компоненты
+- `components.embedding_extraction.EmbeddingExtractor`
+- `components.parser.abbreviations.AbbreviationExtractor`
+- `components.parser.features.HierarchyParser`
+- `components.parser.features.DatasetCreator`
+- `components.parser.xml.XMLParser`
+
+### Внешние библиотеки
+- pandas
+- numpy
+- pathlib
+
+## Структура директорий
+
+```
+data/
+└── regulation_datasets/
+    └── {dataset_id}/
+        ├── abbreviations.csv
+        ├── xml_info.csv
+        ├── dataset.csv
+        ├── embeddings.pt
+        ├── txt/                # (опционально)
+        ├── txt_abbr/          # (опционально)
+        └── jsons/             # (опционально)
+```
+
+## Примечания
+
+- Все промежуточные файлы сохраняются только если установлен флаг `save_intermediate_files=True`
+- Векторизация выполняется после создания д��тасета
+- Аббревиатуры применяются как к текстовому, так и к табличному контенту
+- Иерархическая структура извлекается отдельно для текста и таблиц 

components/parser/abbreviations/README.md

@@ -0,0 +1,119 @@
+# Экстрактор сокращений (Abbreviation Extractor)
+
+> ВАЖНО!!! README.md сгенерировано автоматически, поэтому может содержать неточности.
+
+Модуль для извлечения сокращений и их полных форм из текстовых документов.
+
+## Принцип работы
+
+Экстрактор ищет в тексте конструкции вида:
+- "полная форма (далее - сокращение)"
+- "полная форма (далее – сокращение)"
+и подобные варианты.
+
+### Основные этапы обработки:
+
+1. **Разбиение на предложения**
+   - Текст разбивается на предложения с учетом специальных случаев
+   - Учитываются особые сокращения, после которых точка не является концом предложения
+
+2. **Поиск сокращений**
+   - В каждом предложении ищутся конструкции с маркером "далее"
+   - Извлекается короткая форма (сокращение) после маркера
+   - Определяется полная форма до маркера
+
+3. **Обработка сокращений**
+   - Поддерживается два типа сокращений:
+     - Однословные (например, "*БЖВРК*")
+     - Многословные (например, "Мы великая нация великих обезьян (далее - *нация обезьян*)")
+   - Для каждого сокращения определяется его полная форма
+
+4. **Лемматизация**
+   - Используется библиотека Natasha для лемматизации текста
+   - Помогает находить соответствия между полной и короткой формами
+
+## Использование
+
+```python
+from components.parser.abbreviations.abbreviation_extractor import AbbreviationExtractor
+from components.parser.xml.structures import ParsedXMLs
+
+# Создание экстрактора
+extractor = AbbreviationExtractor()
+
+# Обработка XML-файлов
+result = extractor.process_parsed_xmls(parsed_xmls)
+
+# Обработка одного файла
+file_abbreviations = extractor.process_file(text, filename)
+
+# Извлечение сокращений из текста
+abbreviations = extractor.extract_abbreviations_from_text(text)
+```
+
+## Структура результатов
+
+Результаты представляются в виде структур данных:
+- `AllFilesAbbreviations` - коллекция сокращений из всех файлов
+- `OneFileAbbreviations` - сокращения из одного файла
+- `Abbreviation` - отдельное сокращение с полной и короткой формами
+
+## Особенности
+
+- Учитываются различные варианты разделителей между полной и короткой формами
+- Поддерживается обработка специальных сокращений, не являющихся концом предложения
+- Используется лемматизация для улучшения поиска соответствий
+- Возможна обработка как одиночных файлов, так и наборов файлов
+
+# Обработка сокращений и аббревиатур
+
+Модуль `abbreviation.py` отвечает за обработку и нормализацию сокращений и аббревиатур в тексте.
+
+## Основные типы сокращений
+
+- `ABBREVIATION` - аббревиатуры (например, "ОКС НН")
+- `SHORTENING` - сокращения (например, "Компания")
+- `UNKNOWN` - неопределенный тип
+
+## Процесс обработки
+
+Класс `Abbreviation` выполняет следующие этапы обработки:
+
+1. **Определение типа сокращения** (`_define_abbreviation_type`):
+   - Проверяет, является ли строка аббревиатурой (содержит более одной заглавной буквы в каждом слове)
+   - Проверяет, является ли строка сокращением (одно слово, начинающееся с заглавной буквы)
+
+2. **Очистка префиксов** (`_remove_prefix`):
+   - Удаляет такие префиксы как "далее", различные виды тире
+   - Убирает лишние пробелы
+
+3. **Очистка от мусора** (`_remove_trash`):
+   - Удаляет такие подстроки как "ПАО", "ОАО", "№", "("
+   - Обрезает строку с начала до первого вхождения "мусорной" подстроки
+
+4. **Специальная обработка для аббревиатур** (`_process_abbreviation`):
+   - Извлекает заглавные буквы из короткой формы
+   - Проверяет соответствие заглавных букв началам слов в полной форме
+   - Обрезает полную форму до релевантной части
+
+5. **Специальная обработка для сокращений** (`_process_shortening`):
+   - Применяет стемминг (с помощью алгоритма Портера) к короткой форме
+   - Обрезает полную форму до релевантной части
+
+## Валидация
+
+- Проверяет длину полной формы (должна быть меньше MAX_LENGTH)
+- Проверяет, что полная форма длиннее короткой
+- Проверяет отсутствие полной формы в черном списке (BLACKLIST)
+- Для аббревиатур проверяет соответствие заглавных букв началам слов
+- Для сокращений проверяет корректность регистра букв и отсутствие специальных случаев
+
+Если какая-либо проверка не проходит, тип сокращения устанавливается как `UNKNOWN`.
+
+
+# Применение сокращений и аббревиатур
+
+Класс `Abbreviation` имеет метод `apply`, который принимает текст и возвращает текст с примененными сокращениями и аббревиатурами.
+
+Класс 
+

components/parser/abbreviations/__init__.py

@@ -0,0 +1,9 @@
+from .abbreviation import Abbreviation
+from .abbreviation_extractor import AbbreviationExtractor
+from .structures import AbbreviationsCollection
+
+__all__ = [
+    "AbbreviationExtractor",
+    "Abbreviation",
+    "AbbreviationsCollection",
+]

components/parser/abbreviations/abbreviation.py

@@ -0,0 +1,328 @@
+import re
+from dataclasses import dataclass
+from enum import Enum
+
+from components.parser.abbreviations.constants import (
+    ABBREVIATION_CLEANUP_REPLACEMENTS,
+    BLACKLIST,
+    DASH_PATTERN,
+    MAX_LENGTH,
+    PREFIX_PARTS_TO_REMOVE,
+    REMOVING_SUBSTRINGS,
+)
+from components.parser.abbreviations.porter import Porter
+
+
+class AbbreviationType(str, Enum):
+    ABBREVIATION = 'abbreviation'
+    SHORTENING = 'shortening'
+    UNKNOWN = 'unknown'
+
+
+@dataclass
+class Abbreviation:
+    short_form: str
+    full_form: str
+    abbreviation_type: AbbreviationType = AbbreviationType.UNKNOWN
+
+    _processed: bool = False
+    document_id: int | None = None
+
+    def process(self) -> 'Abbreviation':
+        """
+        Производит пост-обработку сокращения и полной формы.
+        - Определяет тип сокращения.
+        - Удаляет префикс из короткой формы и мусор из полной формы.
+        - В зависимости от типа сокращения адаптирует его под нужный вид.
+        """
+        if self._processed:
+            return
+
+        self._define_abbreviation_type()
+
+        self.short_form = self._remove_prefix(self.short_form)
+        self.full_form = self._remove_trash(self.full_form)
+
+        if self._abbreviation_type == AbbreviationType.SHORTENING:
+            self._process_shortening()
+        elif self._abbreviation_type == AbbreviationType.ABBREVIATION:
+            self._process_abbreviation()
+
+        self._processed = True
+
+        return self
+
+    def apply(self, text: str) -> str:
+        """
+        Применяет аббревиатуру к тексту.
+
+        Args:
+            text (str): Текст для обработки.
+
+        Returns:
+            str: Обработанный текст.
+        """
+        if self._abbreviation_type == AbbreviationType.UNKNOWN:
+            return text
+
+        if self._abbreviation_type == AbbreviationType.SHORTENING:
+            return self._apply_shortening(text)
+
+        elif self._abbreviation_type == AbbreviationType.ABBREVIATION:
+            return self._apply_abbreviation(text)
+
+    def _apply_shortening(self, text: str) -> str:
+        """
+        Применяет сокращение к тексту.
+
+        Args:
+            text (str): Текст для обработки.
+
+        Returns:
+            str: Обработанный текст.
+        """
+        matches = list(re.finditer(self.short_form, text))
+        for i in range(len(matches) - 1, 1, -1):
+            m = matches[i]
+            pos1 = m.start()
+            m2 = re.match(r'[A-Za-zА-Яа-я]+', text[pos1:])
+            pos2 = pos1 + m2.end()
+            explanation = self.full_form
+            m3 = re.match(r'[A-Za-zА-Яа-я]+', explanation)
+            explanation = explanation[m3.end() :]
+            text = text[:pos2] + explanation + text[pos2:]
+        return text
+
+    def _apply_abbreviation(self, text: str) -> str:
+        """
+        Применяет аббревиатуру к тексту.
+
+        Args:
+            text (str): Текст для обработки.
+
+        Returns:
+            str: Обработанный текст.
+        """
+        matches = list(re.finditer(self.short_form, text))
+        for i in range(len(matches) - 1, 0, -1):
+            m = matches[i]
+            text = f'{text[: m.start()]}{self.short_form} ({self.full_form}){text[m.end():]}'
+        return text
+
+    def _define_abbreviation_type(self) -> None:
+        """
+        Определяет тип сокращения.
+        """
+        if self._check_abbreviation(self.full_form):
+            self._abbreviation_type = AbbreviationType.ABBREVIATION
+        elif self._check_shortening(self.full_form):
+            self._abbreviation_type = AbbreviationType.SHORTENING
+        else:
+            self._abbreviation_type = AbbreviationType.UNKNOWN
+
+    def _process_shortening(self) -> None:
+        """
+        Обрабатывает сокращение.
+        """
+        key = Porter.stem(self.short_form)
+        pos = self.full_form.lower().rfind(key.lower())
+        if pos != -1:
+            self.full_form = self.full_form[pos:]
+            self.short_form = key
+        else:
+            self.abbreviation_type = AbbreviationType.UNKNOWN
+
+    def _process_abbreviation(self) -> None:
+        """
+        Обрабатывает аббревиатуру.
+        """
+        uppercase_letters = re.sub('[a-zа-я, ]', '', self.short_form)
+        processed_full_form = self._remove_trash_when_abbreviation(self.full_form)
+        words = processed_full_form.split()
+        uppercase_letters = uppercase_letters[::-1]
+        words = words[::-1]
+
+        if (len(words) <= len(uppercase_letters)) or ('ОКС НН' not in self.short_form):
+            self.abbreviation_type = AbbreviationType.UNKNOWN
+            return
+
+        match = self._check_abbreviation_matches_words(uppercase_letters, words)
+        if match:
+            self._process_matched_abbreviation(uppercase_letters, words)
+        else:
+            self._process_mismatched_abbreviation()
+
+    def _process_matched_abbreviation(
+        self,
+        uppercase_letters: str,
+        words: list[str],
+    ) -> None:
+        """
+        Обрабатывает аббревиатуру, которая совпадает с первыми буквами полной формы.
+
+        Args:
+            uppercase_letters (str): Заглавные буквы из сокращения.
+            words (list[str]): Список слов, которые составляют аббревиатуру.
+        """
+        pos = len(self.full_form)
+        for i in range(len(uppercase_letters)):
+            pos = self.full_form.rfind(words[i], 0, pos)
+
+        if pos != -1:
+            self.full_form = self.full_form[pos:]
+
+        else:
+            self.abbreviation_type = AbbreviationType.UNKNOWN
+
+    def _process_mismatched_abbreviation(self) -> None:
+        """
+        Обрабатывает аббревиатуру, которая не совпадает с первыми буквами полной формы.
+        """
+        first_letter = self.short_form[0]
+        pos = self.full_form.rfind(first_letter)
+        if pos != -1:
+            self.full_form = self.full_form[pos:]
+            first_letter = self.full_form[0]
+            second_letter = self.full_form[1]
+
+            if (
+                ('A' < first_letter < 'Z' or 'А' < first_letter < 'Я')
+                and ('a' < second_letter < 'z' or 'а' < second_letter < 'я')
+                and len(self.full_form) < MAX_LENGTH
+                and len(self.full_form) > len(self.short_form)
+                and self.full_form not in BLACKLIST
+                and '_' not in self.full_form
+            ):
+                return
+
+        self.abbreviation_type = AbbreviationType.UNKNOWN
+
+    def _check_abbreviation_matches_words(
+        self,
+        uppercase_letters: str,
+        words: list[str],
+    ) -> bool:
+        """
+        Проверяет, соответствует ли короткая форма аббревиатуре.
+
+        Args:
+            uppercase_letters (str): Заглавные буквы из сокращения.
+            words (list[str]): Список слов, которые составляют аббревиатуру.
+
+        Returns:
+            bool: True, если аббревиатура соответствует, False в противном случае.
+        """
+        for j in range(len(uppercase_letters)):
+            c1 = uppercase_letters[j].lower()
+            c2 = words[j][0].lower()
+            if c1 != c2:
+                return False
+
+        return True
+
+    @classmethod
+    def _check_abbreviation(cls, full_form: str) -> bool:
+        """
+        Проверяет, является ли строка аббревиатурой.
+
+        Args:
+            full_form (str): Строка для проверки.
+
+        Returns:
+            bool: True, если строка является аббревиатурой, False в противном случае.
+        """
+        s = cls._remove_prefix(full_form)
+        words = s.split()
+
+        for word in words:
+            n = cls._count_uppercase_letters(word)
+            if (n <= 1) and (word != 'и'):
+                return False
+
+        return True
+
+    @classmethod
+    def _check_shortening(cls, full_form: str) -> bool:
+        """
+        Проверяет, является ли строка сокращением.
+
+        Args:
+            full_form (str): Строка для проверки.
+
+        Returns:
+            bool: True, если строка является сокращением, False в противном случае.
+        """
+        s = cls._remove_prefix(full_form)
+        words = s.split()
+
+        if len(words) != 1:
+            return False
+
+        word = words[0]
+        if word[0].isupper() and word[1:].islower() and ('Компания' not in word):
+            return True
+
+        return False
+
+    @staticmethod
+    def _remove_prefix(s: str) -> str:
+        """
+        Удаляет из строки префиксы типа "далее - " и "далее – ".
+
+        Args:
+            s (str): Строка для обработки.
+
+        Returns:
+            str: Обработанная строка.
+        """
+        for prefix_part in PREFIX_PARTS_TO_REMOVE:
+            s = s.replace(prefix_part, '')
+        return s.strip()
+
+    @staticmethod
+    def _remove_trash(s: str) -> str:
+        """
+        Удаляет из строки такие подстроки, как "ПАО", "ОАО", "№", "(".
+
+        Args:
+            s (str): Строка для обработки.
+
+        Returns:
+            str: Обработанная строка.
+        """
+        for substring in REMOVING_SUBSTRINGS:
+            pos = s.find(substring)
+            if pos != -1:
+                s = s[:pos]
+        return s
+
+    @staticmethod
+    def _remove_trash_when_abbreviation(s: str) -> str:
+        """
+        Удаляет из строки такие подстроки, как " и ", " или ", ", ", " ГО".
+        Заменяет дефисы и тире на пробел.
+        Это необходимо для того, чтобы правильно сопоставить аббревиатуру с полной формой.
+
+        Args:
+            s (str): Строка для обработки.
+
+        Returns:
+            str: Обработанная строка.
+        """
+        for old, new in ABBREVIATION_CLEANUP_REPLACEMENTS.items():
+            s = s.replace(old, new)
+        s = re.sub(DASH_PATTERN, ' ', s)
+        return s
+
+    @staticmethod
+    def _count_uppercase_letters(s: str) -> int:
+        """
+        Считает количество заглавных букв в строке.
+
+        Args:
+            s (str): Строка для обработки.
+
+        Returns:
+            int: Количество заглавных букв.
+        """
+        return len(re.findall(r'[A-Z,А-Я]', s))

components/parser/abbreviations/abbreviation_extractor.py

@@ -0,0 +1,336 @@
+import re
+
+from natasha import Doc, MorphVocab, NewsEmbedding, NewsMorphTagger, Segmenter
+
+
+from .constants import (
+    ABBREVIATION_RE,
+    CLOSE_BRACKET_RE,
+    FIRST_CHARS_SET,
+    NEXT_MARKER_RE,
+    NON_SENTENCE_ENDINGS,
+    SECOND_CHARS_SET,
+    UPPERCASE_LETTER_RE,
+)
+from .structures import Abbreviation
+
+
+class AbbreviationExtractor:
+    def __init__(self):
+        """
+        Инициализация экстрактора сокращений.
+
+        Создает необходимые компоненты для лемматизации и компилирует регулярные выражения.
+        """
+        # Инициализация компонентов Natasha для лемматизации
+        self.segmenter = Segmenter()
+        self.morph_tagger = NewsMorphTagger(NewsEmbedding())
+        self.morph_vocab = MorphVocab()
+
+        # Компиляция регулярных выражений
+        self.next_re = re.compile(NEXT_MARKER_RE, re.IGNORECASE)
+        self.abbreviation_re = re.compile(ABBREVIATION_RE)
+        self.uppercase_letter_re = re.compile(UPPERCASE_LETTER_RE)
+        self.close_bracket_re = re.compile(CLOSE_BRACKET_RE)
+
+        self.delimiters = [
+            f'{char1} {char2} '.format(char1, char2)
+            for char1 in FIRST_CHARS_SET
+            for char2 in SECOND_CHARS_SET
+        ]
+
+    def extract_abbreviations_from_text(
+        self,
+        text: str,
+    ) -> list[Abbreviation]:
+        """
+        Извлечение всех сокращений из текста.
+
+        Args:
+            text: Текст для обработки
+
+        Returns:
+            list[Abbreviation]: Список найденных сокращений
+        """
+        sentences = self._extract_sentences_with_abbreviations(text)
+
+        abbreviations = [self._process_one_sentence(sentence) for sentence in sentences]
+        abbreviations = sum(abbreviations, [])  # делаем список одномерным
+        abbreviations = [abbreviation.process() for abbreviation in abbreviations]
+
+        return abbreviations
+
+    def _process_one_sentence(self, sentence: str) -> list[Abbreviation]:
+        """
+        Обработка одного предложения для извлечения сокращений.
+
+        Args:
+            sentence: Текст для обработки
+
+        Returns:
+            list[Abbreviation]: Список найденных сокращений
+        """
+        search_iter = self.next_re.finditer(sentence)
+        prev_index = 0
+
+        abbreviations = []
+
+        for match in search_iter:
+            abbreviation, prev_index = self._process_match(sentence, match, prev_index)
+            if abbreviation is not None:
+                abbreviations.append(abbreviation)
+
+        return abbreviations
+
+    def _process_match(
+        self,
+        sentence: str,
+        match: re.Match,
+        prev_index: int,
+    ) -> tuple[Abbreviation | None, int]:
+        """
+        Обработка одного совпадения с конструкцией "далее - {short_form}" для извлечения сокращений.
+
+        Args:
+            sentence: Текст для обработки
+            match: Совпадение для обработки
+            prev_index: Предыдущий индекс
+
+        Returns:
+            tuple[Abbreviation | None, int]: Найденное сокращение (None, если нет сокращения) и следующий индекс
+        """
+        start, end = match.start(), match.end()
+        text = sentence[start:]
+
+        index_close_parenthesis = self._get_close_parenthesis_index(text)
+        index_point = self._get_point_index(text, start)
+
+        prev_index += index_point
+        short_word = text[end : start + index_close_parenthesis].strip()
+
+        if len(short_word.split()) < 2:
+            abbreviation = self._process_match_for_word(
+                short_word, text, start, end, prev_index
+            )
+
+        else:
+            abbreviation = self._process_match_for_phrase(
+                short_word, text, start, end, prev_index
+            )
+
+        prev_index = start + index_close_parenthesis + 1
+
+        return abbreviation, prev_index
+
+    def _get_close_parenthesis_index(self, text: str) -> int:
+        """
+        Получение индекса закрывающей скобки в тексте.
+
+        Args:
+            text: Текст для обработки
+
+        Returns:
+            int: Индекс закрывающей скобки или 0, если не найдено
+        """
+        result = self.close_bracket_re.search(text)
+        if result is None:
+            return 0
+        return result.start()
+
+    def _get_point_index(self, text: str, start_index: int) -> int:
+        """
+        Получение индекса точки в тексте.
+
+        Args:
+            text: Текст для обработки
+            start_index: Индекс начала поиска
+
+        Returns:
+            int: Индекс точки или 0, если не найдено
+        """
+        result = text.rfind('.', 0, start_index - 1)
+        if result == -1:
+            return 0
+        return result
+
+    def _process_match_for_word(
+        self,
+        short_word: str,
+        text: str,
+        start_next_re_index: int,
+        end_next_re_index: int,
+        prev_index: int,
+    ) -> Abbreviation | None:
+        """
+        Обработка сокращения, состоящего из одного слова.
+
+        Args:
+            short_word: Сокращение
+            text: Текст для обработки
+            start_next_re_index: Индекс начала следующего совпадения
+            end_next_re_index: Индекс конца следующего совпадения
+            prev_index: Предыдущий индекс
+
+        Returns:
+            Abbreviation | None: Найденное сокращение или None, если нет сокращения
+        """
+        if self.abbreviation_re.findall(text) or (short_word == 'ПДн'):
+            return None
+
+        lemm_text = self._lemmatize_text(text[prev_index:start_next_re_index])
+        lemm_short_word = self._lemmatize_text(short_word)
+
+        search_word = re.search(lemm_short_word, lemm_text)
+
+        if not search_word:
+            start_text_index = self._get_start_text_index(
+                text,
+                start_next_re_index,
+                prev_index,
+            )
+
+            if start_text_index is None:
+                return None
+
+            full_text = text[prev_index + start_text_index : end_next_re_index]
+
+        else:
+            index_word = search_word.span()[1]
+            space_index = text[prev_index:start_next_re_index].rfind(' ', 0, index_word)
+            if space_index == -1:
+                space_index = 0
+            text = text[prev_index + space_index : start_next_re_index]
+
+        full_text = text.replace(')', '').replace('(', '').replace('', '- ')
+
+        return Abbreviation(
+            short_form=short_word,
+            full_form=full_text,
+        )
+
+    def _process_match_for_phrase(
+        self,
+        short_word: str,
+        text: str,
+        start_next_re_index: int,
+        end_next_re_index: int,
+        prev_index: int,
+    ) -> list[Abbreviation] | None:
+        """
+        Обработка сокращения, состоящего из нескольких слов.
+        В действительности производится обработка первого слова сокращения, а затем вместо него подставляется полное сокращение.
+
+        Args:
+            short_word: Сокращение
+            text: Текст для обработки
+            start_next_re_index: Индекс начала следующего совпадения
+            end_next_re_index: Индекс конца следующего совпадения
+            prev_index: Предыдущий индекс
+
+        Returns:
+            list[Abbreviation] | None: Найденные сокращения или None, если нет сокращений
+        """
+        first_short_word = short_word.split()[0]
+        result = self._process_match_for_word(
+            first_short_word, text, start_next_re_index, end_next_re_index, prev_index
+        )
+        if result is None:
+            return None
+        return Abbreviation(
+            short_form=short_word,
+            full_form=result.full_form,
+        )
+
+    def _get_start_text_index(
+        self,
+        text: str,
+        start_next_re_index: int,
+        prev_index: int,
+    ) -> int | None:
+        """
+        Получение индекса начала текста для поиска сокращения с учётом разделителей типа
+        "; - "
+        ": - "
+        ";  "
+        ": ‒ " и т.п.
+
+        Args:
+            text: Текст для обработки
+            start_next_re_index: Индекс начала следующего совпадения
+            prev_index: Предыдущий индекс
+
+        Returns:
+            int | None: Индекс начала текста или None, если не найдено
+        """
+        if prev_index == 0:
+            return 0
+
+        for delimiter in self.delimiters:
+            result = re.search(delimiter, text[prev_index:start_next_re_index])
+            if result is not None:
+                return result.span()[1]
+
+        return None
+
+    def _lemmatize_text(self, text: str) -> str:
+        """
+        Лемматизация текста.
+
+        Args:
+            text: Текст для лемматизации
+
+        Returns:
+            str: Лемматизированный текст
+        """
+        doc = Doc(text)
+        doc.segment(self.segmenter)
+        doc.tag_morph(self.morph_tagger)
+
+        for token in doc.tokens:
+            token.lemmatize(self.morph_vocab)
+
+        return ' '.join([token.lemma for token in doc.tokens])
+
+    def _extract_sentences_with_abbreviations(self, text: str) -> list[str]:
+        """
+        Разбивает текст на предложения с учетом специальных сокращений.
+
+        Точка после сокращений из NON_SENTENCE_ENDINGS не считается концом предложения.
+
+        Args:
+            text: Текст для разбиения
+
+        Returns:
+            list[str]: Список предложений
+        """
+        text = text.replace('\n', ' ')
+        sentence_endings = re.finditer(r'\.\s+[А-Я]', text)
+
+        sentences = []
+        start = 0
+
+        for match in sentence_endings:
+            end = match.start() + 1
+
+            # Проверяем, не заканчивается ли предложение на специальное сокращение
+            preceding_text = text[start:end]
+            words = preceding_text.split()
+
+            if words and any(
+                words[-1].rstrip('.').startswith(abbr) for abbr in NON_SENTENCE_ENDINGS
+            ):
+                continue
+
+            sentence = text[start:end].strip()
+            sentences.append(sentence)
+            start = end + 1
+
+        # Добавляем последнее предложение
+        if start < len(text):
+            sentences.append(text[start:].strip())
+
+        return [
+            sentence
+            for sentence in sentences
+            if self.next_re.search(sentence) is not None
+        ]

components/parser/abbreviations/constants.py

@@ -0,0 +1,54 @@
+# Регулярные выражения
+NEXT_MARKER_RE = r'далее (--|־|᠆|‐|‑|‒|–|—|―|⸺|⸻|﹘|﹣|－|-|-)'
+ABBREVIATION_RE = (
+    r'\b[А-Я0-9]{1,}(?:\s?[А-Я0-9]{1,}|[:\-.]?[А-Я0-9]{1,}|[а-я]{1}[А-Я0-9]{1,})*\b'
+)
+UPPERCASE_LETTER_RE = r'[A-ZА-Я]'
+CLOSE_BRACKET_RE = r'\)'
+
+# Сокращения, после которых точка не означает конец предложения
+NON_SENTENCE_ENDINGS = ['г', 'д-р', 'т.е', 'и т.д', 'и т.п', 'и т.п.', 'ул', 'пр']
+
+FIRST_CHARS_SET = {'.', ':', ';'}
+SECOND_CHARS_SET = {
+    '‒',
+    '–',
+    '—',
+    '―',
+    '⸺',
+    '⸻',
+    '﹘',
+    '﹣',
+    '－',
+    '-',
+    '-',
+    '-',
+    '\uf0b7',
+    '',
+}
+
+BLACKLIST = [
+    'Ненецкого муниципального района',
+    'Изменение идентифицирующих',
+    'Systems, Applications and Products in Data Processing Enterprise Resource Planning',
+    'Российской Федерации, Уставом',
+    'Собственника Объекта защиты',
+]
+
+REMOVING_SUBSTRINGS = ['ПАО', 'ОАО', '№', '(']
+
+MAX_LENGTH = 100
+
+# Strings to remove from abbreviations
+PREFIX_PARTS_TO_REMOVE = ['далее', '–', '-']
+
+# Strings to remove when processing abbreviations
+ABBREVIATION_CLEANUP_REPLACEMENTS = {
+    ' и ': ' ',
+    ' или ': ' ',
+    ', ': ' ',
+    ' ГО': ' ',
+}
+
+# Regex pattern for dashes/hyphens to be replaced with space
+DASH_PATTERN = '(-|-|־|᠆|‐|‑|‒|–|—|―|⸺|⸻|﹘|﹣|－)'