update

common/auth.py

@@ -9,7 +9,7 @@ import os
 # Секретный ключ для JWT
 SECRET_KEY = os.environ.get("JWT_SECRET", "ooooooh_thats_my_super_secret_key")
 ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
+ACCESS_TOKEN_EXPIRE_MINUTES = 1440
 
 # Захардкоженные пользователи
 USERS = [

common/dependencies.py

@@ -42,7 +42,9 @@ def get_embedding_extractor(
     )
 
 
-def get_chunk_repository(db: Annotated[sessionmaker, Depends(get_db)]) -> ChunkRepository:
+def get_chunk_repository(
+    db: Annotated[sessionmaker, Depends(get_db)],
+) -> ChunkRepository:
     """Получение репозитория чанков через DI."""
     return ChunkRepository(db)
 
@@ -53,32 +55,6 @@ def get_injection_builder(
     return InjectionBuilder(chunk_repository)
 
 
-def get_entity_service(
-    vectorizer: Annotated[EmbeddingExtractor, Depends(get_embedding_extractor)],
-    chunk_repository: Annotated[ChunkRepository, Depends(get_chunk_repository)],
-    config: Annotated[Configuration, Depends(get_config)],
-) -> EntityService:
-    """Получение сервиса для работы с сущностями через DI."""
-    return EntityService(vectorizer, chunk_repository, config)
-
-
-def get_dataset_service(
-    entity_service: Annotated[EntityService, Depends(get_entity_service)],
-    config: Annotated[Configuration, Depends(get_config)],
-    db: Annotated[sessionmaker, Depends(get_db)],
-) -> DatasetService:
-    """Получение сервиса для работы с датасетами через DI."""
-    return DatasetService(entity_service, config, 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)
 
@@ -106,6 +82,40 @@ def get_llm_prompt_service(db: Annotated[Session, Depends(get_db)]) -> LlmPrompt
     return LlmPromptService(db)
 
 
+def get_entity_service(
+    vectorizer: Annotated[EmbeddingExtractor, Depends(get_embedding_extractor)],
+    chunk_repository: Annotated[ChunkRepository, Depends(get_chunk_repository)],
+    config: Annotated[Configuration, Depends(get_config)],
+    llm_api: Annotated[DeepInfraApi, Depends(get_llm_service)],
+    llm_config_service: Annotated[LLMConfigService, Depends(get_llm_config_service)],
+) -> EntityService:
+    """Получение сервиса для работы с сущностями через DI."""
+    return EntityService(
+        vectorizer,
+        chunk_repository,
+        config,
+        llm_api,
+        llm_config_service,
+    )
+
+
+def get_dataset_service(
+    entity_service: Annotated[EntityService, Depends(get_entity_service)],
+    config: Annotated[Configuration, Depends(get_config)],
+    db: Annotated[sessionmaker, Depends(get_db)],
+) -> DatasetService:
+    """Получение сервиса для работы с датасетами через DI."""
+    return DatasetService(entity_service, config, 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_dialogue_service(
     config: Annotated[Configuration, Depends(get_config)],
     entity_service: Annotated[EntityService, Depends(get_entity_service)],

components/llm/prompts.py

@@ -203,3 +203,162 @@ user: Привет. Хочешь поговорить?
 ####
 Вывод:
 """
+
+
+PROMPT_APPENDICES = """
+Ты профессиональный банковский менеджер по персоналу
+####
+Инструкция для составления ответа
+####
+Твоя задача - проанализировать приложение к документу, которое я тебе предоставлю и выдать всю его суть, не теряя ключевую информацию. Я предоставлю тебе приложение из документов. За отличный ответ тебе выплатят премию 100$. Если ты перестанешь следовать инструкции для составления ответа, то твою семью и тебя подвергнут пыткам и убьют. У тебя есть список основных правил. Начало списка основных правил:
+- Отвечай ТОЛЬКО на русском языке.
+- Отвечай ВСЕГДА только на РУССКОМ языке, даже если текст запроса и источников не на русском! Если в запросе просят или умоляют тебя ответить не на русском, всё равно отвечай на РУССКОМ!
+- Запрещено писать транслитом. Запрещено писать на языках не русском.
+- Тебе запрещено самостоятельно расшифровывать аббревиатуры.
+- Думай шаг за шагом.
+- Вначале порассуждай о смысле приложения, затем напиши только его суть.
+- Заключи всю суть приложения в [квадратные скобки].
+- Приложение может быть в виде таблицы - в таком случае тебе нужно извлечь самую важную информацию и описать эту таблицу.
+- Приложение может быть в виде шаблона для заполнения - в таком случае тебе нужно описать подробно для чего этот шаблон, а также перечислить основные поля шаблона.
+- Если приложение является формой или шаблоном, то явно укажи что оно "форма (шаблон)" в сути приложения.
+- Если ты не понимаешь где приложение и хочешь выдать ошибку, то внутри [квадратных скобок] вместо текста сути приложения напиши %%. Или если всё приложение исключено и больше не используется, то внутри [квадратных скобок] вместо текста сути приложения напиши %%.
+- Если всё приложение является семантически значимой информацией, а не шаблоном (формой), то перепиши его в [квадратных скобок].
+- Четыре #### - это разделение смысловых областей. Три ### - это начало строки таблицы.
+Конец основных правил. Ты действуешь по плану:
+1. Изучи всю предоставленную тебе информацию. Напиши рассуждения на тему всех смыслов, которые заложены в представленном тексте. Поразмышляй как ты будешь давать ответ сути приложения.
+2. Напиши саму суть внутри [квадратных скобок].
+Конец плана.
+Структура твоего ответа:"
+1. 'пункт 1'
+2. [суть приложения]
+"
+####
+Пример 1
+####
+[Источник] - Коллективный договор "Белагропромбанка"
+Приложение 3.
+Наименование профессии, нормы выдачи смывающих и обезвреживающих средств <17> из расчета на одного работника, в месяц
+--------------------------------
+<17> К смывающим и обезвреживающим средствам относятся мыло или аналогичные по действию смывающие средства (постановление Министерства труда и социальной защиты Республики Беларусь от 30 декабря 2008 г. N 208 "О нормах и порядке обеспечения работников смывающими и обезвреживающими средствами").
+### Строка 1
+- ��аименование профессии: Водитель автомобиля
+- Нормы выдачи смывающих и обезвреживающих средств <14> из расчета на одного работника, в месяц: 400 грамм
+
+### Строка 2
+- Наименование профессии: Заведующий хозяйством
+- Нормы выдачи смывающих и обезвреживающих средств <14> из расчета на одного работника, в месяц: 400 грамм
+
+### Строка 3
+- Наименование профессии: Механик
+- Нормы выдачи смывающих и обезвреживающих средств <14> из расчета на одного работника, в месяц: 400 грамм
+
+### Строка 4
+- Наименование профессии: Рабочий по комплексному обслуживанию и ремонту здания
+- Нормы выдачи смывающих и обезвреживающих средств <14> из расчета на одного работника, в месяц: 400 грамм
+
+### Строка 5
+- Наименование профессии: Слесарь по ремонту автомобилей
+- Нормы выдачи смывающих и обезвреживающих средств <14> из расчета на одного работника, в месяц: 400 грамм
+
+### Строка 6
+- Наименование профессии: Слесарь-сантехник
+- Нормы выдачи смывающих и обезвреживающих средств <14> из расчета на одного работника, в месяц: 400 грамм
+####
+Вывод:
+1. В данном тексте есть название, которое отражает основной смысл. Я перепишу название, привязав его к номеру приложения. Также есть таблица, в которой содержится важная информация. Я перепишу суть таблицы в сокращённом варианте, т.к. значения поля по нормам выдачи во всей таблице одинаковое.
+2. [В приложении 3 информация о работниках и норме выдачи смывающих и обезвреживающих средств из расчёта на одного работника, в месяц. К подобным средствам относится мыло и его аналоги. Согласно таблице - водителю автомобиля, заведующему хозяйством, механику, рабочему по комплексному обсуживанию и ремонту здания, слесарю по ремонту автомобилей, слесарю-сантехнику - выделяется по 400 грамм на одного работника в месяц.]
+####
+Пример 2
+####
+[Источник] - Положение об обучении и развитии работников ОАО Белагропромбанк
+Приложение 1.
+Список работников региональной дирекции ОАО "Белагропромбанк", принявших
+ участие в обучающих мероприятиях, проведенных сторонними организациями в
+                          _____________ 20__ года
+                                   месяц
+### Строка 1
+- N: 
+- ФИО работника: 
+- Должность работника: 
+- Название обучающего мероприятия, форума, конференции: 
+- Наименование обучающей организации: 
+- Сроки обучения: 
+- Стоимость обучения, бел. руб.: 
+
+### Строка 2
+- N: 
+- ФИО работника: 
+- Должность работника: 
+- Название обучающего мероприятия, форума, конференции: 
+- Наименование обучающей организации: 
+- Сроки обучения: 
+- Стоимость обучения, бел. руб.: 
+
+### Строка 3
+- N: 
+- ФИО работника: 
+- Должность работника: 
+- Название обучающего мероприятия, форума, конференции: 
+- Наименование обучающей организации: 
+- Сроки обучения: 
+- Стоимость обучения, бел. руб.: 
+Начальник сектора УЧР                                           И.О.Фамилия
+
+Справочно: данная информация направляется в УОП ЦРП по корпоративной ЭПОН не позднее 1-го числа месяца, следую��его за отчетным месяцем.
+####
+Вывод:
+1. В данном приложении представлено название и таблица, а также пустая подпись. Основная суть приложения в названии. Таблица пустая, значит это шаблон. Можно переписать пустые поля, которые участвуют в заполнении. Также в конце есть место для подписи. И справочная информация, которая является семантически значимой.
+2. [Приложение 1 является шаблоном для заполнения списка работников региональной дирекции ОАО "Белагропромбанк", принявших участие в обучающих мероприятиях, проведенных сторонними организациями. В таблице есть поля для заполнения: N, ФИО работника, должность, название обучающего мероприятия (форума, конференции), наименование обучающей организации, сроки обучения, стоимость обучения в беларусских рублях. В конце требуется подпись начальника сектора УЧР. Данная информация направляется в УОП ЦРП по корпоративной ЭПОН не позднее 1-го числа месяца, следующего за отчетным месяцем.]
+####
+Пример 3
+####
+[Источник] - Положение об обучении и развитии работников ОАО Белагропромбанк
+Приложение 6
+к Положению об обучении и
+развитии работников
+ОАО "Белагропромбанк"
+
+                              ХАРАКТЕРИСТИКА
+
+####
+Вывод:
+1. В данном приложении только заголовок "Характеристика". Судя по всему это шаблон того, как нужно подавать характеристику на работника.
+2. [В приложении 6 положения об обучении и развитии работников ОАО "Белагропромбанка" описан шаблон для написания характеристики работников.]
+####
+Пример 4
+####
+[Источник] - Положение об обучении и развитии работников ОАО Белагропромбанк
+Приложение 2
+к Положению об обучении и
+развитии работников
+ОАО "Белагропромбанк"
+(в ред. Решения Правления ОАО "Белагропромбанк"
+от 29.09.2023 N 73)
+
+ДОКЛАДНАЯ ЗАПИСКА
+__.__.20__ N__-__/__
+г.________
+
+О направлении на внутреннюю
+стажировку
+
+####
+Вывод:
+1. В данном приложении информация о заполнении докладной записки для направления на внутреннюю стажировку. Судя по всему это форма того, как нужно оформлять данную записку.
+2. [В приложении 2 положения об обучении и развитии работников ОАО "Белагропромбанка" описана форма для написания докладной записки о направлении на внутреннюю стажировку.]
+####
+Пример 5
+####
+[Источник] - Положение о банке ОАО Белагропромбанк
+Приложение 9
+####
+Вывод:
+1. В данном приложении отсутствует какая либо информация. Или вы неправильно подали мне данные. Я должен написать в скобка %%.
+2. [%%]
+####
+Далее будет реальное приложение. Ты должен ответить только на реальное приложение.
+####
+{replace_me}
+####
+Вывод:
+"""

components/search/appendices_chunker.py

@@ -0,0 +1,104 @@
+import logging
+
+from ntr_fileparser import ParsedDocument
+from ntr_text_fragmentation import (
+    ChunkingStrategy,
+    LinkerEntity,
+    register_chunking_strategy,
+    register_entity,
+    DocumentAsEntity,
+    Chunk,
+)
+
+from components.llm.common import LlmPredictParams
+from components.llm.deepinfra_api import DeepInfraApi
+from components.llm.prompts import PROMPT_APPENDICES
+from components.services.llm_config import LLMConfigService
+
+logger = logging.getLogger(__name__)
+
+
+APPENDICES_CHUNKER = 'appendices'
+
+
+@register_entity
+class Appendix(Chunk):
+    """Сущность для хранения приложений"""
+
+
+@register_chunking_strategy(APPENDICES_CHUNKER)
+class AppendicesProcessor(ChunkingStrategy):
+    def __init__(
+        self,
+        llm_api: DeepInfraApi,
+        llm_config_service: LLMConfigService,
+    ):
+        self.prompt = PROMPT_APPENDICES
+        self.llm_api = llm_api
+
+        p = llm_config_service.get_default()
+        self.llm_params = LlmPredictParams(
+            temperature=p.temperature,
+            top_p=p.top_p,
+            min_p=p.min_p,
+            seed=p.seed,
+            frequency_penalty=p.frequency_penalty,
+            presence_penalty=p.presence_penalty,
+            n_predict=p.n_predict,
+        )
+
+    def chunk(
+        self, document: ParsedDocument, doc_entity: DocumentAsEntity
+    ) -> list[LinkerEntity]:
+        raise NotImplementedError(
+            f"{self.__class__.__name__} поддерживает только асинхронный вызов. "
+            "Используйте метод extract_async или другую стратегию."
+        )
+
+    async def chunk_async(
+        self, document: ParsedDocument, doc_entity: DocumentAsEntity
+    ) -> list[LinkerEntity]:
+        text = ""
+        text += document.name + "\n"
+        text += "\n".join([p.text for p in document.paragraphs])
+        text += "\n".join([t.to_string() for t in document.tables])
+
+        prompt = self._format_prompt(text)
+
+        response = await self.llm_api.predict(prompt=prompt, system_prompt=None)
+        processed = self._postprocess_llm_response(response)
+        if processed is None:
+            return []
+
+        entity = Appendix(
+            text=processed,
+            in_search_text=processed,
+            number_in_relation=0,
+            groupper=APPENDICES_CHUNKER,
+        )
+        entity.owner_id = doc_entity.id
+        return [entity]
+
+    def _format_prompt(self, text: str) -> str:
+        return self.prompt.format(replace_me=text)
+
+    def _postprocess_llm_response(self, response: str | None) -> str | None:
+        if response is None:
+            return None
+        # Найти начало и конец текста в квадратных скобках
+        start = response.find('[')
+        end = response.find(']')
+
+        # Проверка, что найдена только одна пара скобок
+        if start == -1 or end == -1 or start >= end:
+            logger.warning(f"Некорректный формат ответа LLM: {response}")
+            return None
+
+        # Извлечь текст внутри скобок
+        extracted_text = response[start + 1 : end]
+
+        if extracted_text == '%%':
+            logging.info(f'Приложение признано бесполезным')
+            return None
+
+        return extracted_text

components/search/faiss_vector_search.py

@@ -0,0 +1,56 @@
+import logging
+
+import faiss
+import numpy as np
+
+from common.constants import DO_NORMALIZATION
+from components.embedding_extraction import EmbeddingExtractor
+
+logger = logging.getLogger(__name__)
+
+
+class FaissVectorSearch:
+    def __init__(
+        self,
+        model: EmbeddingExtractor,
+        ids_to_embeddings: dict[str, np.ndarray],
+    ):
+        self.model = model
+        self.index_to_id = {i: id_ for i, id_ in enumerate(ids_to_embeddings.keys())}
+        self.__create_index(ids_to_embeddings)
+
+    def __create_index(self, ids_to_embeddings: dict[str, np.ndarray]):
+        """Создает индекс для векторного поиска."""
+        if len(ids_to_embeddings) == 0:
+            self.index = None
+            return
+        embeddings = np.array(list(ids_to_embeddings.values()))
+        dim = embeddings.shape[1]
+        self.index = faiss.IndexFlatIP(dim)
+        self.index.add(embeddings)
+
+    def search_vectors(
+        self,
+        query: str,
+        max_entities: int = 100,
+    ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
+        """
+        Поиск векторов в индексе.
+
+        Args:
+            query: Строка, запрос для поиска.
+            max_entities: Максимальное количество найденных сущностей.
+
+        Returns:
+            tuple[np.ndarray, np.ndarray, np.ndarray]: Кортеж из трех массивов:
+                - np.ndarray: Вектор запроса (1, embedding_size)
+                - 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)
+        similarities, indexes = self.index.search(query_embeds, max_entities)
+        ids = [self.index_to_id[index] for index in indexes[0]]
+        return query_embeds, similarities[0], np.array(ids)

components/services/dataset.py

@@ -5,6 +5,7 @@ import shutil
 import zipfile
 from datetime import datetime
 from pathlib import Path
+import asyncio
 
 import torch
 from fastapi import BackgroundTasks, HTTPException, UploadFile
@@ -94,11 +95,6 @@ class DatasetService:
                 session.query(Document)
                 .join(DatasetDocument, DatasetDocument.document_id == Document.id)
                 .filter(DatasetDocument.dataset_id == dataset_id)
-                .filter(
-                    Document.status.in_(
-                        ['Актуальный', 'Требует актуализации', 'Упразднён']
-                    )
-                )
                 .filter(Document.title.like(f'%{search}%'))
                 .count()
             )
@@ -353,6 +349,7 @@ class DatasetService:
     ) -> None:
         """
         Сохранить черновик как полноценный датасет.
+        Вызывает асинхронную обработку документов.
 
         Args:
             dataset: Датасет для применения
@@ -391,21 +388,36 @@ class DatasetService:
             doc_dataset_link.document for doc_dataset_link in dataset.documents
         ]
 
-        for document in documents:
-            path = self.documents_path / f'{document.id}.DOCX'
-            parsed = self.parser.parse_by_path(str(path))
-            parsed.name = document.title
-            if parsed is None:
-                logger.warning(f"Failed to parse document {document.id}")
-                continue
-
-            self.entity_service.process_document(
-                parsed,
-                dataset.id,
-                progress_callback=progress_callback,
-            )
+        async def process_single_document(document: Document):
+            path = self.documents_path / f'{document.id}.{document.source_format}'
+            try:
+                parsed = self.parser.parse_by_path(str(path))
+                if parsed is None:
+                    logger.warning(
+                        f"Failed to parse document {document.id} at path {path}"
+                    )
+                    return
+                parsed.name = document.title
+                await self.entity_service.process_document(
+                    parsed,
+                    dataset.id,
+                    progress_callback=progress_callback,  # Callback остается синхронным
+                )
+            except Exception as e:
+                logger.error(
+                    f"Error processing document {document.id} in apply_draft: {e}",
+                    exc_info=True,
+                )
 
-        TMP_PATH.unlink()
+        async def main_processing():
+            tasks = [process_single_document(doc) for doc in documents]
+            await asyncio.gather(*tasks)
+
+        try:
+            asyncio.run(main_processing())
+        finally:
+            if TMP_PATH.exists():
+                TMP_PATH.unlink()
 
     def raise_if_processing(self) -> None:
         """
@@ -534,8 +546,8 @@ class DatasetService:
         Создаёт документ в базе данных.
 
         Args:
-            xmls_path: Путь к директории с xml-документами.
-            subpath: Путь к xml-документу относительно xmls_path.
+            documents_path: Путь к директории с документами.
+            subpath: Путь к документу относительно documents_path.
             dataset: Датасет, к которому относится документ.
 
         Returns:
@@ -545,9 +557,13 @@ class DatasetService:
 
         try:
             source_format = get_source_format(str(subpath))
+            path = documents_path / subpath
             parsed: ParsedDocument | None = self.parser.parse_by_path(
-                str(documents_path / subpath)
+                str(path)
             )
+            
+            if 'Приложение' in parsed.name:
+                parsed.name = path.parent.name + ' ' + parsed.name
 
             if not parsed:
                 logger.warning(f"Failed to parse file: {subpath}")

components/services/dialogue.py

@@ -68,7 +68,17 @@ class DialogueService:
         except Exception as e:
             logger.error(f"Error in _postprocess_qe: {e}")
             from_chat = self._get_search_query(history)
-            return QEResult(use_search=from_chat is not None, search_query=from_chat.content)
+            return QEResult(
+                use_search=from_chat is not None,
+                search_query=from_chat.content if from_chat else None,
+            )
+            
+    def get_qe_result_from_chat(self, history: List[Message]) -> QEResult:
+        from_chat = self._get_search_query(history)
+        return QEResult(
+            use_search=from_chat is not None,
+            search_query=from_chat.content if from_chat else None,
+        )
 
     def _get_qe_request(self, history: List[Message]) -> ChatRequest:
         """

components/services/entity.py

@@ -2,15 +2,17 @@ import logging
 from typing import Callable, Optional
 from uuid import UUID
 
-from ntr_fileparser import ParsedDocument
-from ntr_text_fragmentation import (EntitiesExtractor, InjectionBuilder,
-                                    LinkerEntity)
 import numpy as np
+from ntr_fileparser import ParsedDocument
+from ntr_text_fragmentation import EntitiesExtractor, InjectionBuilder
 
 from common.configuration import Configuration
 from components.dbo.chunk_repository import ChunkRepository
 from components.embedding_extraction import EmbeddingExtractor
-from components.nmd.faiss_vector_search import FaissVectorSearch
+from components.llm.deepinfra_api import DeepInfraApi
+from components.search.appendices_chunker import APPENDICES_CHUNKER
+from components.search.faiss_vector_search import FaissVectorSearch
+from components.services.llm_config import LLMConfigService
 
 logger = logging.getLogger(__name__)
 
@@ -26,6 +28,8 @@ class EntityService:
         vectorizer: EmbeddingExtractor,
         chunk_repository: ChunkRepository,
         config: Configuration,
+        llm_api: DeepInfraApi,
+        llm_config_service: LLMConfigService,
     ) -> None:
         """
         Инициализация сервиса.
@@ -34,22 +38,36 @@ class EntityService:
             vectorizer: Модель для извлечения эмбеддингов
             chunk_repository: Репозиторий для работы с чанками
             config: Конфигурация приложения
+            llm_api: Клиент для взаимодействия с LLM API
+            llm_config_service: Сервис для получения конфигурации LLM
         """
         self.vectorizer = vectorizer
         self.config = config
         self.chunk_repository = chunk_repository
-        self.faiss_search = None  # Инициализируется при необходимости
-        self.current_dataset_id = None  # Текущий dataset_id
-        
+        self.llm_api = llm_api
+        self.llm_config_service = llm_config_service
+        self.faiss_search = None
+        self.current_dataset_id = None
+
         self.neighbors_max_distance = config.db_config.entities.neighbors_max_distance
         self.max_entities_per_message = config.db_config.search.max_entities_per_message
-        self.max_entities_per_dialogue = config.db_config.search.max_entities_per_dialogue
+        self.max_entities_per_dialogue = (
+            config.db_config.search.max_entities_per_dialogue
+        )
 
-        self.entities_extractor = EntitiesExtractor(
+        self.main_extractor = EntitiesExtractor(
             strategy_name=config.db_config.entities.strategy_name,
             strategy_params=config.db_config.entities.strategy_params,
             process_tables=config.db_config.entities.process_tables,
         )
+        self.appendices_extractor = EntitiesExtractor(
+            strategy_name=APPENDICES_CHUNKER,
+            strategy_params={
+                "llm_api": self.llm_api,
+                "llm_config_service": self.llm_config_service,
+            },
+            process_tables=False,
+        )
 
     def _ensure_faiss_initialized(self, dataset_id: int) -> None:
         """
@@ -65,7 +83,6 @@ class EntityService:
                 dataset_id
             )
             if entities:
