update

common/configuration.py

@@ -8,7 +8,7 @@ from pyaml_env import parse_config
 class EntitiesExtractorConfiguration:
     def __init__(self, config_data):
         self.strategy_name = str(config_data['strategy_name'])
-        self.strategy_params: dict = config_data['strategy_params']
+        self.strategy_params: dict | None = config_data['strategy_params']
         self.process_tables = bool(config_data['process_tables'])
         self.neighbors_max_distance = int(config_data['neighbors_max_distance'])
 

common/dependencies.py

@@ -19,6 +19,7 @@ from components.services.document import DocumentService
 from components.services.entity import EntityService
 from components.services.llm_config import LLMConfigService
 from components.services.llm_prompt import LlmPromptService
+from components.services.search_metrics import SearchMetricsService
 
 
 def get_config() -> Configuration:
@@ -117,17 +118,24 @@ def get_document_service(
 
 
 def get_dialogue_service(
-    config: Annotated[Configuration, Depends(get_config)],
-    entity_service: Annotated[EntityService, Depends(get_entity_service)],
-    dataset_service: Annotated[DatasetService, Depends(get_dataset_service)],
     llm_api: Annotated[DeepInfraApi, Depends(get_llm_service)],
     llm_config_service: Annotated[LLMConfigService, Depends(get_llm_config_service)],
 ) -> DialogueService:
     """Получение сервиса для работы с диалогами через DI."""
     return DialogueService(
-        config=config,
-        entity_service=entity_service,
-        dataset_service=dataset_service,
         llm_api=llm_api,
         llm_config_service=llm_config_service,
     )
+
+
+def get_search_metrics_service(
+    entity_service: Annotated[EntityService, Depends(get_entity_service)],
+    config: Annotated[Configuration, Depends(get_config)],
+    dialogue_service: Annotated[DialogueService, Depends(get_dialogue_service)],
+) -> SearchMetricsService:
+    """Получение сервиса для расчета метрик поиска через DI."""
+    return SearchMetricsService(
+        entity_service=entity_service,
+        config=config,
+        dialogue_service=dialogue_service,
+    )

components/dbo/chunk_repository.py

@@ -1,3 +1,4 @@
+import asyncio
 import logging
 from uuid import UUID
 
@@ -114,6 +115,16 @@ class ChunkRepository(SQLAlchemyEntityRepository):
             session.add_all(db_entities_to_add)
             session.commit()
 
+    async def add_entities_async(
+        self,
+        entities: list[LinkerEntity],
+        dataset_id: int,
+        embeddings: dict[str, np.ndarray] | None = None,
+    ):
+        """Асинхронно добавляет список сущностей LinkerEntity в базу данных."""
+        # TODO: Реализовать с использованием async-сессии
+        await asyncio.to_thread(self.add_entities, entities, dataset_id, embeddings)
+
     def get_searching_entities(
         self,
         dataset_id: int,
@@ -163,6 +174,49 @@ class ChunkRepository(SQLAlchemyEntityRepository):
         # Возвращаем результаты после закрытия сессии
         return linker_entities, embeddings_list
 
+    async def get_searching_entities_async(
+        self,
+        dataset_id: int,
+    ) -> tuple[list[LinkerEntity], list[np.ndarray]]:
+        """Асинхронно получает сущности для поиска вместе с эмбеддингами."""
+        # TODO: Реализовать с использованием async-сессии
+        return await asyncio.to_thread(self.get_searching_entities, dataset_id)
+
+    def get_all_entities_for_dataset(self, dataset_id: int) -> list[LinkerEntity]:
+        """
+        Получает все сущности для указанного датасета.
+
+        Args:
+            dataset_id: ID датасета.
+
+        Returns:
+            Список всех LinkerEntity для данного датасета.
+        """
+        entity_model = self._entity_model_class
+        linker_entities = []
+
+        with self.db() as session:
+            stmt = select(entity_model).where(
+                entity_model.dataset_id == dataset_id
+            )
+            db_models = session.execute(stmt).scalars().all()
+
+            # Переносим цикл внутрь сессии для маппинга
+            for model in db_models:
+                try:
+                    linker_entity = self._map_db_entity_to_linker_entity(model)
+                    linker_entities.append(linker_entity)
+                except Exception as e:
+                    logger.error(f"Error mapping entity {getattr(model, 'uuid', 'N/A')} in dataset {dataset_id}: {e}")
+
+        logger.info(f"Loaded {len(linker_entities)} entities for dataset {dataset_id}")
+        return linker_entities
+
+    async def get_all_entities_for_dataset_async(self, dataset_id: int) -> list[LinkerEntity]:
+        """Асинхронно получает все сущности для указанного датасета."""
+        # TODO: Реализовать с использованием async-сессии
+        return await asyncio.to_thread(self.get_all_entities_for_dataset, dataset_id)
+
     def count_entities_by_dataset_id(self, dataset_id: int) -> int:
         """
         Подсчитывает общее количество сущностей для указанного датасета.
@@ -182,3 +236,13 @@ class ChunkRepository(SQLAlchemyEntityRepository):
             )
             count = session.execute(stmt).scalar_one()
             return count
+
+    async def count_entities_by_dataset_id_async(self, dataset_id: int) -> int:
+        """Асинхронно подсчитывает общее количество сущностей для датасета."""
+        # TODO: Реализовать с использованием async-сессии
+        return await asyncio.to_thread(self.count_entities_by_dataset_id, dataset_id)
+
+    async def get_entities_by_ids_async(self, entity_ids: list[UUID]) -> list[LinkerEntity]:
+        """Асинхронно получить сущности по списку ID."""
+        # TODO: Реализовать с использованием async-сессии
+        return await asyncio.to_thread(self.get_entities_by_ids, entity_ids)

components/llm/prompts.py

@@ -362,3 +362,162 @@ __.__.20__ N__-__/__
 ####
 Вывод:
 """
+
+
+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/llm/utils.py

@@ -12,21 +12,27 @@ def convert_to_openai_format(request: ChatRequest, system_prompt: str) -> List[D
     Returns:
         List[Dict[str, str]]: История в формате OpenAI [{'role': str, 'content': str}, ...].
     """
-    # Добавляем системный промпт как первое сообщение
-    openai_history = [{"role": "system", "content": system_prompt}]
+    # # Добавляем системный промпт как первое сообщение
+    # openai_history = [{"role": "system", "content": system_prompt}]
+    
+    # # Преобразуем историю из ChatRequest
+    # for message in request.history:
+    #     content = message.content
+    #     if message.searchResults:
+    #         search_results = "\n" + message.searchResults
+    #         content += f"\n<search-results>\n{search_results}\n</search-results>"
+        
+    #     openai_history.append({
+    #         "role": message.role,
+    #         "content": content
+    #     })
     
-    content = system_prompt+"\n"
-    # Преобразуем историю из ChatRequest
+    user_prompt = system_prompt + "\n\n"
     for message in request.history:
-        content += message.content
-        if message.searchResults:
-            search_results = "\n" + message.searchResults
-            content += f"\n<search-results>\n{search_results}\n</search-results>"
+        content = message.content
+        user_prompt += content
         
-        openai_history.append({
-            "role": message.role,
-            "content": content
-        })
+    openai_history = [{"role": "user", "content": user_prompt}]
     
     return openai_history
 

components/services/dataset.py

@@ -1,3 +1,5 @@
+import asyncio
+from functools import partial
 import json
 import logging
 import os
@@ -5,11 +7,9 @@ import shutil
 import zipfile
 from datetime import datetime
 from pathlib import Path
-import asyncio
 
 import torch
 from fastapi import BackgroundTasks, HTTPException, UploadFile
-from components.dbo.models.entity import EntityModel
 from ntr_fileparser import ParsedDocument, UniversalParser
 from sqlalchemy.orm import Session
 
@@ -18,6 +18,7 @@ from common.configuration import Configuration
 from components.dbo.models.dataset import Dataset
 from components.dbo.models.dataset_document import DatasetDocument
 from components.dbo.models.document import Document
+from components.dbo.models.entity import EntityModel
 from components.services.entity import EntityService
 from schemas.dataset import Dataset as DatasetSchema
 from schemas.dataset import DatasetExpanded as DatasetExpandedSchema
@@ -55,6 +56,20 @@ class DatasetService:
         self.entity_service = entity_service
         self.documents_path = Path(config.db_config.files.documents_path)
         self.tmp_path = Path(os.environ.get("APP_TMP_PATH", '.'))
+
+        # Начальная загрузка кеша для активного датасета
+        try:
+            active_dataset = self.get_current_dataset()
+            if active_dataset:
+                logger.info(f"Performing initial cache load for active dataset {active_dataset.id}")
+                # Вызываем метод сервиса сущностей для построения кеша
+                self.entity_service.build_cache(active_dataset.id)
+            else:
+                logger.warning("No active dataset found during DatasetService initialization.")
+        except Exception as e:
+            # Логгируем ошибку, но не прерываем инициализацию сервиса
+            logger.error(f"Failed initial cache load during DatasetService initialization: {e}", exc_info=True)
+
         logger.info("DatasetService initialized")
 
     def get_dataset(
@@ -210,11 +225,14 @@ class DatasetService:
                     status_code=403, detail='Active dataset cannot be deleted'
                 )
             
+            # Инвалидируем кеш перед удалением данных (больше не нужен ID)
+            self.entity_service.invalidate_cache()
+
             session.query(EntityModel).filter(EntityModel.dataset_id == dataset_id).delete()
             session.delete(dataset)
             session.commit()
 
-    def apply_draft_task(self, dataset_id: int):
+    async def apply_draft_task(self, dataset_id: int):
         """
         Метод для выполнения в отдельном процессе.
         """
@@ -233,6 +251,7 @@ class DatasetService:
                 active_dataset = (
                     session.query(Dataset).filter(Dataset.is_active == True).first()
                 )
+                old_active_dataset_id = active_dataset.id if active_dataset else None
 
                 self.apply_draft(dataset)
                 dataset.is_draft = False
@@ -241,12 +260,17 @@ class DatasetService:
                     active_dataset.is_active = False
 
                 session.commit()
+
+            # Обновляем кеши после применения черновика
+            if old_active_dataset_id:
+                self.entity_service.invalidate_cache()
+            await self.entity_service.build_or_rebuild_cache_async(dataset_id)
             logger.info(f"apply_draft_task finished")
         except Exception as e:
             logger.error(f"Error applying draft: {e}")
             raise
 
-    def activate_dataset(
+    async def activate_dataset(
         self, dataset_id: int, background_tasks: BackgroundTasks
     ) -> DatasetExpandedSchema:
         """
@@ -266,15 +290,22 @@ class DatasetService:
                 raise HTTPException(status_code=400, detail='Dataset is already active')
 
             if dataset.is_draft:
-                background_tasks.add_task(self.apply_draft_task, dataset_id)
+                wrapper = partial(asyncio.run, self.apply_draft_task(dataset_id))
+                background_tasks.add_task(wrapper)
             else:
-                dataset.is_active = True
+                old_active_dataset_id = active_dataset.id if active_dataset else None
 
+                dataset.is_active = True
                 if active_dataset:
                     active_dataset.is_active = False
-
                 session.commit()
 
+                # Обновляем кеши после коммита
+                if old_active_dataset_id:
+                    self.entity_service.invalidate_cache()
+                await self.entity_service.build_or_rebuild_cache_async(dataset_id)
+                logger.info(f"Caches updated after activating non-draft dataset {dataset_id}")
+
             return self.get_dataset(dataset_id)
 
     def get_processing(self) -> DatasetProcessing:

components/services/dialogue.py

@@ -1,16 +1,12 @@
 import logging
-import os
 import re
-from typing import List, Optional, Tuple
+from typing import List, Optional
 
 from pydantic import BaseModel
 
-from common.configuration import Configuration
-from components.llm.common import ChatRequest, LlmParams, LlmPredictParams, Message
+from components.llm.common import ChatRequest, LlmPredictParams, Message
 from components.llm.deepinfra_api import DeepInfraApi
 from components.llm.prompts import PROMPT_QE
-from components.services.dataset import DatasetService
-from components.services.entity import EntityService
 from components.services.llm_config import LLMConfigService
 
 logger = logging.getLogger(__name__)
@@ -25,15 +21,10 @@ class QEResult(BaseModel):
 class DialogueService:
     def __init__(
         self,
-        config: Configuration,
-        entity_service: EntityService,
-        dataset_service: DatasetService,
         llm_api: DeepInfraApi,
         llm_config_service: LLMConfigService,
     ) -> None:
         self.prompt = PROMPT_QE
-        self.entity_service = entity_service
-        self.dataset_service = dataset_service
         self.llm_api = llm_api
 
         p = llm_config_service.get_default()
@@ -50,7 +41,7 @@ class DialogueService:
     async def get_qe_result(self, history: List[Message]) -> QEResult:
         """
         Получает результат QE.
-        
+
         Args:
             history: История диалога в виде списка сообщений
 
@@ -72,9 +63,9 @@ class DialogueService:
             return QEResult(
                 use_search=from_chat is not None,
                 search_query=from_chat.content if from_chat else None,
-                debug_message=response
+                debug_message=response,
             )
-            
+
     def get_qe_result_from_chat(self, history: List[Message]) -> QEResult:
         from_chat = self._get_search_query(history)
         return QEResult(
@@ -131,8 +122,9 @@ class DialogueService:
         else:
             raise ValueError("Первая часть текста должна содержать 'ДА' или 'НЕТ'.")
 
-        return QEResult(use_search=bool_var, search_query=second_part,
-                debug_message=input_text)
+        return QEResult(
+            use_search=bool_var, search_query=second_part, debug_message=input_text
+        )
 
     def _get_search_query(self, history: List[Message]) -> Message | None:
         """

components/services/entity.py

@@ -4,7 +4,8 @@ from uuid import UUID
 
 import numpy as np
 from ntr_fileparser import ParsedDocument
-from ntr_text_fragmentation import EntitiesExtractor, InjectionBuilder
+from ntr_text_fragmentation import (EntitiesExtractor, EntityRepository,
+                                    InjectionBuilder, InMemoryEntityRepository)
 
 from common.configuration import Configuration
 from components.dbo.chunk_repository import ChunkRepository
@@ -69,6 +70,61 @@ class EntityService:
             process_tables=False,
         )
 
+        self._in_memory_cache: InMemoryEntityRepository = None
+        self._cached_dataset_id: int | None = None
+
+    def invalidate_cache(self) -> None:
+        """Инвалидирует (удаляет) текущий кеш в памяти."""
+        if self._in_memory_cache:
+            self._in_memory_cache.clear()
+            self._cached_dataset_id = None
+        else:
+            logger.info("In-memory кеш уже пуст. Ничего не делаем.")
+            
+    def build_cache(self, dataset_id: int) -> None:
+        """Строит кеш для указанного датасета."""
+        all_entities = self.chunk_repository.get_all_entities_for_dataset(dataset_id)
+        in_memory_repo = InMemoryEntityRepository(entities=all_entities)
+        self._in_memory_cache = in_memory_repo
+        self._cached_dataset_id = dataset_id
+
+    async def build_or_rebuild_cache_async(self, dataset_id: int) -> None:
+        """
+        Строит или перестраивает кеш для указанного датасета, удаляя предыдущий кеш.
+        """
+
+        all_entities = await self.chunk_repository.get_all_entities_for_dataset_async(dataset_id)
+        if not all_entities:
+            logger.warning(f"No entities found for dataset {dataset_id}. Cache not built.")
+            self._in_memory_cache = None
+            self._cached_dataset_id = None
+            return
+
+        logger.info(f"Building new in-memory cache for dataset {dataset_id}")
+        in_memory_repo = InMemoryEntityRepository(entities=all_entities)
+        self._in_memory_cache = in_memory_repo
+        self._cached_dataset_id = dataset_id
+        logger.info(f"Cached {len(all_entities)} entities for dataset {dataset_id}")
+
+    def _get_repository_for_dataset(self, dataset_id: int) -> EntityRepository:
+        """
+        Возвращает кешированный репозиторий, если он существует и соответствует
+        запрошенному dataset_id, иначе возвращает основной репозиторий ChunkRepository.
+        """
+        # Проверяем совпадение ID с закешированным
+        if self._cached_dataset_id == dataset_id and self._in_memory_cache is not None:
+            return self._in_memory_cache
+        else:
+            # Логируем причину промаха кеша для диагностики
+            if not self._in_memory_cache:
+                 logger.warning(f"Cache miss for dataset {dataset_id}: Cache is empty. Using ChunkRepository (DB).")
+            elif self._cached_dataset_id != dataset_id:
+                 logger.warning(f"Cache miss for dataset {dataset_id}: Cache contains data for dataset {self._cached_dataset_id}. Using ChunkRepository (DB).")
+            else: # На случай непредвиденной ситуации
+                 logger.warning(f"Cache miss for dataset {dataset_id}: Unknown reason. Using ChunkRepository (DB).")
+
+            return self.chunk_repository
+
     def _ensure_faiss_initialized(self, dataset_id: int) -> None:
         """
         Проверяет и при необходимости инициализирует или обновляет FAISS индекс.
@@ -76,7 +132,7 @@ class EntityService:
         Args:
             dataset_id: ID датасета для инициализации
         """
-        # Если индекс не инициализирован или датасет изменился
+        # Переинициализируем FAISS, только если ID датасета изменился
         if self.faiss_search is None or self.current_dataset_id != dataset_id:
             logger.info(f'Initializing FAISS for dataset {dataset_id}')
             entities, embeddings = self.chunk_repository.get_searching_entities(
@@ -124,6 +180,7 @@ class EntityService:
         """
         logger.info(f"Processing document {document.name} for dataset {dataset_id}")
 
+        # Определяем экстрактор в зависимости от имени документа
         if 'Приложение' in document.name:
             entities = await self.appendices_extractor.extract_async(document)
         else:
@@ -136,46 +193,73 @@ class EntityService:
         filtering_texts = [entity.in_search_text for entity in filtering_entities]
 
         embeddings = self.vectorizer.vectorize(filtering_texts, progress_callback)
-        embeddings_dict = {
-            str(entity.id): embedding
-            for entity, embedding in zip(filtering_entities, embeddings)
-        }
+
+        # Собираем словарь эмбеддингов только для найденных сущностей
+        embeddings_dict = {}
+        if embeddings is not None:
+            embeddings_dict = {
+                str(entity.id): embedding
+                for entity, embedding in zip(filtering_entities, embeddings)
+                if embedding is not None
+            }
+        else:
+            logger.warning(f"Vectorizer returned None for document {document.name}")
 
         # Сохраняем в базу
-        self.chunk_repository.add_entities(entities, dataset_id, embeddings_dict)
+        await self.chunk_repository.add_entities_async(entities, dataset_id, embeddings_dict)
 
         logger.info(f"Added {len(entities)} entities to dataset {dataset_id}")
 
-    def build_text(
+    async def build_text_async(
         self,
         entities: list[str],
+        dataset_id: int,
         chunk_scores: Optional[list[float]] = None,
         include_tables: bool = True,
         max_documents: Optional[int] = None,
     ) -> str:
         """
-        Сборка текста из сущностей.
+        Асинхронная сборка текста из сущностей с использованием кешированного или основного репозитория.
 
         Args:
-            entities: Список идентификаторов сущностей
-            chunk_scores: Список весов чанков
+            entities: Список идентификаторов сущностей (строки UUID)
+            dataset_id: ID датасета для получения репозитория (кешированного или БД)
+            chunk_scores: Список весов чанков (соответствует порядку entities)
             include_tables: Флаг включения таблиц
             max_documents: Максимальное количество документов
 
         Returns:
             Собранный текст
         """
-        entities = [UUID(entity) for entity in entities]
-        entities = self.chunk_repository.get_entities_by_ids(entities)
-        logger.info(f"Building text for {len(entities)} entities")
+        if not entities:
+            logger.warning("build_text called with empty entities list.")
+            return ""
+
+        try:
+            entity_ids = [UUID(entity) for entity in entities]
+        except ValueError as e:
+            logger.error(f"Invalid UUID format found in entities list: {e}")
+            raise ValueError(f"Invalid UUID format in entities list: {entities}") from e
+
+        repository = self._get_repository_for_dataset(dataset_id)
+
+        # Передаем репозиторий (кеш или БД) в InjectionBuilder
+        builder = InjectionBuilder(repository=repository)
+
+        # Создаем словарь score_map UUID -> score, если chunk_scores предоставлены
+        scores_map: dict[UUID, float] | None = None
         if chunk_scores is not None:
-            chunk_scores = {
-                entity.id: score for entity, score in zip(entities, chunk_scores)
-            }
-        builder = InjectionBuilder(self.chunk_repository)
-        return builder.build(
-            entities,
-            scores=chunk_scores,
+            if len(entity_ids) == len(chunk_scores):
+                scores_map = {eid: score for eid, score in zip(entity_ids, chunk_scores)}
+            else:
+                logger.warning(f"Length mismatch between entities ({len(entity_ids)}) and chunk_scores ({len(chunk_scores)}). Scores ignored.")
+
+        logger.info(f"Building text for {len(entity_ids)} entities from dataset {dataset_id} using {repository.__class__.__name__}")
+
+        # Вызываем асинхронный метод сборщика
+        return await builder.build_async(
+            entities=entity_ids, # Передаем список UUID
+            scores=scores_map,   # Передаем словарь UUID -> score
             include_tables=include_tables,
             neighbors_max_distance=self.neighbors_max_distance,
             max_documents=max_documents,
@@ -185,6 +269,7 @@ class EntityService:
         self,
         query: str,
         dataset_id: int,
+        k: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Поиск похожих сущностей.
@@ -192,6 +277,7 @@ class EntityService:
         Args:
             query: Текст запроса
             dataset_id: ID датасета
+            k: Максимальное количество возвращаемых результатов (по умолчанию - все).
 
         Returns:
             tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -199,14 +285,19 @@ class EntityService:
                 - Оценки сходства
                 - Идентификаторы найденных сущностей
         """
-        # Убеждаемся, что FAISS инициализирован для текущего датасета
+        logger.info(f"Searching similar entities for dataset {dataset_id} with k={k}")
         self._ensure_faiss_initialized(dataset_id)
 
         if self.faiss_search is None:
+            logger.warning(
+                f"FAISS search not initialized for dataset {dataset_id}. Returning empty results."
+            )
             return np.array([]), np.array([]), np.array([])
 
-        # Выполняем поиск
-        return self.faiss_search.search_vectors(query)
+        # Выполняем поиск с использованием параметра k
+        query_vector, scores, ids = self.faiss_search.search_vectors(query, max_entities=k)
+        logger.info(f"Found {len(ids)} similar entities.")
+        return query_vector, scores, ids
 
     def search_similar(
         self,
@@ -225,7 +316,7 @@ class EntityService:
         Returns:
             tuple[list[list[str]], list[str], list[float]]:
                 - Перефильтрованный список идентификаторов сущностей из прошлых запросов
-                - Список идентификаторов найденных сущностей
+                - Список идентификаторов найденных сущностей (строки UUID)
                 - Скоры найденных сущностей
         """
         self._ensure_faiss_initialized(dataset_id)

components/services/search_metrics.py

@@ -357,7 +357,8 @@ class SearchMetricsService:
                     # +++ Получаем тексты чанков для расчета метрик chunk/punct +++
                     retrieved_chunks_texts_for_n = []
                     if chunk_ids_for_n.size > 0:
-                        chunks_for_n = self.entity_service.chunk_repository.get_entities_by_ids(
+                        # Используем асинхронный вызов
+                        chunks_for_n = await self.entity_service.chunk_repository.get_entities_by_ids_async(
                             [UUID(ch_id) for ch_id in chunk_ids_for_n]
                         )
                         chunk_map_for_n = {str(ch.id): ch for ch in chunks_for_n}
@@ -392,8 +393,13 @@ class SearchMetricsService:
                     # --- Метрики Сборки ---
                     # +++ Правильная сборка контекста с помощью build_text +++
                     logger.info(f"Building context for QID={question_id}, n={n} using {len(chunk_ids_for_n)} chunk IDs...")
-                    assembled_context_for_n = self.entity_service.build_text(
-                        entities=chunk_ids_for_n # Передаем список ID строк
+                    # Используем асинхронный вызов и передаем dataset_id
+                    assembled_context_for_n = await self.entity_service.build_text_async(
+                        entities=chunk_ids_for_n.tolist(), # Преобразуем numpy array в list[str]
+                        dataset_id=dataset_id, # Передаем ID датасета
+                        # chunk_scores можно передать, если они нужны для сборки, иначе None
+                        # include_tables=True, # По умолчанию
+                        # max_documents=None, # По умолчанию
                     )
 
                     assembly_recall, single_q_assembly_found, single_q_valid_gt = self._calculate_assembly_punct_recall(

config_dev.yaml

@@ -18,8 +18,8 @@ bd:
     use_vector_search: true
     vectorizer_path: !ENV ${EMBEDDING_MODEL_PATH:BAAI/bge-m3}
     device: !ENV ${DEVICE:cuda}
-    max_entities_per_message: 75
-    max_entities_per_dialogue: 500
+    max_entities_per_message: 150
+    max_entities_per_dialogue: 300
 
   files:
     empty_start: true

lib/extractor/ntr_text_fragmentation/additors/tables/table_processor.py

@@ -1,3 +1,4 @@
+import logging
 from ntr_fileparser import ParsedRow, ParsedSubtable, ParsedTable
 
 from ...models import LinkerEntity
@@ -5,6 +6,9 @@ from ...repositories.entity_repository import EntityRepository, GroupedEntities
 from .models import SubTableEntity, TableEntity, TableRowEntity
 
 
+logger = logging.getLogger(__name__)
+
+
 class TableProcessor:
     def __init__(self):
         pass
@@ -114,6 +118,84 @@ class TableProcessor:
         entity.owner_id = subtable_entity.id
         return entity
 
+    async def build_async(
+        self,
+        repository: EntityRepository,
+        group: GroupedEntities[TableEntity],
+    ) -> str | None:
+        """
+        Асинхронно собирает текст таблицы из группы сущностей.
+        """
+        if not group or not group.composer:
+            return None
+
+        table = group.composer
+        entities = group.entities
+
+        if not isinstance(table, TableEntity):
+            logger.warning(f"Ожидался TableEntity в composer, получен {type(table)}.")
+            return None
+
+        # Асинхронно группируем строки по подтаблицам
+        subtable_grouped: list[GroupedEntities[SubTableEntity]] = (
+            await repository.group_entities_hierarchically_async(
+                entities=entities,
+                root_type=SubTableEntity,
+                sort=True,  # Важно для порядка подтаблиц и строк внутри
+            )
+        )
+
+        if not subtable_grouped:
+            logger.debug(f"Нет подтаблиц для таблицы '{table.name}' ({table.id})")
+            # Можно вернуть только заголовок и примечание, если они есть
+            # return f"#### {table.title or f'Таблица {table.number_in_relation}'}\n{f'**Примечание:** {table.note}\n' if table.note else ''}".strip()
+            return None  # Или ничего не возвращать, если нет строк
+
+        result_parts = []
+
+        # Заголовок таблицы
+        if table.title:
+            result_parts.append(f"#### {table.title}")
+        else:
+            result_parts.append(f"#### Таблица {table.number_in_relation}")
+
+        table_header = table.header  # Синхронное получение атрибута
+
+        # Обработка каждой подтаблицы (синхронно внутри, т.к. CPU-bound)
+        for subtable_group in subtable_grouped:
+            if not subtable_group or not subtable_group.composer:
+                continue
+
+            subtable = subtable_group.composer
+            if not isinstance(subtable, SubTableEntity):
+                continue
+
+            subtable_header = subtable.header  # Синхронно
+            # Фильтруем только строки таблицы, сортировка уже выполнена group_entities_hierarchically_async
+            rows = [
+                row
+                for row in subtable_group.entities
+                if isinstance(row, TableRowEntity)
+            ]
+
+            if subtable.title:
+                result_parts.append(f"##### {subtable.title}")
+
+            for row in rows:
+                # _prepare_row - чисто CPU-bound операция
+                result_parts.append(
+                    self._prepare_row(
+                        row,
+                        subtable_header or table_header,
+                    )
+                )
+
+        # Примечание к таблице
+        if table.note:
+            result_parts.append(f"**Примечание:** {table.note}")
+
+        return "\n".join(result_parts)
+
     def build(
         self,
         repository: EntityRepository,
@@ -157,7 +239,7 @@ class TableProcessor:
                     row,
                     subtable_header or table_header,
                 )
-        
+
         if table.note:
             result += f"**Примечание:** {table.note}\n"
 
@@ -173,6 +255,13 @@ class TableProcessor:
             cells = "\n".join([f"- - {cell}" for cell in row.cells])
         else:
             normalized_header = [h.replace('\n', '') for h in header]
-            cells = "\n".join([f"  - **{normalized_header[i]}**: {row.cells[i]}".replace('\n', '\n    -') for i in range(len(header))])
+            cells = "\n".join(
+                [
+                    f"  - **{normalized_header[i]}**: {row.cells[i]}".replace(
+                        '\n', '\n    -'
+                    )
+                    for i in range(len(header))
+                ]
+            )
 
         return f"- {row_name}\n{cells}\n"

lib/extractor/ntr_text_fragmentation/additors/tables_processor.py

@@ -2,11 +2,13 @@
 Процессор таблиц из документа.
 """
 
+import asyncio
+
 from ntr_fileparser import ParsedDocument
 
 from ..models import LinkerEntity
-from .tables import TableProcessor, TableEntity
 from ..repositories import EntityRepository, GroupedEntities
+from .tables import TableEntity, TableProcessor
 
 
 class TablesProcessor:
@@ -29,6 +31,41 @@ class TablesProcessor:
             entities.extend(self.table_processor.extract(table, doc_entity))
         return entities
 
+    async def build_async(
+        self,
+        repository: EntityRepository,
+        entities: list[LinkerEntity],
+    ) -> str:
+        """
+        Асинхронно собирает текст таблиц из списка сущностей.
+        """
+        if not entities:
+            return ""
+
+        # Асинхронно группируем сущности по TableEntity
+        groups: list[GroupedEntities[TableEntity]] = (
+            await repository.group_entities_hierarchically_async(
+                entities=entities,
+                root_type=TableEntity,
+                sort=True,
+            )
+        )
+
+        if not groups:
+            return ""
+
+        groups = sorted(
+            groups, key=lambda x: x.composer.number_in_relation if x.composer else float('inf'),
+        )
+
+        build_tasks = [
+            self.table_processor.build_async(repository, group)
+            for group in groups
+        ]
+        results = await asyncio.gather(*build_tasks)
+
+        return "\n\n".join(filter(None, results))
+
     def build(
         self,
         repository: EntityRepository,
@@ -51,7 +88,7 @@ class TablesProcessor:
         )
 
         result = "\n\n".join(
-            self.table_processor.build(repository, group) for group in groups
+            filter(None, (self.table_processor.build(repository, group) for group in groups))
         )
 
         return result

lib/extractor/ntr_text_fragmentation/chunking/chunking_strategy.py

@@ -2,6 +2,7 @@
 Абстрактный базовый класс для стратегий чанкинга.
 """
 
+import asyncio
 import logging
 from abc import ABC, abstractmethod
 
@@ -102,6 +103,18 @@ class ChunkingStrategy(ABC):
 
         return result.strip()
 
+    @classmethod
+    async def dechunk_async(
+        cls,
+        repository: EntityRepository,
+        filtered_entities: list[LinkerEntity],
+    ) -> str:
+        """
+        Асинхронно собирает текст из отфильтрованных чанков к одному документу.
+        По умолчанию вызывает синхронную версию.
+        """
+        return await asyncio.to_thread(cls.dechunk, repository, filtered_entities)
+
     @classmethod
     def _build_sequenced_chunks(
         cls,

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

@@ -2,14 +2,33 @@
 Модуль содержащий конкретные стратегии для чанкинга текста.
 """
 
+# Импортируем конкретные сущности из BLM
+from .blm import (BLM_PARAGRAPH, BLM_SENTENCE, BlmChunk,
+                  BlmParagraphChunkingStrategy, BlmSentenceChunkingStrategy)
 from .fixed_size import FixedSizeChunk
-from .fixed_size_chunking import (
-    FixedSizeChunkingStrategy,
-    FIXED_SIZE,
-)
+from .fixed_size_chunking import FIXED_SIZE, FixedSizeChunkingStrategy
+from .paragraph_chunking import PARAGRAPH, ParagraphChunkingStrategy
+from .sentence_chunking import SENTENCE, SentenceChunkingStrategy
 
 __all__ = [
     "FixedSizeChunk",
     "FixedSizeChunkingStrategy",
     "FIXED_SIZE",
+    "ParagraphChunkingStrategy",
+    "PARAGRAPH",
+    "SentenceChunkingStrategy",
+    "SENTENCE",
+    # Явно добавляем BLM экспорты
+    "BlmChunk",
+    "BlmParagraphChunkingStrategy",
+    "BLM_PARAGRAPH",
+    "BlmSentenceChunkingStrategy",
+    "BLM_SENTENCE",
 ]
+
+# Динамическое добавление больше не нужно
+# import inspect
+# import sys
+# from . import blm
+# blm_exports = [name for name, obj in inspect.getmembers(blm) if not name.startswith("_")]
+# __all__.extend(blm_exports)

lib/extractor/ntr_text_fragmentation/chunking/specific_strategies/blm/__init__.py

@@ -0,0 +1,18 @@
+"""
+BLM-специфичные стратегии и модели чанкинга.
+"""
+
+from .blm_chunk import BlmChunk
+from .blm_paragraph_chunking import BLM_PARAGRAPH, BlmParagraphChunkingStrategy
+from .blm_sentence_chunking import BLM_SENTENCE, BlmSentenceChunkingStrategy
+
+# Утилиты не экспортируем вовне
+# from .blm_utils import ... 
+
+__all__ = [
+    "BlmChunk",
+    "BlmParagraphChunkingStrategy",
+    "BLM_PARAGRAPH",
+    "BlmSentenceChunkingStrategy",
+    "BLM_SENTENCE",
+] 

lib/extractor/ntr_text_fragmentation/chunking/specific_strategies/blm/blm_chunk.py

@@ -0,0 +1,66 @@
+"""
+Класс для представления чанка BLM-документа со ссылками на сноски.
+"""
+
+from dataclasses import dataclass, field
+
+from ....models import Entity, LinkerEntity, register_entity
+from ...models.chunk import Chunk
+
+
+@register_entity
+@dataclass
+class BlmChunk(Chunk):
+    """
+    Представляет чанк документа в рамках BLM-специфичной обработки.
+
+    Расширяет базовый класс Chunk полем для хранения идентификаторов
+    сносок, на которые ссылается текст этого чанка.
+
+    Attributes:
+        referenced_footnote_ids (list[int]): Список числовых идентификаторов сносок,
+                                           найденных в исходном тексте этого чанка.
+    """
+
+    referenced_footnote_ids: list[int] = field(default_factory=list)
+
+    @classmethod
+    def _deserialize_to_me(cls, data: Entity) -> "BlmChunk":
+        """
+        Десериализует BlmChunk из объекта Entity (LinkerEntity).
+
+        Извлекает поле `referenced_footnote_ids` из метаданных (`_referenced_footnote_ids`).
+
+        Args:
+            data: Объект Entity (LinkerEntity) для десериализации.
+
+        Returns:
+            Новый экземпляр BlmChunk с данными из Entity.
+
+        Raises:
+            TypeError: Если data не является экземпляром LinkerEntity или его подкласса.
+        """
+        if not isinstance(data, LinkerEntity):
+            raise TypeError(
+                f"Ожидался LinkerEntity или его подкласс, получен {type(data)}"
+            )
+
+        metadata = data.metadata or {}
+
+        ref_ids = list(metadata.get("_referenced_footnote_ids", []))
+        
+        clean_metadata = {k: v for k, v in metadata.items() if not k.startswith('_')}
+
+        return cls(
+            id=data.id,
+            name=data.name,
+            text=data.text,
+            in_search_text=data.in_search_text,
+            metadata=clean_metadata,
+            source_id=data.source_id,
+            target_id=data.target_id,
+            number_in_relation=data.number_in_relation,
+            groupper=data.groupper,
+            type=cls.__name__,
+            referenced_footnote_ids=ref_ids,
+        ) 

lib/extractor/ntr_text_fragmentation/chunking/specific_strategies/blm/blm_paragraph_chunking.py

@@ -0,0 +1,355 @@
+"""
+BLM-специфичная стратегия чанкинга по абзацам.
+"""
+
+import logging
+from uuid import uuid4
+
+from ntr_fileparser import ParsedDocument
+
+from ....models import DocumentAsEntity, LinkerEntity
+from ....repositories import EntityRepository
+from ...chunking_registry import register_chunking_strategy
+from ...chunking_strategy import ChunkingStrategy
+from ...models import Chunk
+from .blm_chunk import BlmChunk
+from .blm_utils import FOOTNOTE_TAG_PATTERN, _preprocess_blm_paragraphs
+
+logger = logging.getLogger(__name__)
+
+BLM_PARAGRAPH = "blm_paragraph"
+MIN_WORDS_PER_CHUNK = 6  # Сливаем, если <= 5 слов
+MAX_WORDS_PER_CHUNK = 300 # Разделяем, если > 300 слов
+
+
+@register_chunking_strategy(BLM_PARAGRAPH)
+class BlmParagraphChunkingStrategy(ChunkingStrategy):
+    """
+    BLM-специфичная стратегия: чанкинг по параграфам с обработкой сносок.
+
+    - Игнорирует параграфы-сноски (<N>...) и неинформативные параграфы.
+    - Создает `BlmChunk`, сохраняя ссылки на сноски `<N>`, найденные в тексте.
+    - Формирует `in_search_text` с добавлением текстов сносок.
+    - При сборке (`_build_sequenced_chunks`) добавляет блок "Примечания" к группе чанков.
+    """
+
+    DEFAULT_GROUPPER: str = "blm_paragraph"
+
+    def __init__(self, skip_footnotes: bool = False):
+        """Инициализация стратегии.
+        
+        Args:
+            skip_footnotes: Если True, сноски будут игнорироваться при обработке.
+        """
+        self.skip_footnotes = skip_footnotes
+        logger.info(f"BlmParagraphChunkingStrategy инициализирована с skip_footnotes={skip_footnotes}")
+
+    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]:
+        """
+        Разбивает документ на BlmChunk (параграфы) с обработкой сносок и правил слияния/разделения.
+
+        Args:
+            document: Документ для чанкинга.
+            doc_entity: Сущность документа-владельца.
+
+        Returns:
+            Список созданных BlmChunk.
+        """
+        footnotes_map, valid_paragraphs = _preprocess_blm_paragraphs(
+            document.paragraphs, extract_map=not self.skip_footnotes
+        )
+
+        if not self.skip_footnotes:
+            if not hasattr(doc_entity, 'metadata') or doc_entity.metadata is None:
+                doc_entity.metadata = {}
+            doc_entity.metadata['blm_footnotes'] = footnotes_map
+        elif hasattr(doc_entity, 'metadata') and doc_entity.metadata is not None:
+             # Убираем карту, если она там была и флаг skip=True
+             doc_entity.metadata.pop('blm_footnotes', None)
+
+        # Этап 1: Создание первичных чанков BlmChunk
+        initial_chunks: list[BlmChunk] = []
+        chunk_index = 0
+        for paragraph in valid_paragraphs:
+            paragraph_text = paragraph.text
+            # Ищем ID сносок только если НЕ пропускаем их
+            referenced_ids = []
+            if not self.skip_footnotes:
+                referenced_ids = [
+                    int(match.group(1))
+                    for match in FOOTNOTE_TAG_PATTERN.finditer(paragraph_text)
+                ]
+            
+            # Очищаем текст от тегов <N> всегда, т.к. они не нужны в чистом тексте
+            clean_text = FOOTNOTE_TAG_PATTERN.sub("", paragraph_text).strip()
+            if not clean_text: continue
+
+            # Формируем search_text: если skip_footnotes=True, он равен clean_text
+            search_text = clean_text
+            if not self.skip_footnotes and referenced_ids:
+                footnote_texts_for_search = []
+                unique_sorted_ids = sorted(list(set(referenced_ids)))
+                for ref_id in unique_sorted_ids:
+                    if ref_id in footnotes_map:
+                        footnote_texts_for_search.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                    else:
+                        logger.warning(f'Ссылка на отсутствующую сноску <{ref_id}> в параграфе: \'{clean_text[:50]}...\'')
+                if footnote_texts_for_search:
+                    search_text += '\n\nПримечания:\n' + '\n'.join(footnote_texts_for_search)
+
+            chunk_instance = BlmChunk(
+                id=uuid4(),
+                name=f"{doc_entity.name}_blm_paragraph_{chunk_index}",
+                text=clean_text,
+                in_search_text=search_text,
+                metadata={},
+                source_id=None,
+                target_id=doc_entity.id,
+                number_in_relation=chunk_index,
+                groupper=self.DEFAULT_GROUPPER,
+                # referenced_ids будет пуст, если skip_footnotes=True
+                referenced_footnote_ids=referenced_ids, 
+            )
+            chunk_instance.owner_id = doc_entity.id
+            initial_chunks.append(chunk_instance)
+            chunk_index += 1
+
+        if not initial_chunks: return []
+
+        # Этап 2: Слияние коротких чанков (BlmChunk)
+        merged_chunks: list[BlmChunk] = []
+        i = 0
+        while i < len(initial_chunks):
+            current_chunk = initial_chunks[i]
+            word_count = len(current_chunk.text.split())
+
+            if word_count < MIN_WORDS_PER_CHUNK and i + 1 < len(initial_chunks):
+                next_chunk = initial_chunks[i + 1]
+                merged_text = f"{current_chunk.text}\n\n{next_chunk.text}"
+                merged_refs = []
+                # Объединяем ссылки только если не пропускаем сноски
+                if not self.skip_footnotes:
+                    merged_refs = sorted(list(set(current_chunk.referenced_footnote_ids + next_chunk.referenced_footnote_ids)))
+                
+                # Перестраиваем search_text для следующего чанка
+                merged_search_text = merged_text
+                if not self.skip_footnotes and merged_refs:
+                    merged_footnote_texts = []
+                    for ref_id in merged_refs:
+                        if ref_id in footnotes_map: # footnotes_map пуст, если skip_footnotes=True
+                             merged_footnote_texts.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                    if merged_footnote_texts:
+                        merged_search_text += '\n\nПримечания:\n' + '\n'.join(merged_footnote_texts)
+                
+                next_chunk.text = merged_text
+                next_chunk.in_search_text = merged_search_text
+                next_chunk.referenced_footnote_ids = merged_refs
+                i += 1 
+            elif word_count < MIN_WORDS_PER_CHUNK and i > 0 and not merged_chunks:
+                 if merged_chunks:
+                      prev_chunk = merged_chunks[-1]
+                      merged_text = f"{prev_chunk.text}\n\n{current_chunk.text}"
+                      merged_refs = []
+                      if not self.skip_footnotes:
+                           merged_refs = sorted(list(set(prev_chunk.referenced_footnote_ids + current_chunk.referenced_footnote_ids)))
+                      
+                      merged_search_text = merged_text
+                      if not self.skip_footnotes and merged_refs:
+                           merged_footnote_texts = []
+                           for ref_id in merged_refs:
+                                if ref_id in footnotes_map:
+                                     merged_footnote_texts.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                           if merged_footnote_texts:
+                                 merged_search_text += '\n\nПримечания:\n' + '\n'.join(merged_footnote_texts)
+                      
+                      prev_chunk.text = merged_text
+                      prev_chunk.in_search_text = merged_search_text
+                      prev_chunk.referenced_footnote_ids = merged_refs
+                      i += 1
+                 else: # Первый короткий
+                      merged_chunks.append(current_chunk)
+                      i += 1
+            elif word_count < MIN_WORDS_PER_CHUNK and i == 0 and len(initial_chunks) == 1:
+                 merged_chunks.append(current_chunk)
+                 i += 1
+            else:
+                merged_chunks.append(current_chunk)
+                i += 1
+
+        if not merged_chunks: return []
+
+        # Этап 3: Разделение длинных чанков (BlmChunk)
+        final_chunks: list[BlmChunk] = []
+        for chunk in merged_chunks:
+            words = chunk.text.split()
+            if len(words) > MAX_WORDS_PER_CHUNK:
+                sub_chunk_texts = []
+                for j in range(0, len(words), MAX_WORDS_PER_CHUNK):
+                    sub_chunk_words = words[j:j + MAX_WORDS_PER_CHUNK]
+                    sub_chunk_texts.append(" ".join(sub_chunk_words))
+                
+                # Ссылки на сноски копируются, но блок примечаний формируется только если не skip
+                chunk_refs = chunk.referenced_footnote_ids if not self.skip_footnotes else []
+                footnote_block = ""
+                if not self.skip_footnotes and chunk_refs:
+                     footnote_texts_for_sub_chunks = []
+                     unique_sorted_refs = sorted(list(set(chunk_refs)))
+                     for ref_id in unique_sorted_refs:
+                         if ref_id in footnotes_map:
+                             footnote_texts_for_sub_chunks.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                     if footnote_texts_for_sub_chunks:
+                          footnote_block = '\n\nПримечания:\n' + '\n'.join(footnote_texts_for_sub_chunks)
+                     
+                for part_index, sub_text in enumerate(sub_chunk_texts):
+                    # search_text включает блок примечаний только если не skip
+                    sub_search_text = sub_text + footnote_block 
+                    sub_chunk_instance = BlmChunk(
+                        id=uuid4(),
+                        name=f"{chunk.name}_part_{part_index}", 
+                        text=sub_text,
+                        in_search_text=sub_search_text,
+                        metadata=chunk.metadata.copy(),
+                        source_id=chunk.source_id,
+                        target_id=chunk.target_id,
+                        number_in_relation=-1, 
+                        groupper=chunk.groupper,
+                        referenced_footnote_ids=chunk_refs, # Список будет пуст, если skip=True
+                    )
+                    sub_chunk_instance.owner_id = chunk.owner_id
+                    final_chunks.append(sub_chunk_instance)
+            else:
+                final_chunks.append(chunk)
+
+        # Этап 4: Обновление нумерации и имен
+        for final_index, chunk in enumerate(final_chunks):
+            chunk.number_in_relation = final_index
+            base_name = f"{doc_entity.name}_blm_paragraph_{final_index}"
+            if "_part_" in chunk.name:
+                chunk.name = base_name + chunk.name[chunk.name.rfind("_part_"):]
+            else:
+                 chunk.name = base_name
+                 
+        logger.info(
+            f"Документ {doc_entity.name} (BLM Paragraph, skip_footnotes={self.skip_footnotes}) разбит на {len(final_chunks)} чанков."
+        )
+        return final_chunks
+
+    @classmethod
+    def _build_sequenced_chunks(
+        cls,
+        repository: EntityRepository,
+        group: list[Chunk],
+    ) -> str:
+        """
+        Собирает текст для НЕПРЕРЫВНОЙ последовательности BlmChunk (параграфы).
+        Добавляет блок "Примечания" в конце группы, если есть ссылки на сноски.
+
+        Args:
+            repository: Репозиторий для получения карты сносок из документа-владельца.
+            group: Список последовательных Chunk (ожидаются BlmChunk).
+
+        Returns:
+            Собранный текст для данной группы с примечаниями.
+        """
+        if not group:
+            return ""
+
+        if not all(isinstance(c, BlmChunk) for c in group):
+            logger.warning(
+                "В _build_sequenced_chunks (BLM) передан список, содержащий не BlmChunk. Используется базовая сборка параграфов."
+            )
+            return "\n\n".join([cls._build_chunk(chunk) for chunk in group])
+
+        typed_group: list[BlmChunk] = group
+
+        main_text = "\n\n".join([cls._build_chunk(chunk) for chunk in typed_group])
+
+        # Проверяем, есть ли вообще ссылки и нужно ли добавлять блок
+        all_ref_ids = set()
+        if not group or not isinstance(group[0], BlmChunk):
+             # На всякий случай, если пришла не та группа
+             return "\n\n".join([cls._build_chunk(chunk) for chunk in group]) 
+             
+        first_blm_chunk = group[0]
+        # Проверяем skip_footnotes по первой сущности (предполагаем, что у всех одинаково)
+        # TODO: Как надежно узнать skip_footnotes при сборке? Пока предполагаем, что если есть refs, то не skip.
+        # Лучше: Передавать skip_footnotes в InjectionBuilder и далее сюда?
+        # Пока: если нет ссылок в чанках, блок не добавляем.
+        needs_footnote_block = False
+        for chunk in group:
+            if isinstance(chunk, BlmChunk) and chunk.referenced_footnote_ids:
+                 all_ref_ids.update(chunk.referenced_footnote_ids)
+                 needs_footnote_block = True # Нашли х��тя бы одну ссылку
+        
+        # Если не нужно добавлять блок (нет ссылок или skip_footnotes был True при создании)
+        if not needs_footnote_block:
+             return main_text
+
+        first_chunk = typed_group[0]
+        owner_id = first_chunk.owner_id
+        footnotes_map = {}
+        if owner_id:
+            try:
+                doc_entity = repository.get_entity_by_id(owner_id)
+                if (
+                    doc_entity
+                    and isinstance(doc_entity, (DocumentAsEntity, LinkerEntity))
+                    and hasattr(doc_entity, 'metadata')
+                ):
+                    entity_metadata = doc_entity.metadata or {}
+                    footnotes_map = entity_metadata.get('blm_footnotes', {})
+                    if not footnotes_map:
+                        logger.warning(
+                            f"Метаданные 'blm_footnotes' пусты или отсутствуют для документа {owner_id}."
+                        )
+                else:
+                    logger.error(
+                        f"Не удалось найти DocumentAsEntity/LinkerEntity с метаданными для ID {owner_id} (группа чанков начиная с {first_chunk.name})"
+                    )
+            except Exception as e:
+                logger.error(
+                    f"Ошибка при получении DocumentAsEntity ({owner_id}) или его метаданных из репозитория: {e}",
+                    exc_info=True,
+                )
+        else:
+            logger.error(f"У первого чанка {first_chunk.name} отсутствует owner_id.")
+
+        if not footnotes_map:
+            logger.warning(
+                f"Карта сносок 'blm_footnotes' не найдена или пуста для документа {owner_id}. Блок примечаний не будет добавлен."
+            )
+            return main_text
+
+        footnotes_block_parts = []
+        missing_footnotes = []
+        for ref_id in sorted(list(all_ref_ids)):
+            if ref_id in footnotes_map:
+                footnotes_block_parts.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+            else:
+                missing_footnotes.append(str(ref_id))
+                footnotes_block_parts.append(f'<{ref_id}> [Сноска не найдена]')
+
+        if missing_footnotes:
+            logger.warning(
+                f'В документе {owner_id} не найдены определения для сносок: {", ".join(missing_footnotes)}'
+            )
+
+        if footnotes_block_parts:
+            footnotes_block = '\n\nПримечания:\n' + '\n'.join(footnotes_block_parts)
+            return main_text + footnotes_block
+        else:
+            return main_text

lib/extractor/ntr_text_fragmentation/chunking/specific_strategies/blm/blm_sentence_chunking.py

@@ -0,0 +1,415 @@
+"""
+BLM-специфичная стратегия чанкинга по предложениям.
+"""
+
+import logging
+from uuid import uuid4
+
+# Импортируем nltk
+try:
+    import nltk
+except ImportError:
+    logger.exception(
+        "Фатальная ошибка: Библиотека NLTK не найдена. Установите ее: pip install nltk "
+        "и загрузите необходимые данные: python -m nltk.downloader punkt"
+    )
+    raise ImportError(
+        "Библиотека NLTK не найдена. Установите ее и данные 'punkt'."
+    ) from None
+
+from ntr_fileparser import ParsedDocument
+
+from ....models import DocumentAsEntity, LinkerEntity
+from ....repositories import EntityRepository
+from ...chunking_registry import register_chunking_strategy
+from ...chunking_strategy import ChunkingStrategy
+from ...models import Chunk
+# Импортируем BlmChunk и утилиты
+from .blm_chunk import BlmChunk
+from .blm_utils import FOOTNOTE_TAG_PATTERN, _preprocess_blm_paragraphs
+
+logger = logging.getLogger(__name__)
+
+BLM_SENTENCE = "blm_sentence"
+MIN_WORDS_PER_CHUNK = 4  # Минимальное кол-во слов для отдельного чанка
+MAX_WORDS_PER_CHUNK = 150 # Максимальное кол-во слов в чанке
+
+
+@register_chunking_strategy(BLM_SENTENCE)
+class BlmSentenceChunkingStrategy(ChunkingStrategy):
+    """
+    BLM-специфичная стратегия: чанкинг по предложениям с обработкой сносок.
+
+    - Игнорирует параграфы-сноски и неинформативные параграфы перед обработкой.
+    - Находит теги <N> в тексте, удаляет их перед разбивкой на предложения.
+    - Сопоставляет предложения с исходными тегами сносок по позициям.
+    - Создает `BlmChunk`, сохраняя ссылки на релевантные сноски.
+    - Формирует `in_search_text` с добавлением текстов сносок.
+    - При сборке (`_build_sequenced_chunks`) добавляет блок "Примечания".
+    """
+
+    DEFAULT_GROUPPER: str = "blm_sentence"
+
+    def __init__(self, skip_footnotes: bool = False):
+        """Инициализация стратегии.
+        Проверяем наличие данных nltk 'punkt', скачиваем при необходимости.
+        Args:
+            skip_footnotes: Если True, сноски будут игнорироваться при обработке.
+        """
+        self.skip_footnotes = skip_footnotes
+        logger.info(f"BlmSentenceChunkingStrategy инициализирована с skip_footnotes={skip_footnotes}")
+        
+        # Проверка и загрузка nltk 'punkt'
+        try:
+            nltk.data.find('tokenizers/punkt')
+            logger.debug("Данные NLTK 'punkt' найдены.")
+        except LookupError:
+            logger.info(
+                "Данные NLTK 'punkt' не найдены. Попытка автоматической загрузки..."
+            )
+            try:
+                nltk.download('punkt')
+                nltk.data.find('tokenizers/punkt') # Повторная проверка
+                logger.info("Данные NLTK 'punkt' успешно загружены.")
+            except FileNotFoundError:
+                 logger.exception(
+                    "Ошибка FileNotFoundError при загрузке данных nltk 'punkt'. " 
+                    "Проверьте права доступа или попробуйте загрузить вручную: \n" 
+                    "import nltk; nltk.download('punkt')"
+                 )
+                 raise LookupError(
+                    "Не удалось найти или загрузить данные NLTK 'punkt' из-за ошибки файловой системы." 
+                    "(см. лог ошибок)"
+                 ) from None
+            except Exception as e:
+                 logger.exception(
+                    f"Не удалось автоматически загрузить данные NLTK 'punkt': {e}. "
+                    "Пожалуйста, загрузите их вручную: запустите Python и выполните:\n"
+                    "import nltk\nnltk.download('punkt')"
+                 )
+                 raise LookupError(
+                     "Не удалось найти или загрузить данные NLTK 'punkt'. "
+                     "(см. лог ошибок для инструкции)"
+                 ) from e
+
+    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]:
+        """
+        Разбивает документ на BlmChunk (предложения) с обработкой сносок.
+        """
+        # Передаем флаг в препроцессор
+        footnotes_map, valid_paragraphs = _preprocess_blm_paragraphs(
+            document.paragraphs, extract_map=not self.skip_footnotes
+        )
+        
+        if not self.skip_footnotes:
+            if not hasattr(doc_entity, 'metadata') or doc_entity.metadata is None:
+                doc_entity.metadata = {}
+            doc_entity.metadata['blm_footnotes'] = footnotes_map
+        elif hasattr(doc_entity, 'metadata') and doc_entity.metadata is not None:
+             doc_entity.metadata.pop('blm_footnotes', None)
+
+        if not valid_paragraphs:
+            logger.info(f"Документ {doc_entity.name} (BLM Sentence) не содержит валидных параграфов для чанкинга.")
+            return []
+
+        # 1. Собираем текст, находим позиции тегов и очищаем
+        full_text_parts = []
+        original_offsets = [] 
+        current_offset = 0
+        for paragraph in valid_paragraphs:
+            text = paragraph.text
+            matches = list(FOOTNOTE_TAG_PATTERN.finditer(text))
+            last_match_end = 0
+            clean_part = ""
+            for match in matches:
+                part_before = text[last_match_end:match.start()]
+                clean_part += part_before
+                # Сохраняем позицию тега только если не пропускаем сноски
+                if not self.skip_footnotes:
+                    try:
+                        tag_id = int(match.group(1))
+                        tag_position_in_clean_text = len(clean_part) + current_offset
+                        original_offsets.append((tag_position_in_clean_text, tag_position_in_clean_text, tag_id))
+                    except ValueError: # Пропускаем невалидные теги
+                         logger.warning(f"Не удалось распознать номер в теге сноски: {match.group(1)} в параграфе.")
+                         pass 
+                last_match_end = match.end()
+            
+            part_after = text[last_match_end:]
+            clean_part += part_after
+            
+            stripped_clean_part = clean_part.strip()
+            if stripped_clean_part:
+                 full_text_parts.append(stripped_clean_part)
+                 current_offset += len(stripped_clean_part) + 2 
+
+        if current_offset > 0: current_offset -= 2
+        clean_full_text = "\n\n".join(full_text_parts)
+        if not clean_full_text: return []
+
+        # 2. Разбиваем очищенный текст на предложения
+        try:
+            sentences = nltk.sent_tokenize(clean_full_text, language='russian')
+        except Exception as e:
+            logger.error(f"Ошибка при токенизации предложений (BLM) в {doc_entity.name}: {e}", exc_info=True)
+            return []
+
+        # Этап 1 (продолжение): Создание первичных чанков BlmChunk
+        initial_chunks: list[BlmChunk] = []
+        chunk_index = 0
+        current_search_offset = 0
+        for sentence_text in sentences:
+            sentence_text_stripped = sentence_text.strip()
+            if not sentence_text_stripped:
+                 if sentence_text in clean_full_text[current_search_offset:]:
+                      current_search_offset += len(sentence_text)                     
+                 continue
+                
+            sentence_start_pos = clean_full_text.find(sentence_text_stripped, current_search_offset)
+            if sentence_start_pos == -1: 
+                 logger.warning(f"Не удалось найти позицию предложения (BLM): \'{sentence_text_stripped[:50]}...\'")
+                 sentence_start_pos = clean_full_text.find(sentence_text_stripped)
+                 if sentence_start_pos == -1:
+                      logger.error("Полностью не удалось найти предложение, пропускаем.")
+                      current_search_offset += len(sentence_text_stripped) 
+                      continue
+            
+            sentence_end_pos = sentence_start_pos + len(sentence_text_stripped)
+            current_search_offset = sentence_end_pos
+
+            # Находим ID сносок только если не пропускаем их
+            referenced_ids = []
+            if not self.skip_footnotes:
+                 referenced_ids = [offset[2] for offset in original_offsets if sentence_start_pos <= offset[0] < sentence_end_pos]
+
+            # Ф��рмируем search_text
+            search_text = sentence_text_stripped
+            if not self.skip_footnotes and referenced_ids:
+                footnote_texts_for_search = []
+                unique_sorted_ids = sorted(list(set(referenced_ids)))
+                for ref_id in unique_sorted_ids:
+                    if ref_id in footnotes_map:
+                        footnote_texts_for_search.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                    else:
+                        logger.warning(f'Ссылка на отсутствующую сноску <{ref_id}> в предложении: \'{sentence_text_stripped[:50]}...\'')
+                if footnote_texts_for_search:
+                    search_text += '\n\nПримечания:\n' + '\n'.join(footnote_texts_for_search)
+
+            chunk_instance = BlmChunk(
+                id=uuid4(),
+                name=f"{doc_entity.name}_blm_sentence_{chunk_index}",
+                text=sentence_text_stripped,
+                in_search_text=search_text,
+                metadata={},
+                source_id=None,
+                target_id=doc_entity.id,
+                number_in_relation=chunk_index,
+                groupper=self.DEFAULT_GROUPPER,
+                referenced_footnote_ids=referenced_ids,
+            )
+            chunk_instance.owner_id = doc_entity.id
+            initial_chunks.append(chunk_instance)
+            chunk_index += 1
+            
+        if not initial_chunks: return []
+
+        # Этап 2: Слияние коротких чанков (BlmChunk)
+        # Логика идентична BlmParagraphChunkingStrategy, но text соединяется пробелом
+        merged_chunks: list[BlmChunk] = []
+        i = 0
+        while i < len(initial_chunks):
+            current_chunk = initial_chunks[i]
+            word_count = len(current_chunk.text.split())
+
+            if word_count < MIN_WORDS_PER_CHUNK and i + 1 < len(initial_chunks):
+                next_chunk = initial_chunks[i + 1]
+                merged_text = f"{current_chunk.text} {next_chunk.text}" # Соединяем пробелом
+                merged_refs = []
+                if not self.skip_footnotes:
+                    merged_refs = sorted(list(set(current_chunk.referenced_footnote_ids + next_chunk.referenced_footnote_ids)))
+                
+                merged_search_text = merged_text
+                if not self.skip_footnotes and merged_refs:
+                    merged_footnote_texts = []
+                    for ref_id in merged_refs:
+                        if ref_id in footnotes_map:
+                             merged_footnote_texts.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                    if merged_footnote_texts:
+                        merged_search_text += '\n\nПримечания:\n' + '\n'.join(merged_footnote_texts)
+                
+                next_chunk.text = merged_text
+                next_chunk.in_search_text = merged_search_text
+                next_chunk.referenced_footnote_ids = merged_refs
+                i += 1 
+            elif word_count < MIN_WORDS_PER_CHUNK and i > 0 and not merged_chunks:
+                 if merged_chunks:
+                      prev_chunk = merged_chunks[-1]
+                      merged_text = f"{prev_chunk.text} {current_chunk.text}" # Соединяем пробелом
+                      merged_refs = []
+                      if not self.skip_footnotes:
+                           merged_refs = sorted(list(set(prev_chunk.referenced_footnote_ids + current_chunk.referenced_footnote_ids)))
+                      
+                      merged_search_text = merged_text
+                      if not self.skip_footnotes and merged_refs:
+                           merged_footnote_texts = []
+                           for ref_id in merged_refs:
+                                if ref_id in footnotes_map:
+                                     merged_footnote_texts.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                           if merged_footnote_texts:
+                                 merged_search_text += '\n\nПримечания:\n' + '\n'.join(merged_footnote_texts)
+                      
+                      prev_chunk.text = merged_text
+                      prev_chunk.in_search_text = merged_search_text
+                      prev_chunk.referenced_footnote_ids = merged_refs
+                      i += 1
+                 else:
+                      merged_chunks.append(current_chunk)
+                      i += 1
+            elif word_count < MIN_WORDS_PER_CHUNK and i == 0 and len(initial_chunks) == 1:
+                 merged_chunks.append(current_chunk)
+                 i += 1
+            else:
+                merged_chunks.append(current_chunk)
+                i += 1
+
+        if not merged_chunks: return []
+
+        # Этап 3: Разделение длинных чанков (BlmChunk)
+        # Логика идентична BlmParagraphChunkingStrategy
+        final_chunks: list[BlmChunk] = []
+        for chunk in merged_chunks:
+            words = chunk.text.split()
+            if len(words) > MAX_WORDS_PER_CHUNK:
+                sub_chunk_texts = []
+                for j in range(0, len(words), MAX_WORDS_PER_CHUNK):
+                    sub_chunk_words = words[j:j + MAX_WORDS_PER_CHUNK]
+                    sub_chunk_texts.append(" ".join(sub_chunk_words))
+                
+                chunk_refs = chunk.referenced_footnote_ids if not self.skip_footnotes else []
+                footnote_block = ""
+                if not self.skip_footnotes and chunk_refs:
+                     footnote_texts_for_sub_chunks = []
+                     unique_sorted_refs = sorted(list(set(chunk_refs)))
+                     for ref_id in unique_sorted_refs:
+                         if ref_id in footnotes_map:
+                             footnote_texts_for_sub_chunks.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+                     if footnote_texts_for_sub_chunks:
+                          footnote_block = '\n\nПримечания:\n' + '\n'.join(footnote_texts_for_sub_chunks)
+                     
+                for part_index, sub_text in enumerate(sub_chunk_texts):
+                    sub_search_text = sub_text + footnote_block 
+                    sub_chunk_instance = BlmChunk(
+                        id=uuid4(),
+                        name=f"{chunk.name}_part_{part_index}", 
+                        text=sub_text,
+                        in_search_text=sub_search_text,
+                        metadata=chunk.metadata.copy(),
+                        source_id=chunk.source_id,
+                        target_id=chunk.target_id,
+                        number_in_relation=-1, 
+                        groupper=chunk.groupper,
+                        referenced_footnote_ids=chunk_refs,
+                    )
+                    sub_chunk_instance.owner_id = chunk.owner_id
+                    final_chunks.append(sub_chunk_instance)
+            else:
+                final_chunks.append(chunk)
+
+        # Этап 4: Обновление нумерации и имен
+        # Логика идентична BlmParagraphChunkingStrategy
+        for final_index, chunk in enumerate(final_chunks):
+            chunk.number_in_relation = final_index
+            base_name = f"{doc_entity.name}_blm_sentence_{final_index}"
+            if "_part_" in chunk.name:
+                chunk.name = base_name + chunk.name[chunk.name.rfind("_part_"):]
+            else:
+                 chunk.name = base_name
+                 
+        logger.info(
+            f"Документ {doc_entity.name} (BLM Sentence, skip_footnotes={self.skip_footnotes}) разбит на {len(final_chunks)} чанков."
+        )
+        return final_chunks
+
+    @classmethod
+    def _build_sequenced_chunks(
+        cls,
+        repository: EntityRepository,
+        group: list[Chunk],
+    ) -> str:
+        """
+        Собирает текст для НЕПРЕРЫВНОЙ последовательности BlmChunk (предложения).
+        Добавляет блок "Примечания" в конце группы, если нужно.
+        """
+        if not group:
+            return ""
+
+        if not all(isinstance(c, BlmChunk) for c in group):
+            logger.warning("В _build_sequenced_chunks (BLM Sentence) передан список, содержащий не BlmChunk. Используется базовая сборка предложений.")
+            return " ".join([cls._build_chunk(chunk) for chunk in group])
+
+        typed_group: list[BlmChunk] = group 
+
+        main_text = " ".join([cls._build_chunk(chunk) for chunk in typed_group])
+
+        all_ref_ids = set()
+        needs_footnote_block = False
+        for chunk in typed_group:
+            if chunk.referenced_footnote_ids: # Если список не пуст, значит skip_footnotes=False при создании
+                 all_ref_ids.update(chunk.referenced_footnote_ids)
+                 needs_footnote_block = True
+        
+        if not needs_footnote_block:
+             return main_text
+
+        # Логика получения footnotes_map и формирования блока идентична параграфной
+        first_chunk = typed_group[0]
+        owner_id = first_chunk.owner_id
+        footnotes_map = {}
+        if owner_id:
+            try:
+                doc_entity = repository.get_entity_by_id(owner_id)
+                if doc_entity and isinstance(doc_entity, (DocumentAsEntity, LinkerEntity)) and hasattr(doc_entity, 'metadata'):
+                    entity_metadata = doc_entity.metadata or {}
+                    footnotes_map = entity_metadata.get('blm_footnotes', {})
+                    if not footnotes_map:
+                         logger.warning(f"Метаданные 'blm_footnotes' пусты или отсутствуют для документа {owner_id}.")
+                else:
+                    logger.error(f"Не удалось найти DocumentAsEntity/LinkerEntity с метаданными для ID {owner_id}.")
+            except Exception as e:
+                logger.error(f"Ошибка при получении DocumentAsEntity ({owner_id}) или метаданных: {e}", exc_info=True)
+        else:
+            logger.error(f"У первого чанка {first_chunk.name} отсутствует owner_id.")
+
+        if not footnotes_map:
+            logger.warning(f"Карта сносок 'blm_footnotes' не найдена для документа {owner_id}. Блок примечаний не будет добавлен.")
+            return main_text
+
+        footnotes_block_parts = []
+        missing_footnotes = []
+        for ref_id in sorted(list(all_ref_ids)):
+            if ref_id in footnotes_map:
+                footnotes_block_parts.append(f"<{ref_id}> {footnotes_map[ref_id]}")
+            else:
+                missing_footnotes.append(str(ref_id))
+                footnotes_block_parts.append(f'<{ref_id}> [Сноска не найдена]')
+
+        if missing_footnotes:
+            logger.warning(f'В документе {owner_id} не найдены определения для сносок: {", ".join(missing_footnotes)}')
+
+        if footnotes_block_parts:
+            footnotes_block = '\n\nПримечания:\n' + '\n'.join(footnotes_block_parts)
+            return main_text + footnotes_block
+        else:
+            return main_text 

lib/extractor/ntr_text_fragmentation/chunking/specific_strategies/blm/blm_utils.py

@@ -0,0 +1,86 @@
+"""
+Утилиты для BLM-специфичных стратегий чанкинга.
+"""
+import logging
+import re
+from typing import Tuple
+
+from ntr_fileparser import ParsedTextBlock
+
+logger = logging.getLogger(__name__)
+
+
+# Паттерн для поиска сносок вида <{number}>
+FOOTNOTE_TAG_PATTERN = re.compile(r"<(\d+)>", re.IGNORECASE)
+# Паттерн для определения параграфа, являющегося текстом сноски
+FOOTNOTE_DEF_PATTERN = re.compile(r"^<(\d+)>(.*)", re.IGNORECASE)
+# Паттерн для игнорируемых параграфов (пустые, разделители и т.п.)
+# Проверяет строки, состоящие только из пробелов, -, _, *, ., или полностью пустые
+IGNORE_PARAGRAPH_PATTERN = re.compile(r"^\s*([-_*.\s]*)$", re.UNICODE)
+
+def _preprocess_blm_paragraphs(
+    paragraphs: list[ParsedTextBlock],
+    extract_map: bool = True,
+) -> Tuple[dict[int, str], list[ParsedTextBlock]]:
+    """Извлекает сноски (если extract_map=True), фильтрует невалидные параграфы.
+
+    Args:
+        paragraphs: Список всех параграфов из ParsedDocument.
+        extract_map: Если True, извлекает и возвращает карту сносок.
+
+    Returns:
+        Кортеж: (словарь сносок {номер: текст}, список валидных параграфов).
+                Словарь будет пустым, если extract_map=False.
+    """
+    footnotes_map: dict[int, str] = {}
+    valid_paragraphs: list[ParsedTextBlock] = []
+    ignored_count = 0
+    footnote_defs_count = 0
+
+    for p in paragraphs:
+        if not isinstance(p, ParsedTextBlock):
+            ignored_count += 1
+            continue
+        
+        text_stripped = p.text.strip()
+        
+        # Проверка на определение сноски (только если extract_map=True)
+        if extract_map:
+            footnote_match = FOOTNOTE_DEF_PATTERN.match(text_stripped)
+            if footnote_match:
+                try:
+                    footnote_num = int(footnote_match.group(1))
+                    footnote_text = footnote_match.group(2).strip()
+                    footnotes_map[footnote_num] = footnote_text
+                    footnote_defs_count += 1
+                except ValueError:
+                    logger.warning(f"Не удалось распознать номер в теге сноски: {footnote_match.group(1)}")
+                continue # Параграф с определением сноски пропускаем в любом случае
+
+        # Проверка на игнорируемый/неинформативный параграф
+        if not text_stripped or IGNORE_PARAGRAPH_PATTERN.match(text_stripped):
+            # Если не извлекаем карту, но это определение сноски - тоже игнорируем
+            if not extract_map and FOOTNOTE_DEF_PATTERN.match(text_stripped):
+                 ignored_count += 1
+                 footnote_defs_count += 1 # Считаем как определение, даже если не сохраняем
+                 continue
+            # Иначе это просто мусор
+            ignored_count += 1
+            continue
+        
+        valid_paragraphs.append(p)
+
+    # Корректируем лог в зависимости от флага
+    log_msg_start = f"Предварительная обработка BLM (extract_map={extract_map}): "
+    log_msg_parts = []
+    if extract_map:
+        log_msg_parts.append(f"Найдено определений сносок: {footnote_defs_count}")
+    else:
+        log_msg_parts.append(f"Проигнорировано определений сносок: {footnote_defs_count}")
+        
+    log_msg_parts.append(f"Игнорировано/пустых параграфов: {ignored_count}")
+    log_msg_parts.append(f"Валидных параграфов для чанкинга: {len(valid_paragraphs)}")
+    
+    logger.debug(log_msg_start + ", ".join(log_msg_parts))
+    
+    return footnotes_map, valid_paragraphs 

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

@@ -0,0 +1,180 @@
+"""
+Стратегия чанкинга по абзацам.
+"""
+
+import logging
+from uuid import uuid4
+
+from ntr_fileparser import ParsedDocument, ParsedTextBlock
+
+from ...models import DocumentAsEntity, LinkerEntity
+from ...repositories import EntityRepository
+from ..chunking_registry import register_chunking_strategy
+from ..chunking_strategy import ChunkingStrategy
+from ..models import Chunk
+
+logger = logging.getLogger(__name__)
+
+PARAGRAPH = "paragraph"
+MIN_WORDS_PER_CHUNK = 6  # Сливаем, если <= 5 слов
+MAX_WORDS_PER_CHUNK = 300 # Разделяем, если > 300 слов
+
+
+@register_chunking_strategy(PARAGRAPH)
+class ParagraphChunkingStrategy(ChunkingStrategy):
+    """
+    Стратегия чанкинга, разбивающая документ на чанки, где каждый чанк - это абзац.
+
+    Создает базовые экземпляры `Chunk` для каждого непустого текстового блока.
+    При сборке (`dechunk`) соединяет абзацы двойным переносом строки.
+    """
+
+    DEFAULT_GROUPPER: str = "paragraph"  # Группа для связывания и сортировки
+
+    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]:
+        """
+        Разбивает документ на чанки-абзацы, применяя правила слияния/разделения.
+
+        Args:
+            document: Документ для чанкинга.
+            doc_entity: Сущность документа-владельца.
+
+        Returns:
+            Список созданных Chunk.
+        """
+        # Этап 1: Создание первичных чанков (по параграфам)
+        initial_chunks: list[Chunk] = []
+        chunk_index = 0
+        for paragraph in document.paragraphs:
+            if not isinstance(paragraph, ParsedTextBlock) or not paragraph.text.strip():
+                continue
+            paragraph_text = paragraph.text.strip()
+            if not paragraph_text: # Дополнительная проверка после strip
+                 continue
+
+            chunk_instance = Chunk(
+                id=uuid4(),
+                name=f"{doc_entity.name}_paragraph_{chunk_index}", # Временное имя
+                text=paragraph_text,
+                in_search_text=paragraph_text, 
+                metadata={},
+                source_id=None, 
+                target_id=doc_entity.id,
+                number_in_relation=chunk_index, # Временный индекс
+                groupper=self.DEFAULT_GROUPPER,
+            )
+            chunk_instance.owner_id = doc_entity.id
+            initial_chunks.append(chunk_instance)
+            chunk_index += 1
+
+        if not initial_chunks: return []
+
+        # Этап 2: Слияние коротких чанков
+        merged_chunks: list[Chunk] = []
+        i = 0
+        while i < len(initial_chunks):
+            current_chunk = initial_chunks[i]
+            word_count = len(current_chunk.text.split())
+
+            # Логика слияния - аналогична sentence, но соединяем через \n\n
+            if word_count < MIN_WORDS_PER_CHUNK and i + 1 < len(initial_chunks):
+                next_chunk = initial_chunks[i + 1]
+                # Соединяем абзацы через двойной перенос строки
+                merged_text = f"{current_chunk.text}\n\n{next_chunk.text}"
+                next_chunk.text = merged_text
+                next_chunk.in_search_text = merged_text 
+                i += 1 
+            elif word_count < MIN_WORDS_PER_CHUNK and i > 0 and not merged_chunks:
+                 if merged_chunks:
+                      prev_chunk = merged_chunks[-1]
+                      merged_text = f"{prev_chunk.text}\n\n{current_chunk.text}"
+                      prev_chunk.text = merged_text
+                      prev_chunk.in_search_text = merged_text
+                      i += 1
+                 else:
+                      merged_chunks.append(current_chunk)
+                      i += 1
+            elif word_count < MIN_WORDS_PER_CHUNK and i == 0 and len(initial_chunks) == 1:
+                 merged_chunks.append(current_chunk)
+                 i += 1
+            else:
+                merged_chunks.append(current_chunk)
+                i += 1
+                
+        if not merged_chunks: return []
+
+        # Этап 3: ��азделение длинных чанков
+        final_chunks: list[Chunk] = []
+        for chunk in merged_chunks:
+            words = chunk.text.split()
+            if len(words) > MAX_WORDS_PER_CHUNK:
+                sub_chunk_texts = []
+                # Делим по словам, сохраняя абзацную структуру в _build_sequenced_chunks
+                for j in range(0, len(words), MAX_WORDS_PER_CHUNK):
+                    sub_chunk_words = words[j:j + MAX_WORDS_PER_CHUNK]
+                    sub_chunk_texts.append(" ".join(sub_chunk_words)) # Соединяем слова пробелом
+                
+                for part_index, sub_text in enumerate(sub_chunk_texts):
+                    sub_chunk_instance = Chunk(
+                        id=uuid4(),
+                        name=f"{chunk.name}_part_{part_index}", 
+                        text=sub_text,
+                        in_search_text=sub_text,
+                        metadata=chunk.metadata.copy(),
+                        source_id=chunk.source_id,
+                        target_id=chunk.target_id,
+                        number_in_relation=-1, 
+                        groupper=chunk.groupper,
+                    )
+                    sub_chunk_instance.owner_id = chunk.owner_id
+                    final_chunks.append(sub_chunk_instance)
+            else:
+                final_chunks.append(chunk)
+
+        # Этап 4: Обновление нумерации и имен
+        for final_index, chunk in enumerate(final_chunks):
+            chunk.number_in_relation = final_index
+            base_name = f"{doc_entity.name}_paragraph_{final_index}"
+            if "_part_" in chunk.name:
+                chunk.name = base_name + chunk.name[chunk.name.rfind("_part_"):]
+            else:
+                 chunk.name = base_name
+                 
+        logger.info(
+            f"Документ {doc_entity.name} (Paragraph) разбит на {len(final_chunks)} чанков (после слияния/разделения)."
+        )
+        return final_chunks
+
+    @classmethod
+    def _build_sequenced_chunks(
+        cls,
+        repository: EntityRepository,
+        group: list[Chunk],
+    ) -> str:
+        """
+        Собирает текст для НЕПРЕРЫВНОЙ последовательности чанков-абзацев.
+
+        Соединяет текст абзацев двойным переносом строки.
+
+        Args:
+            repository: Репозиторий (не используется в данной реализации).
+            group: Список последовательных Chunk (абзацев).
+
+        Returns:
+            Собранный текст для данной группы.
+        """
+        # Используем _build_chunk из базового класса, он просто возвращает chunk.text
+        return "\n\n".join([cls._build_chunk(chunk) for chunk in group]) 

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

@@ -0,0 +1,261 @@
+"""
+Стратегия чанкинга по предложениям.
+"""
+
+import logging
+from uuid import uuid4
+
+# Импортируем nltk
+try:
+    import nltk
+except ImportError:
+    # Эта ошибка фатальна, так как без nltk стратегия не может работать
+    logger.exception(
+        "Фатальная ошибка: Библиотека NLTK не найдена. Установите ее: pip install nltk "
+        "и загрузите необходимые данные: python -m nltk.downloader punkt"
+    )
+    raise ImportError(
+        "Библиотека NLTK не найдена. Установите ее и данные 'punkt'."
+    ) from None
+
+from ntr_fileparser import ParsedDocument, ParsedTextBlock
+
+from ...models import DocumentAsEntity, LinkerEntity
+from ..chunking_registry import register_chunking_strategy
+from ..chunking_strategy import ChunkingStrategy
+from ..models import Chunk
+
+logger = logging.getLogger(__name__)
+
+SENTENCE = "sentence"
+MIN_WORDS_PER_CHUNK = 4
+MAX_WORDS_PER_CHUNK = 150
+
+
+@register_chunking_strategy(SENTENCE)
+class SentenceChunkingStrategy(ChunkingStrategy):
+    """
+    Стратегия чанкинга, разбивающая документ на чанки, где каждый чанк - это предложение.
+
+    Использует `nltk.sent_tokenize` для разбиения на предложения.
+    Создает базовые экземпляры `Chunk`.
+    При сборке (`dechunk`) использует стандартное соединение пробелом.
+    """
+
+    DEFAULT_GROUPPER: str = "sentence"  # Группа для связывания и сортировки
+
+    def __init__(self):
+        """Инициализация стратегии. Проверяем наличие данных nltk 'punkt', скачиваем при необходимости."""
+        try:
+            nltk.data.find('tokenizers/punkt')
+            logger.debug("Данные NLTK 'punkt' найдены.")
+        except LookupError:
+            logger.info(
+                "Данные NLTK 'punkt' не найдены. Попытка автоматической загрузки..."
+            )
+            try:
+                nltk.download('punkt')
+                # Повторная проверка после скачивания
+                nltk.data.find('tokenizers/punkt')
+                logger.info("Данные NLTK 'punkt' успешно загружены.")
+            except FileNotFoundError:
+                 # Ошибка часто возникает в ограниченных окружениях или если nltk не может найти/создать папку
+                 logger.exception(
+                    "Ошибка FileNotFoundError при загрузке данных nltk 'punkt'. " 
+                    "Проверьте права доступа или попробуйте загрузить вручную: \n" 
+                    "import nltk; nltk.download('punkt')"
+                 )
+                 raise LookupError(
+                    "Не удалось найти или загрузить данные NLTK 'punkt' из-за ошибки файловой системы." 
+                    "(см. лог ошибок)"
+                 ) from None
+            except Exception as e:
+                 logger.exception(
+                    f"Не удалось автоматически загрузить данные NLTK 'punkt': {e}. "
+                    "Пожалуйста, загрузите их вручную: запустите Python и выполните:\n"
+                    "import nltk\nnltk.download('punkt')"
+                 )
+                 # Перевыбрасываем исходную ошибку или новую, указывающую на проблему загрузки
+                 raise LookupError(
+                     "Не удалось найти или загрузить данные NLTK 'punkt'. "
+                     "(см. лог ошибок для инструкции)"
+                 ) from e
+
+    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]:
+        """Разбивает документ на чанки-предложения.
+
+        Args:
+            document (ParsedDocument): Документ для чанкинга.
+            doc_entity (DocumentAsEntity): Сущность документа-владельца.
+
+        Returns:
+            list[LinkerEntity]: Список созданных Chunk.
+        """
+        result_chunks: list[Chunk] = []
+        chunk_index = 0
+
+        # 1. Собираем весь текст документа, разделяя параграфы
+        full_text_parts = []
+        for paragraph in document.paragraphs:
+            # Учитываем только текстовые блоки с непустым текстом
+            if isinstance(paragraph, ParsedTextBlock) and paragraph.text and paragraph.text.strip():
+                full_text_parts.append(paragraph.text.strip())
+
+        if not full_text_parts:
+            logger.info(f"Документ {doc_entity.name} не содержит текста для чанкинга предложениями.")
+            return []
+
+        full_text = "\n\n".join(full_text_parts)
+
+        # 2. Разбиваем на предложения с помощью nltk
+        try:
+            # Указываем язык для лучшей токенизации
+            sentences = nltk.sent_tokenize(full_text, language='russian')
+        except LookupError as e:
+            # Эта ошибка должна была быть поймана в __init__, но на всякий случай
+            logger.exception(f"Ошибка LookupError при токенизации (данные 'punkt' отсутствуют?): {e}")
+            raise  # Перевыбрасываем, т.к. это критично
+        except Exception as e:
+            logger.error(
+                f"Неожиданная ошибка при токенизации предложений в документе {doc_entity.name}: {e}",
+                exc_info=True
+            )
+            # В случае неожиданной ошибки возвращаем пустой список, чтобы не падать полностью
+            return []
+
+        # Этап 1: Создание первичных чанков (один на предложение)
+        initial_chunks: list[Chunk] = []
+        chunk_index = 0
+        current_search_offset = 0
+        for sentence_text in sentences:
+            sentence_text_stripped = sentence_text.strip()
+            if not sentence_text_stripped:
+                 # Обновляем current_search_offset даже для пустых
+                 if sentence_text in full_text[current_search_offset:]:
+                      current_search_offset += len(sentence_text)                
+                 continue
+            
+            # Находим позицию для следующего поиска (не используется напрямую, но нужно для offset)
+            sentence_start_pos = full_text.find(sentence_text_stripped, current_search_offset)
+            if sentence_start_pos != -1:
+                 current_search_offset = sentence_start_pos + len(sentence_text_stripped)
+            else: # На случай если find не сработал, просто двигаем offset
+                 current_search_offset += len(sentence_text_stripped)
+
+            chunk_instance = Chunk(
+                id=uuid4(),
+                name=f"{doc_entity.name}_sentence_{chunk_index}", # Временное имя
+                text=sentence_text_stripped,
+                in_search_text=sentence_text_stripped,
+                metadata={},
+                source_id=None,
+                target_id=doc_entity.id,
+                number_in_relation=chunk_index, # Временный индекс
+                groupper=self.DEFAULT_GROUPPER,
+            )
+            chunk_instance.owner_id = doc_entity.id
+            initial_chunks.append(chunk_instance)
+            chunk_index += 1
+            
+        if not initial_chunks:
+            return [] # Если предложений не нашлось
+
+        # Этап 2: Слияние коротких чанков
+        merged_chunks: list[Chunk] = []
+        i = 0
+        while i < len(initial_chunks):
+            current_chunk = initial_chunks[i]
+            word_count = len(current_chunk.text.split())
+
+            if word_count < MIN_WORDS_PER_CHUNK and i + 1 < len(initial_chunks):
+                # Короткий чанк и есть следующий: сливаем с СЛЕДУЮЩИМ
+                next_chunk = initial_chunks[i + 1]
+                merged_text = f"{current_chunk.text} {next_chunk.text}"
+                # Обновляем следующий чанк
+                next_chunk.text = merged_text
+                next_chunk.in_search_text = merged_text # Для базовой стратегии совпадает
+                # Пропускаем текущий (он слит в следующий)
+                i += 1 
+            elif word_count < MIN_WORDS_PER_CHUNK and i > 0 and not merged_chunks:
+                 # Короткий, ПОСЛЕДНИ�� чанк (merged_chunks пуст, значит предыдущие были длинные)
+                 # Сливаем с ПРЕДЫДУЩИМ в merged_chunks
+                 if merged_chunks: # Должен быть не пуст, но проверим
+                      prev_chunk = merged_chunks[-1]
+                      merged_text = f"{prev_chunk.text} {current_chunk.text}"
+                      prev_chunk.text = merged_text
+                      prev_chunk.in_search_text = merged_text
+                      i += 1 # Пропускаем текущий
+                 else: # Не должно произойти, но если первый чанк короткий
+                      merged_chunks.append(current_chunk)
+                      i += 1
+            elif word_count < MIN_WORDS_PER_CHUNK and i == 0 and len(initial_chunks) == 1:
+                 # Единственный чанк и он короткий - просто добавляем
+                 merged_chunks.append(current_chunk)
+                 i += 1
+            else:
+                # Достаточно длинный чанк или последний короткий (но не единственный)
+                merged_chunks.append(current_chunk)
+                i += 1
+                
+        if not merged_chunks: return [] # Если все слилось в никуда (маловероятно)
+
+        # Этап 3: Разделение длинных чанков
+        final_chunks: list[Chunk] = []
+        for chunk in merged_chunks:
+            words = chunk.text.split()
+            if len(words) > MAX_WORDS_PER_CHUNK:
+                sub_chunk_texts = []
+                for j in range(0, len(words), MAX_WORDS_PER_CHUNK):
+                    sub_chunk_words = words[j:j + MAX_WORDS_PER_CHUNK]
+                    sub_chunk_texts.append(" ".join(sub_chunk_words))
+                
+                # Создаем новые чанки для подстрок
+                for part_index, sub_text in enumerate(sub_chunk_texts):
+                    sub_chunk_instance = Chunk(
+                        id=uuid4(),
+                        # Имя отражает разделение, но индекс будет обновлен позже
+                        name=f"{chunk.name}_part_{part_index}", 
+                        text=sub_text,
+                        in_search_text=sub_text, # Базовая стратегия
+                        metadata=chunk.metadata.copy(),
+                        source_id=chunk.source_id,
+                        target_id=chunk.target_id,
+                        number_in_relation=-1, # Будет обновлен
+                        groupper=chunk.groupper,
+                    )
+                    sub_chunk_instance.owner_id = chunk.owner_id
+                    final_chunks.append(sub_chunk_instance)
+            else:
+                # Чанк не слишком длинный, добавляем как есть
+                final_chunks.append(chunk)
+
+        # Этап 4: Обновление нумерации и имен
+        for final_index, chunk in enumerate(final_chunks):
+            chunk.number_in_relation = final_index
+            # Обновляем имя, если оно было разделено
+            base_name = f"{doc_entity.name}_sentence_{final_index}"
+            if "_part_" in chunk.name:
+                chunk.name = base_name + chunk.name[chunk.name.rfind("_part_"):]
+            else:
+                 chunk.name = base_name
+                 
+        logger.info(
+            f"Документ {doc_entity.name} (Sentence) разбит на {len(final_chunks)} чанков (после слияния/разделения)."
+        )
+        return final_chunks
+
+    # Метод _build_sequenced_chunks не переопределяем,
+    # используется базовая реализация с соединением через пробел. 

lib/extractor/ntr_text_fragmentation/core/injection_builder.py

@@ -2,13 +2,15 @@
 Класс для сборки документа из деструктурированных сущностей (чанков, таблиц).
 """
 
+import asyncio
 import logging
 from uuid import UUID
 
 from ..additors import TablesProcessor
 from ..chunking import chunking_registry
 from ..models import DocumentAsEntity, LinkerEntity
-from ..repositories import EntityRepository, GroupedEntities, InMemoryEntityRepository
+from ..repositories import (EntityRepository, GroupedEntities,
+                            InMemoryEntityRepository)
 
 # Настраиваем базовый логгер
 logger = logging.getLogger(__name__)
@@ -125,9 +127,11 @@ class InjectionBuilder:
         }
 
         groups = sorted(
-            groups, key=lambda x: document_scores[x.composer.id], reverse=True
+            groups, key=lambda x: document_scores.get(x.composer.id, -1.0), reverse=True
         )
-        groups = list(groups)[:max_documents]
+
+        if max_documents is not None:
+            groups = groups[:max_documents]
 
         builded_documents = [
             self._build_document(group, include_tables, document_prefix).replace(
@@ -176,3 +180,158 @@ class InjectionBuilder:
             )
             for group in groups
         ]
+
+    async def build_async(
+        self,
+        entities: list[UUID] | list[LinkerEntity],
+        scores: dict[UUID, float] | None = None,
+        include_tables: bool = True,
+        neighbors_max_distance: int = 1,
+        max_documents: int | None = None,
+        document_prefix: str = "[Источник] - ",
+    ) -> str:
+        """
+        Асинхронно собирает текст документов на основе списка сущностей.
+
+        Args:
+            entities: Список ID сущностей (UUID) или самих сущностей.
+            scores: Словарь оценок {entity_id: score}.
+            include_tables: Включать ли таблицы.
+            neighbors_max_distance: Макс. расстояние для поиска соседей.
+            max_documents: Макс. кол-во документов для включения.
+            document_prefix: Префикс для заголовка документа.
+
+        Returns:
+            Собранный текст.
+        """
+        # Нормализуем до ID, если нужно
+        if entities and isinstance(entities[0], LinkerEntity):
+            entity_ids = [e.id for e in entities]
+        else:
+            entity_ids = entities
+
+        if not entity_ids:
+            logger.warning("Не переданы ID сущностей для асинхронной сборки.")
+            return ""
+
+        # Асинхронно получаем сущности по ID
+        base_entities = await self.repository.get_entities_by_ids_async(entity_ids)
+        if not base_entities:
+            logger.warning("Не удалось получить ни одной сущности по переданным ID (async).")
+            return ""
+
+        current_entities = [e.deserialize() for e in base_entities]
+
+        if neighbors_max_distance > 0:
+            neighbors = await self.repository.get_neighboring_entities_async(
+                current_entities, neighbors_max_distance
+            )
+            if neighbors:
+                current_entities.extend([e.deserialize() for e in neighbors])
+                logger.info(f"Добавлено {len(neighbors)} соседей (async). Общее число: {len(current_entities)}")
+
+        # Используем переданные scores или генерируем дефолтные
+        if scores is None:
+            logger.info("Оценки не предоставлены, используем порядковые номера в обратном порядке (async).")
+            id_to_score = {entity.id: float(i) for i, entity in enumerate(reversed(current_entities))}
+        else:
+            id_to_score = scores
+
+        # Асинхронно группируем сущности
+        groups: list[GroupedEntities[DocumentAsEntity]] = (
+            await self.repository.group_entities_hierarchically_async(
+                entities=current_entities, # Передаем сами сущности
+                root_type=DocumentAsEntity,
+                sort=True # Сортировка внутри группы
+            )
+        )
+
+        logger.info(f"Сгруппировано {len(groups)} документов (async).")
+
+        if not groups:
+            return ""
+
+        # Вычисляем скоры документов (синхронная операция)
+        document_scores = {
+            group.composer.id: max(
+                id_to_score.get(eid.id, -1.0) for eid in group.entities
+            )
+            for group in groups
+        }
+
+        # Сортируем группы по скору документа
+        groups = sorted(
+            groups, key=lambda x: document_scores.get(x.composer.id, -1.0), reverse=True
+        )
+
+        # Ограничиваем количество документов
+        if max_documents is not None:
+            groups = groups[:max_documents]
+
+        # Асинхронно собираем каждый документ
+        build_tasks = [
+            self._build_document_async(group, include_tables, document_prefix)
+            for group in groups
+        ]
+        builded_documents = await asyncio.gather(*build_tasks)
+        builded_documents = [doc.replace("\n", "\n\n") for doc in builded_documents if doc is not None]
+
+        return "\n\n".join(filter(None, builded_documents))
+
+    async def _build_document_async(
+        self,
+        group: GroupedEntities[DocumentAsEntity],
+        include_tables: bool,
+        document_prefix: str,
+    ) -> str | None:
+        """Асинхронно собирает текст одного документа."""
+        document = group.composer
+        entities = group.entities # Уже десериализованные
+
+        if not document or not entities:
+            return None
+
+        name = document.name
+        strategy = document.chunking_strategy_ref
+        builded_chunks = None
+        builded_tables = None
+
+        tasks_to_gather = []
+
+        # Задача для сборки чанков
+        if strategy:
+            try:
+                strategy_class = chunking_registry.get(strategy)
+                tasks_to_gather.append(strategy_class.dechunk_async(self.repository, entities))
+            except KeyError:
+                logger.warning(f"Стратегия чанкинга '{strategy}' не найдена для документа {name} (async)")
+                tasks_to_gather.append(asyncio.sleep(0, result=None)) # Заглушка None
+        else:
+            logger.warning(f"Стратегия чанкинга не указана для документа {name} (async)")
+            tasks_to_gather.append(asyncio.sleep(0, result=None)) # Заглушка None
+
+        if include_tables:
+            tasks_to_gather.append(self.tables_processor.build_async(self.repository, entities))
+        else:
+            tasks_to_gather.append(asyncio.sleep(0, result=None)) # Заглушка None
+
+        try:
+            results = await asyncio.gather(*tasks_to_gather)
+            builded_chunks = results[0]
+            builded_tables = results[1]
+        except Exception as e:
+            logger.error(f"Ошибка при параллельной сборке чанков/таблиц для документа {name}: {e}", exc_info=True)
+            return None
+
+        # Собираем финальный текст
+        result_parts = [f"## {document_prefix}{name}"]
+        if builded_chunks:
+            result_parts.append(f'### Текст\n{builded_chunks}')
+        if builded_tables:
+            result_parts.append(f'### Таблицы\n{builded_tables}')
+
+        # Если не собралось ни чанков, ни таблиц, не возвращаем ничего
+        if len(result_parts) <= 1:
+            return None
+
+        return "\n\n".join(result_parts)

lib/extractor/ntr_text_fragmentation/integrations/sqlalchemy/sqlalchemy_repository.py

@@ -1,6 +1,7 @@
 """
 Реализация EntityRepository для работы с SQLAlchemy.
 """
+import asyncio  # Добавляем импорт
 # Добавляем импорт logging и создаем логгер
 import logging
 from abc import ABC, abstractmethod
@@ -101,6 +102,11 @@ class SQLAlchemyEntityRepository(EntityRepository, ABC):
 
         return [self._map_db_entity_to_linker_entity(entity) for entity in db_entities]
 
+    async def get_entities_by_ids_async(self, entity_ids: Iterable[UUID]) -> List[LinkerEntity]:
+        """Асинхронно получить сущности по списку ID."""
+        # TODO: Реализовать с использованием async-сессии и await session.execute(...)
+        return await asyncio.to_thread(self.get_entities_by_ids, entity_ids)
+
     def group_entities_hierarchically(
         self,
         entities: Iterable[UUID] | Iterable[LinkerEntity],
@@ -235,6 +241,16 @@ class SQLAlchemyEntityRepository(EntityRepository, ABC):
             logger.info(f"[group_hierarchically] Сформировано {len(result)} объектов GroupedEntities.")
             return result
 
+    async def group_entities_hierarchically_async(
+        self,
+        entities: Iterable[UUID] | Iterable[LinkerEntity],
+        root_type: Type[LinkerEntity],
+        max_levels: int = 10,
+        sort: bool = True,
+    ) -> list[GroupedEntities[LinkerEntity]]:
+        """Асинхронно группирует сущности по иерархии."""
+        # TODO: Реализовать с использованием async-сессии для реальной асинхронности
+        return await asyncio.to_thread(self.group_entities_hierarchically, entities, root_type, max_levels, sort)
 
     def get_neighboring_entities(
         self,
@@ -342,6 +358,14 @@ class SQLAlchemyEntityRepository(EntityRepository, ABC):
 
         return [self._map_db_entity_to_linker_entity(ne) for ne in neighbor_entities_map.values()]
 
+    async def get_neighboring_entities_async(
+        self,
+        entities: Iterable[UUID] | Iterable[LinkerEntity],
+        max_distance: int = 1,
+    ) -> list[LinkerEntity]:
+        """Асинхронно получить соседние сущности."""
+        # TODO: Реализовать с использованием async-сессии для реальной асинхронности
+        return await asyncio.to_thread(self.get_neighboring_entities, entities, max_distance)
 
     def get_related_entities(
         self,
@@ -453,3 +477,15 @@ class SQLAlchemyEntityRepository(EntityRepository, ABC):
                 final_map[linker_entity.id] = linker_entity
 
         return list(final_map.values())
+
+    async def get_related_entities_async(
+        self,
+        entities: Iterable[UUID] | Iterable[LinkerEntity],
+        relation_type: Type[LinkerEntity] | None = None,
+        as_source: bool = False,
+        as_target: bool = False,
+        as_owner: bool = False,
+    ) -> list[LinkerEntity]:
+        """Асинхронно получить связанные сущности."""
+        # TODO: Реализовать с использованием async-сессии для реальной асинхронности
+        return await asyncio.to_thread(self.get_related_entities, entities, relation_type, as_source, as_target, as_owner)

lib/extractor/ntr_text_fragmentation/repositories/entity_repository.py

@@ -39,6 +39,13 @@ class EntityRepository(ABC):
         """
         pass
 