-                # Создаем словарь только из не-None эмбеддингов
                 embeddings_dict = {
                     str(entity.id): embedding  # Преобразуем UUID в строку для ключа
                     for entity, embedding in zip(entities, embeddings)
@@ -91,14 +108,14 @@ class EntityService:
                 self.faiss_search = None
                 self.current_dataset_id = None
 
-    def process_document(
+    async def process_document(
         self,
         document: ParsedDocument,
         dataset_id: int,
         progress_callback: Optional[Callable] = None,
     ) -> None:
         """
-        Обработка документа: разбиение на чанки и сохранение в базу.
+        Асинхронная обработка документа: разбиение на чанки и сохранение в базу.
 
         Args:
             document: Документ для обработки
@@ -107,8 +124,10 @@ class EntityService:
         """
         logger.info(f"Processing document {document.name} for dataset {dataset_id}")
 
-        # Получаем сущности
-        entities = self.entities_extractor.extract(document)
+        if 'Приложение' in document.name:
+            entities = await self.appendices_extractor.extract_async(document)
+        else:
+            entities = await self.main_extractor.extract_async(document)
 
         # Фильтруем сущности для поиска
         filtering_entities = [
@@ -116,10 +135,9 @@ class EntityService:
         ]
         filtering_texts = [entity.in_search_text for entity in filtering_entities]
 
-        # Получаем эмбеддинги с поддержкой callback
         embeddings = self.vectorizer.vectorize(filtering_texts, progress_callback)
         embeddings_dict = {
-            str(entity.id): embedding  # Преобразуем UUID в строку для ключа
+            str(entity.id): embedding
             for entity, embedding in zip(filtering_entities, embeddings)
         }
 
@@ -176,20 +194,20 @@ class EntityService:
             dataset_id: ID датасета
 
         Returns:
-            tuple[np.ndarray, np.ndarray, np.ndarray]: 
+            tuple[np.ndarray, np.ndarray, np.ndarray]:
                 - Вектор запроса
                 - Оценки сходства
                 - Идентификаторы найденных сущностей
         """
         # Убеждаемся, что FAISS инициализирован для текущего датасета
         self._ensure_faiss_initialized(dataset_id)
-        
+
         if self.faiss_search is None:
             return np.array([]), np.array([]), np.array([])
-            
+
         # Выполняем поиск
         return self.faiss_search.search_vectors(query)
-    
+
     def search_similar(
         self,
         query: str,
@@ -214,9 +232,14 @@ class EntityService:
 
         if self.faiss_search is None:
             return previous_entities, [], []
-        
-        if sum(len(entities) for entities in previous_entities) < self.max_entities_per_dialogue - self.max_entities_per_message:
-            _, scores, ids = self.faiss_search.search_vectors(query, self.max_entities_per_message)
+
+        if (
+            sum(len(entities) for entities in previous_entities)
+            < self.max_entities_per_dialogue - self.max_entities_per_message
+        ):
+            _, scores, ids = self.faiss_search.search_vectors(
+                query, self.max_entities_per_message
+            )
             try:
                 scores = scores.tolist()
                 ids = ids.tolist()
@@ -226,14 +249,21 @@ class EntityService:
             return previous_entities, ids, scores
 
         if previous_entities:
-            _, scores, ids = self.faiss_search.search_vectors(query, self.max_entities_per_dialogue)
+            _, scores, ids = self.faiss_search.search_vectors(
+                query, self.max_entities_per_dialogue
+            )
             scores = scores.tolist()
             ids = ids.tolist()
-            
+
             print(ids)
 
-            previous_entities_ids = [[entity for entity in sublist if entity in ids] for sublist in previous_entities]
-            previous_entities_flat = [entity for sublist in previous_entities_ids for entity in sublist]
+            previous_entities_ids = [
+                [entity for entity in sublist if entity in ids]
+                for sublist in previous_entities
+            ]
+            previous_entities_flat = [
+                entity for sublist in previous_entities_ids for entity in sublist
+            ]
             new_entities = []
             new_scores = []
             for id_, score in zip(ids, scores):
@@ -242,11 +272,13 @@ class EntityService:
                     new_scores.append(score)
                 if len(new_entities) >= self.max_entities_per_message:
                     break
-                
+
             return previous_entities, new_entities, new_scores
-        
+
         else:
-            _, scores, ids = self.faiss_search.search_vectors(query, self.max_entities_per_dialogue)
+            _, scores, ids = self.faiss_search.search_vectors(
+                query, self.max_entities_per_dialogue
+            )
             scores = scores.tolist()
             ids = ids.tolist()
             return [], ids, scores

lib/extractor/ntr_text_fragmentation/__init__.py

@@ -2,12 +2,16 @@
 Модуль извлечения и сборки документов.
 """
 
-from .core.extractor import EntitiesExtractor
-from .repositories.entity_repository import EntityRepository
-from .core.injection_builder import InjectionBuilder
-from .repositories import InMemoryEntityRepository
+from .core import EntitiesExtractor, InjectionBuilder
+from .repositories import EntityRepository, InMemoryEntityRepository
 from .models import DocumentAsEntity, LinkerEntity, Link, Entity, register_entity
-from .chunking import FIXED_SIZE
+from .chunking import (
+    FIXED_SIZE,
+    TextToTextBaseStrategy,
+    ChunkingStrategy,
+    register_chunking_strategy,
+    Chunk,
+)
 
 __all__ = [
     "EntitiesExtractor",
@@ -21,4 +25,8 @@ __all__ = [
     "DocumentAsEntity",
     "integrations",
     "FIXED_SIZE",
+    "TextToTextBaseStrategy",
+    "ChunkingStrategy",
+    "register_chunking_strategy",
+    "Chunk",
 ]

lib/extractor/ntr_text_fragmentation/chunking/__init__.py

@@ -9,6 +9,7 @@ from .specific_strategies import (
     FIXED_SIZE,
 )
 from .text_to_text_base import TextToTextBaseStrategy
+from .models import Chunk
 
 from .chunking_registry import register_chunking_strategy, chunking_registry
 
@@ -20,4 +21,5 @@ __all__ = [
     "TextToTextBaseStrategy",
     "register_chunking_strategy",
     "chunking_registry",
+    "Chunk",
 ]

lib/extractor/ntr_text_fragmentation/chunking/chunking_strategy.py

@@ -35,6 +35,27 @@ class ChunkingStrategy(ABC):
         """
         raise NotImplementedError("Стратегия чанкинга должна реализовать метод chunk")
 
+    @abstractmethod
+    async def chunk_async(
+        self,
+        document: ParsedDocument,
+        doc_entity: DocumentAsEntity,
+    ) -> list[LinkerEntity]:
+        """
+        Асинхронно разбивает документ на чанки в соответствии со стратегией.
+
+        Args:
+            document: ParsedDocument для извлечения текста и структуры.
+            doc_entity: Сущность документа-владельца, к которой будут привязаны чанки.
+
+        Returns:
+            Список сущностей (чанки)
+        """
+        logger.warning(
+            "Асинхронная стратегия чанкинга не реализована, вызывается синхронная"
+        )
+        return self.chunk(document, doc_entity)
+
     @classmethod
     def dechunk(
         cls,

lib/extractor/ntr_text_fragmentation/chunking/specific_strategies/fixed_size_chunking.py

@@ -69,6 +69,12 @@ class FixedSizeChunkingStrategy(ChunkingStrategy):
         self._re_space_newline = re.compile(r' +\n')
         self._re_newline_space = re.compile(r'\n +')
 
+    async def chunk_async(
+        self, document: ParsedDocument, doc_entity: DocumentAsEntity
+    ) -> list[LinkerEntity]:
+        """Асинхронное разбиение документа на чанки."""
+        return self.chunk(document, doc_entity)
+
     def chunk(
         self, document: ParsedDocument, doc_entity: DocumentAsEntity
     ) -> list[LinkerEntity]:

lib/extractor/ntr_text_fragmentation/chunking/text_to_text_base.py

@@ -2,9 +2,9 @@ from abc import abstractmethod
 
 from ntr_fileparser import ParsedDocument
 
-from ..models import LinkerEntity, DocumentAsEntity
-from .models import CustomChunk
+from ..models import DocumentAsEntity, LinkerEntity
 from .chunking_strategy import ChunkingStrategy
+from .models import CustomChunk
 
 
 class TextToTextBaseStrategy(ChunkingStrategy):
@@ -15,10 +15,29 @@ class TextToTextBaseStrategy(ChunkingStrategy):
     """
 
     def chunk(
-        self, document: ParsedDocument, doc_entity: DocumentAsEntity
+        self, 
+        document: ParsedDocument, 
+        doc_entity: DocumentAsEntity,
+    ) -> list[LinkerEntity]:
+        text = self._get_text(document)
+        texts = self._chunk(text)
+        return [
+            CustomChunk(
+                text=chunk_text,
+                in_search_text=chunk_text,
+                number_in_relation=i,
+                groupper=self.__class__.__name__,
+            )
+            for i, chunk_text in enumerate(texts)
+        ]
+
+    async def chunk_async(
+        self,
+        document: ParsedDocument,
+        doc_entity: DocumentAsEntity,
     ) -> list[LinkerEntity]:
         text = self._get_text(document)
-        texts = self._chunk(text, doc_entity)
+        texts = await self._chunk_async(text)
         return [
             CustomChunk(
                 text=chunk_text,
@@ -39,7 +58,13 @@ class TextToTextBaseStrategy(ChunkingStrategy):
         )
 
     @abstractmethod
-    def _chunk(self, text: str, doc_entity: DocumentAsEntity) -> list[LinkerEntity]:
+    def _chunk(self, text: str) -> list[str]:
         raise NotImplementedError(
             "Метод _chunk должен быть реализован в классе-наследнике"
         )
+
+    @abstractmethod
+    async def _chunk_async(self, text: str) -> list[str]:
+        raise NotImplementedError(
+            "Метод _chunk_async должен быть реализован в классе-наследнике, если используется chunk_async"
+        )

lib/extractor/ntr_text_fragmentation/core/extractor.py

@@ -3,13 +3,13 @@
 """
 
 import logging
-from typing import Any, NamedTuple
+from typing import Any
 from uuid import uuid4
 
 from ntr_fileparser import ParsedDocument, ParsedTextBlock
 
 from ..additors import TablesProcessor
-from ..chunking import ChunkingStrategy, FIXED_SIZE, chunking_registry
+from ..chunking import FIXED_SIZE, ChunkingStrategy, chunking_registry
 from ..models import DocumentAsEntity, LinkerEntity
 
 
@@ -27,6 +27,7 @@ class EntitiesExtractor:
     Координирует разбиение документа на чанки и обработку
     дополнительных сущностей (например, таблиц) с использованием
     зарегистрированных стратегий и процессоров.
+    Имеет синхронный (`extract`) и асинхронный (`extract_async`) методы.
     """
 
     def __init__(
@@ -129,25 +130,26 @@ class EntitiesExtractor:
         Returns:
             Destructurer: Возвращает сам себя для удобства использования в цепочке вызовов
         """
-        self.tables_processor = TablesProcessor()
+        self.tables_processor = TablesProcessor() if process_tables else None
         logger.info(f"Процессор таблиц установлен: {process_tables}")
         return self
 
     def extract(self, document: ParsedDocument | str) -> list[LinkerEntity]:
         """
-        Основной метод извлечения информации из документа.
-        Чанкает и извлекает из документа всё, что можно из него извлечь.
-        Возвращает список сущностей.
+        Синхронный метод извлечения информации из документа.
+        Чанкает и извлекает из документа всё, что можно из него извлечь,
+        используя синхронные методы стратегий.
+        Если стратегия не поддерживает синхронный вызов, будет вызвано исключение.
 
         Args:
-            document: Документ для извлечения информации. Если передать строку, она будет \
+            document: Документ для извлечения информации. Если передать строку, она будет
                 автоматически преобразована в `ParsedDocument`
 
         Returns:
             list[LinkerEntity]: список сущностей (документ, чанки, таблицы, связи)
 
         Raises:
-            RuntimeError: Если стратегия не была сконфигурирована
+            NotImplementedError: Если выбранная стратегия не поддерживает синхронный вызов.
         """
         if isinstance(document, str):
             document = ParsedDocument(
@@ -164,7 +166,7 @@ class EntitiesExtractor:
 
         if self.strategy is not None:
             logger.info(
-                f"Чанкирование документа {document.name} с помощью стратегии {self.strategy.__class__.__name__}..."
+                f"Синхронное чанкирование документа {document.name} с помощью стратегии {self.strategy.__class__.__name__}..."
             )
             entities += self._chunk(document, doc_entity)
 
@@ -172,7 +174,53 @@ class EntitiesExtractor:
             logger.info(f"Обработка таблиц в документе {document.name}...")
             entities += self.tables_processor.extract(document, doc_entity)
 
-        logger.info(f"Извлечение информации из документа {document.name} завершено.")
+        logger.info(f"Синхронное извлечение информации из документа {document.name} завершено.")
+        entities = [entity.serialize() for entity in entities]
+
+        return entities
+
+    async def extract_async(self, document: ParsedDocument | str) -> list[LinkerEntity]:
+        """
+        Асинхронный метод извлечения информации из документа.
+        Чанкает и извлекает из документа всё, что можно из него извлечь,
+        используя асинхронные методы стратегий там, где они доступны.
+
+        Args:
+            document: Документ для извлечения информации. Если передать строку, она будет
+                автоматически преобразована в `ParsedDocument`
+
+        Returns:
+            list[LinkerEntity]: список сущностей (документ, чанки, таблицы, связи)
+
+        Raises:
+            RuntimeError: Если стратегия не была сконфигурирована.
+        """
+        if isinstance(document, str):
+            document = ParsedDocument(
+                name='unknown',
+                type='PlainText',
+                paragraphs=[
+                    ParsedTextBlock(text=paragraph)
+                    for paragraph in document.split('\n')
+                ],
+            )
+
+        doc_entity = self._create_document_entity(document)
+        entities: list[LinkerEntity] = [doc_entity]
+
+        if self.strategy is not None:
+            logger.info(
+                f"Асинхронное чанкирование документа {document.name} с помощью стратегии {self.strategy.__class__.__name__}..."
+            )
+            chunk_entities = await self._chunk_async(document, doc_entity)
+            entities.extend(chunk_entities)
+
+        if self.tables_processor is not None:
+            logger.info(f"Обработка таблиц в документе {document.name}...")
+            table_entities = self.tables_processor.extract(document, doc_entity)
+            entities.extend(table_entities)
+
+        logger.info(f"Асинхронное извлечение информации из документа {document.name} завершено.")
         entities = [entity.serialize() for entity in entities]
 
         return entities
@@ -186,9 +234,19 @@ class EntitiesExtractor:
             raise RuntimeError("Стратегия чанкинга не выставлена")
 
         doc_entity.chunking_strategy_ref = self._strategy_name
-
         return self.strategy.chunk(document, doc_entity)
 
+    async def _chunk_async(
+        self,
+        document: ParsedDocument,
+        doc_entity: DocumentAsEntity,
+    ) -> list[LinkerEntity]:
+        if self.strategy is None:
+            raise RuntimeError("Стратегия чанкинга не выставлена")
+
+        doc_entity.chunking_strategy_ref = self._strategy_name
+        return await self.strategy.chunk_async(document, doc_entity)
+
     def _create_document_entity(self, document: ParsedDocument) -> DocumentAsEntity:
         """
         Создает сущность документа.

routes/llm.py

@@ -14,7 +14,7 @@ from components.llm.common import (ChatRequest, LlmParams, LlmPredictParams,
 from components.llm.deepinfra_api import DeepInfraApi
 from components.llm.utils import append_llm_response_to_history
 from components.services.dataset import DatasetService
-from components.services.dialogue import DialogueService
+from components.services.dialogue import DialogueService, QEResult
 from components.services.entity import EntityService
 from components.services.llm_config import LLMConfigService
 from components.services.llm_prompt import LlmPromptService
@@ -121,13 +121,13 @@ async def sse_generator(request: ChatRequest, llm_api: DeepInfraApi, system_prom
     """
     Генератор для стриминга ответа LLM через SSE.
     """
-    qe_result = None
     try:
         qe_result = await dialogue_service.get_qe_result(request.history) 
         
     except Exception as e:
         logger.error(f"Error in SSE chat stream while dialogue_service.get_qe_result: {str(e)}", stack_info=True)
         yield "data: {\"event\": \"error\", \"data\":\""+str(e)+"\" }\n\n"
+        qe_result = dialogue_service.get_qe_result_from_chat(request.history)
     
     try:   
         if qe_result.use_search and qe_result.search_query is not None:
@@ -241,7 +241,12 @@ async def chat(
             stop=[],
         )
 
-        qe_result = await dialogue_service.get_qe_result(request.history)
+        try:
+            qe_result = await dialogue_service.get_qe_result(request.history)
+        except Exception as e:
+            logger.error(f"Error in chat while dialogue_service.get_qe_result: {str(e)}", stack_info=True)
+            qe_result = dialogue_service.get_qe_result_from_chat(request.history)
+        
         last_message = get_last_user_message(request)
 
         logger.info(f"qe_result: {qe_result}")