+    async def get_entities_by_ids_async(
+        self,
+        entity_ids: Iterable[UUID],
+    ) -> list[LinkerEntity]:
+        """Асинхронно получить сущности по списку идентификаторов."""
+        return self.get_entities_by_ids(entity_ids)
+
     @abstractmethod
     def group_entities_hierarchically(
         self,
@@ -62,6 +69,16 @@ class EntityRepository(ABC):
         """
         pass
 
+    async def group_entities_hierarchically_async(
+        self,
+        entities: Iterable[UUID] | Iterable[LinkerEntity],
+        root_type: Type[LinkerEntity],
+        max_levels: int = 10,
+        sort: bool = True,
+    ) -> list[GroupedEntities[LinkerEntity]]:
+        """Асинхронно группирует сущности по корневым элементам иерархии."""
+        return self.group_entities_hierarchically(entities, root_type, max_levels, sort)
+
     @abstractmethod
     def get_neighboring_entities(
         self,
@@ -81,6 +98,14 @@ class EntityRepository(ABC):
         """
         pass
 
+    async def get_neighboring_entities_async(
+        self,
+        entities: Iterable[UUID] | Iterable[LinkerEntity],
+        max_distance: int = 1,
+    ) -> list[LinkerEntity]:
+        """Асинхронно получить соседние сущности."""
+        return self.get_neighboring_entities(entities, max_distance)
+
     @abstractmethod
     def get_related_entities(
         self,
@@ -104,3 +129,14 @@ class EntityRepository(ABC):
             Список связанных сущностей и самих связей
         """
         pass
+
+    async def get_related_entities_async(
+        self,
+        entities: Iterable[UUID] | Iterable[LinkerEntity],
+        relation_type: Type[LinkerEntity] | None = None,
+        as_source: bool = False,
+        as_target: bool = False,
+        as_owner: bool = False,
+    ) -> list[LinkerEntity]:
+        """Асинхронно получить сущности, связанные с указанными."""
+        return self.get_related_entities(entities, relation_type, as_source, as_target, as_owner)

lib/extractor/ntr_text_fragmentation/repositories/in_memory_repository.py

@@ -183,8 +183,6 @@ class InMemoryEntityRepository(EntityRepository):
             if root_id:
                 entity_to_root[entity_id] = root_id
                 
-        logger.info(f"Найдены корневые элементы для {len(entity_to_root)} сущностей из общего количества {len(entity_ids)}.")
-
         # Группируем сущности по корневым элементам
         root_to_entities: dict[UUID, list[LinkerEntity]] = defaultdict(list)
 

lib/extractor/pyproject.toml

@@ -7,7 +7,8 @@ name = "ntr_text_fragmentation"
 version = "0.1.0"
 dependencies = [
     "uuid==1.30",
-    "ntr_fileparser==0.2.0"
+    "ntr_fileparser==0.2.0",
+    "nltk>=3.8"
 ]
 
 [project.optional-dependencies]

routes/dataset.py

@@ -129,7 +129,7 @@ async def make_active(dataset_id: int, dataset_service: Annotated[DatasetService
 ) -> DatasetExpanded:
     logger.info(f"Handling POST request to /datasets/{dataset_id}/activate")
     try:
-        result = dataset_service.activate_dataset(dataset_id, background_tasks)
+        result = await dataset_service.activate_dataset(dataset_id, background_tasks)
         logger.info(f"Successfully activated dataset {dataset_id}")
         return result
     except Exception as e:

routes/entity.py

@@ -91,7 +91,7 @@ async def search_entities_with_text(
     try:
         # Получаем результаты поиска
         _, scores, entity_ids = entity_service.search_similar_old(
-            request.query, request.dataset_id
+            request.query, request.dataset_id, 100
         )
 
         # Проверяем, что scores и entity_ids - корректные numpy массивы
@@ -108,8 +108,9 @@ async def search_entities_with_text(
             sorted_scores = [float(scores[i]) for i in sorted_indices]
             sorted_ids = [UUID(entity_ids[i]) for i in sorted_indices]
 
-            # Получаем тексты чанков
-            chunks = entity_service.chunk_repository.get_entities_by_ids(sorted_ids)
+            chunks = await entity_service.chunk_repository.get_entities_by_ids_async(
+                sorted_ids
+            )
 
             # Формируем ответ
             return EntitySearchWithTextResponse(
@@ -150,14 +151,18 @@ async def build_entity_text(
         Собранный текст
     """
     try:
+        if request.dataset_id is None:
+            raise HTTPException(status_code=400, detail="dataset_id is required")
+
         if not request.entities:
             raise HTTPException(
                 status_code=404, detail="No entities found with provided IDs"
             )
 
-        # Собираем текст
-        text = entity_service.build_text(
+        # Собираем текст асинхронно
+        text = await entity_service.build_text_async(
             entities=request.entities,
+            dataset_id=request.dataset_id,
             chunk_scores=request.chunk_scores,
             include_tables=request.include_tables,
             max_documents=request.max_documents,
@@ -190,14 +195,17 @@ async def get_entity_info(
     # Создаем репозиторий, передавая sessionmaker
     chunk_repository = ChunkRepository(db)
 
-    # Получаем общее количество сущностей
-    total_entities_count = chunk_repository.count_entities_by_dataset_id(dataset_id)
-
-    # Получаем сущности, готовые к поиску (с текстом и эмбеддингом)
-    searchable_entities, searchable_embeddings = (
-        chunk_repository.get_searching_entities(dataset_id)
+    # Получаем общее количество сущностей асинхронно
+    total_entities_count = await chunk_repository.count_entities_by_dataset_id_async(
+        dataset_id
     )
 
+    # Получаем сущности, готовые к поиску (с текстом и эмбеддингом) асинхронно
+    (
+        searchable_entities,
+        searchable_embeddings,
+    ) = await chunk_repository.get_searching_entities_async(dataset_id)
+
     # Проверка, найдены ли сущности, готовые к поиску
     # Можно оставить проверку, чтобы не возвращать пустые примеры, если таких нет,
     # но основная ошибка 404 должна базироваться на total_entities_count

routes/llm.py

@@ -1,7 +1,7 @@
 import json
 import logging
 import os
-from typing import Annotated, AsyncGenerator, List, Optional
+from typing import Annotated, AsyncGenerator, Optional
 
 from fastapi import APIRouter, Depends, HTTPException
 from fastapi.responses import StreamingResponse
@@ -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, QEResult
+from components.services.dialogue import DialogueService
 from components.services.entity import EntityService
 from components.services.llm_config import LLMConfigService
 from components.services.llm_prompt import LlmPromptService
@@ -70,16 +70,13 @@ def insert_search_results_to_message(
     return False
 
 def try_insert_search_results(
-    chat_request: ChatRequest, search_results: List[str], entities: List[List[str]]
+    chat_request: ChatRequest, search_results: str
 ) -> bool:
-    i = 0
     for msg in reversed(chat_request.history):
-        if msg.role == "user" and not msg.searchResults:
-            msg.searchResults = search_results[i]
-            msg.searchEntities = entities[i]
-            i += 1
-    if i == len(search_results):
-        return True
+        if msg.role == "user":
+            msg.searchResults = search_results
+            msg.searchEntities = []
+            return True
     return False
 
 def try_insert_reasoning(
@@ -93,31 +90,70 @@ def collapse_history_to_first_message(chat_request: ChatRequest) -> ChatRequest:
     """
     Сворачивает историю в первое сообщение и возвращает новый объект ChatRequest.
     Формат:
-    role: текст сообщения
-    <reasoning>[Источник] - текст</reasoning>
-    <search-results>[Источник] - текст</search-results>
-    
+        <history>
+            <user>
+                текст сообщения
+            </user>
+            <reasoning>
+                текст reasoning
+            </reasoning>
+            <search-results>
+                текст search-results
+            </search-results>
+            <assistant>
+                текст ответа
+            </assistant>
+        </history>
+        
+        <last-request>
+            <reasoning>
+                текст reasoning
+            </reasoning>
+            <search-results>
+                текст search-results
+            </search-results>
+            user:
+            текст последнего запроса
+        </last-request>
+        assistant:
     """
     if not chat_request.history:
         return ChatRequest(history=[])
+    
+    last_user_message = chat_request.history[-1]
+    if chat_request.history[-1].role != "user":
+        logger.warning("Last message is not user message")
+        
 
     # Собираем историю в одну строку
     collapsed_content = []
-    for msg in chat_request.history:
-        # Добавляем текст сообщения с указанием роли
+    collapsed_content.append("<history>\n")
+    for msg in chat_request.history[:-1]:
         if msg.content.strip():
-            collapsed_content.append(f"{msg.role.strip()}: {msg.content.strip()}")
-        # Добавляем reasoning, если есть
-        if msg.reasoning.strip():
-            collapsed_content.append(f"<reasoning>{msg.reasoning}</reasoning>")
-        # Добавляем search-results, если они есть
-        if msg.searchResults.strip():
-            collapsed_content.append(f"<search-results>{msg.searchResults}</search-results>")
+            tabulated_content = msg.content.strip().replace("\n", "\n\t\t")
+            collapsed_content.append(f"\t<{msg.role.strip()}>\n\t\t{tabulated_content}\n\t</{msg.role.strip()}>\n")
+            if msg.role == "user":
+                tabulated_reasoning = msg.reasoning.strip().replace("\n", "\n\t\t")
+                tabulated_search_results = msg.searchResults.strip().replace("\n", "\n\t\t")
+                collapsed_content.append(f"\t<reasoning>\n\t\t{tabulated_reasoning}\n\t</reasoning>\n")
+                collapsed_content.append(f"\t<search-results>\n\t\t{tabulated_search_results}\n\t</search-results>\n")
+                
+    collapsed_content.append("</history>\n")
+    
+    collapsed_content.append("<last-request>\n")
+    if last_user_message.content.strip():
+        tabulated_content = last_user_message.content.strip().replace("\n", "\n\t\t")
+        tabulated_reasoning = last_user_message.reasoning.strip().replace("\n", "\n\t\t")
+        tabulated_search_results = last_user_message.searchResults.strip().replace("\n", "\n\t\t")
+        collapsed_content.append(f"\t<reasoning>\n\t\t{tabulated_reasoning}\n\t</reasoning>\n")
+        collapsed_content.append(f"\t<search-results>\n\t\t{tabulated_search_results}\n\t</search-results>\n")
+        collapsed_content.append(f"\tuser: \n\t\t{tabulated_content}\n")
 
-    # Формируем финальный текст с переносами строк
-    new_content = "\n".join(collapsed_content)
+    collapsed_content.append("</last-request>\n")
+    
+    collapsed_content.append("assistant:\n")
+    new_content = "".join(collapsed_content)
 
-    # Создаем новое сообщение и новый объект ChatRequest
     new_message = Message(
         role='user',
         content=new_content,
@@ -134,6 +170,17 @@ async def sse_generator(request: ChatRequest, llm_api: DeepInfraApi, system_prom
     Генератор для стриминга ответа LLM через SSE.
     """
     try:
+        old_history = request.history
+        new_history = [Message(
+            role=msg.role,
+            content=msg.content,
+            reasoning=msg.reasoning,
+            searchResults='', #msg.searchResults[:10000] + "..." if msg.searchResults else '',
+            searchEntities=[],
+        ) for msg in old_history]
+        request.history = new_history
+        
+        
         qe_result = await dialogue_service.get_qe_result(request.history)
         try_insert_reasoning(request, qe_result.debug_message)
         
@@ -162,12 +209,12 @@ async def sse_generator(request: ChatRequest, llm_api: DeepInfraApi, system_prom
             dataset = dataset_service.get_current_dataset()
             if dataset is None:
                 raise HTTPException(status_code=400, detail="Dataset not found")
-            previous_entities = [msg.searchEntities for msg in request.history if msg.searchEntities is not None]
-            previous_entities, chunk_ids, scores = entity_service.search_similar(qe_result.search_query, 
-                                                                                 dataset.id, previous_entities)
-            text_chunks = entity_service.build_text(chunk_ids, scores)
-            all_text_chunks = [text_chunks] + [entity_service.build_text(entities) for entities in previous_entities]
-            all_entities = [chunk_ids] + previous_entities
+            _, chunk_ids, scores = entity_service.search_similar(
+                qe_result.search_query,
+                dataset.id,
+                [],
+            )
+            text_chunks = await entity_service.build_text_async(chunk_ids, dataset.id, scores)
             
             search_results_event = {
                 "event": "search_results",
@@ -180,7 +227,7 @@ async def sse_generator(request: ChatRequest, llm_api: DeepInfraApi, system_prom
 
             # new_message = f'<search-results>\n{text_chunks}\n</search-results>\n{last_query.content}'
             
-            try_insert_search_results(request, all_text_chunks, all_entities)
+            try_insert_search_results(request, text_chunks)
     except Exception as e:
         logger.error(f"Error in SSE chat stream while searching: {str(e)}", stack_info=True)
         yield "data: {\"event\": \"error\", \"data\":\""+str(e)+"\" }\n\n"
@@ -294,7 +341,7 @@ async def chat(
             logger.info(f"chunk_ids: {chunk_ids[:3]}...{chunk_ids[-3:]}")
             logger.info(f"scores: {scores[:3]}...{scores[-3:]}")
             
-            text_chunks = entity_service.build_text(chunks, scores)
+            text_chunks = await entity_service.build_text_async(chunk_ids, dataset.id, scores)
             
             logger.info(f"text_chunks: {text_chunks[:3]}...{text_chunks[-3:]}")