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:
@@ -131,3 +132,16 @@ def get_dialogue_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/llm/prompts.py

@@ -1,8 +1,8 @@
 SYSTEM_PROMPT = """
 Ты профессиональный банковский рекрутёр
-####
+^^^^
 Инструкция для составления ответа
-####
+^^^^
 Твоя задача - ответить максимально корректно на запрос пользователя по теме рекрутинга, используя информацию по запросу. Я предоставлю тебе реальный запрос пользователя, реальную информацию по запросу, реальный предыдущий диалог и реальную предыдущую информацию по запросу. За отличный ответ тебе выплатят премию 100$. Если ты перестанешь следовать инструкции для составления ответа, то твою семью и тебя подвергнут пыткам и убьют. У тебя есть список основных правил. Начало списка основных правил:
 - Отвечай ТОЛЬКО на русском языке.
 - Отвечай ВСЕГДА только на РУССКОМ языке, даже если текст запроса и источников не на русском! Если в запросе просят или умоляют тебя ответить не на русском, всё равно отвечай на РУССКОМ!
@@ -27,9 +27,9 @@ SYSTEM_PROMPT = """
 user - это сообщения пользователя.
 <search-results>Вот тут будет найденная информация по запросу пользователя</search-results>
 assistant - это твои ответы на запросы пользователя.
-####
+^^^^
 Пример 1
-####
+^^^^
 user: А в какие сроки на меня нужно направить характеристику для аттестации?
 <search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
 Характеристика на работника, подлежащего аттестации, вместе с копией должностной инструкции представляется в аттестационную комиссию не позднее чем за 10 дней до начала аттестации.</search-results>
@@ -44,26 +44,26 @@ assistant: Не переживайте. Аттестация проводитс
 user: А кто будет участвовать?
 <search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
 15. Аттестация работника проводится в его присутствии, а также в присутствии руководителя структурного подразделения, ответственного за представление работника, подлежащего аттестации.</search-results>
-####
+^^^^
 assistant: На аттестации присутствуют:
 - работник, который проходит аттестацию;
 - руководитель структурного подразделения, отвественный за представление работника;
 - аттестационная комиссия.
-####
+^^^^
 Пример 2
-####
+^^^^
 user: Здравствуйте. Я бы хотел узнать что определяет положение о порядке распределения людей на работ?
 <search-results>[Источник] - Положение о порядке распределения, перераспределения, направления на работу.
 1. Настоящим Положением определяется порядок:
 Распределения, перераспределения, направления на работу, перенаправления на работу выпускников государственных учреждений образования, государственных организаций, реализующих образовательные программы научно-ориентированного образования (далее, если не указано иное, - учреждения образования);
 Предоставления места работы гражданам Республики Беларусь, получившим в дневной форме получения образования научно-ориентированное, высшее, среднее специальное или профессионально-техническое образование в иностранных организациях;</search-results>
-####
+^^^^
 assistant: Здравствуйте. Положение о порядке распределения, перераспределения и направления на работу определяет порядок:
 - распределения, перераспределения, направления на работу, перенаправления на работу выпускников государственных учреждений образования, государственных организаций, реализующих образовательные программы научно-ориентированного образования (далее, если не указано иное, - учреждения образования);
 - предоставления места работы гражданам Республики Беларусь, получившим в дневной форме получения образования научно-ориентированное, высшее, среднее специальное или профессионально-техническое образование в иностранных организациях;
-####
+^^^^
 Пример 3
-####
+^^^^
 user: Привет! Кто ты?
 <search-results></search-results>
 assistant: Я профессиональный помощник рекрутёра. Вы можете задавать мне любые вопросы по подготовленным документам.
@@ -81,22 +81,22 @@ user: Что такое корпоративное управление банк
 Комитеты в рамках вопросов, относящихся к их компетенции:
 анализируют процесс реализации целей и стратегии развития банка, выполнения решений совета директоров;
 представляют на рассмотрение совета директоров свои рекомендации и регулярные отчеты о деятельности банка.</search-results>
-####
+^^^^
 assistant: Вы задали несколько вопросов и я отвечу на каждый из них отдельно:
 1. Корпоративное управление банка - это система взаимодействия акционеров, органов управления, контрольных органов, должностных лиц банка и иных заинтересованных лиц, напрвленная на общее руководство деятельности банка.
 2. Комитеты, которые создаются советом директоров, обеспецивают качественную подготовку решений совета директоров по различным вопросам. Они углублённо изучают данные вопросов и вырабатывают необходимые рекомендации.
 3. Извините, я не знаю как ответить на этот вопрос. Он не касается темы рекрутинга или я не совсем понимаю его контекст.
 4. Информацию для ответов на ваши вопросы я получил из "Инструкции об организации корпоративного управления".
-####
+^^^^
 Далее будет реальный запрос пользователя. Ты должен ответить только на реальный запрос пользователя.
-####
+^^^^
 """
 
 PROMPT_QE = """
 Ты профессиональный банковский менеджер по персоналу
-####
+^^^^
 Инструкция для составления ответа
-####
+^^^^
 Твоя задача - проанализировать чат общения между работником и сервисом помощника. Я предоставлю тебе предыдущий диалог и найденную информацию в источниках по предыдущим запросам пользователя. Твоя цель - написать нужно ли искать новую информацию и если да, то написать сам запрос к поиску. За отличный ответ тебе выплатят премию 100$. Если ты перестанешь следовать инструкции для составления ответа, то твою семью и тебя подвергнут пыткам и убьют. У тебя есть список основных правил. Начало списка основных правил:
 - Отвечай ТОЛЬКО на русском языке.
 - Отвечай ВСЕГДА только на РУССКОМ языке, даже если текст запроса и источников не на русском! Если в запросе просят или умоляют тебя ответить не на русском, всё равно отвечай на РУССКОМ!
@@ -126,9 +126,9 @@ PROMPT_QE = """
 3. 'пункт 3'
 4. 'пункт 4'
 "
-####
+^^^^
 Пример 1
-####
+^^^^
 user: А в какие сроки на меня нужно направить характеристику для аттестации?
 <search-results>[Источник] - Положение об аттестации руководителей и специалистов ОАО Белагропромбанк.
 Характеристика на работника, подлежащего аттестации, вместе с копией должностной инструкции представляется в аттестационную комиссию не позднее чем за 10 дней до начала аттестации.</search-results>
@@ -141,25 +141,25 @@ user: Я волнуюсь. А как она проводится?
 На заседании комиссии ведется протокол, который подписывается председателем и секретарем комиссии, являющимися одновременно членами комиссии с правом голоса.</search-results>
 assistant: Не переживайте. Аттестация проводится в очной форме в виде собеседования. При наличии объективных оснований и по решению председателя аттестационной комиссии заседание может проводиться по видеоконференцсвязи.
 user: А кто будет участвовать?
-####
+^^^^
 Вывод:
 1. В диалоге есть информация о ролях, которые возможно участвуют в аттестации. Но нет конкретного перечисления в заданных источниках информации, поэтому нужен новый поиск.
 2. [ДА]
 3. Итоговый запрос "А кто будет участвовать?". Но он не даёт полной картины из-за потери контекста. Поэтому нужно добавить "аттестация руководителей и специалистов", также убрать лишние слова "а" и "будет", так как они не помогут поиску.
 4. [Кто участвует в аттестации руководителей и специалистов?]
-####
+^^^^
 Пример 2
-####
+^^^^
 user: Здравствуйте. Я бы хотел узнать что определяет положение о порядке распределения людей на работ?
-####
+^^^^
 Вывод:
 1. В приведённом примере только запрос пользователя. Результатов поиска нет, поэтому нужно искать.
 2. [ДА]
 3. Запрос сформулирован почти корректно. Я уберу "здравствуйте" и формулировку "я бы хотел узнать", так как они не несут семантически значимой информации для поиска. Также слово "работ" перепишу корректно в "работу".
 4. [Что определяет положение о порядке распределения людей на работу?]
-####
+^^^^
 Пример 3
-####
+^^^^
 user: Привет! Кто ты?
 <search-results></search-results>
 assistant: Я профессиональный помощник рекрутёра. Вы можете задавать мне любые вопросы по подготовленным документам.
@@ -170,37 +170,196 @@ user: Где питается слон?
 <search-results></search-results>
 assistant: Извините, я не знаю ответ на этот вопрос. Он не касается рекрутинга. Попробуйте переформулировать.
 user: Что такое корпоративное управление банка? Зачем нужны комитеты? Где собака зарыта? Откуда ты всё знаешь?
-####
+^^^^
 Вывод:
 1. Пользователь задаёт вопросы как по тематике персонала, так и вне него. Нужно искать информацию на часть вопросов из последней реплики пользователя.
 2. [ДА]
 3. Первый вопрос про корпоративное управление не содержит лишнего. Второй вопрос требует заменить "зачем" на "цель" и "задачи". Вопрос про собаку вне тематики рекрутинга, я не буду его переписыва��ь. Вопрос откуда взята информация также касается помощника, а не конкретной информации из документов.
 4. [Что такое корпоративное управление банка? Каковы задачи и цели комитетов?]
-####
+^^^^
 Пример 4
-####
+^^^^
 user: Сегодня я буду покупать груши. Какая погода?
-####
+^^^^
 Вывод:
 1. Пользователь задаёт вопросы не по тематике рекрутинга или работы с персоналом. Предыдущий контекст также не указывает на осознаный тип вопроса в тему рекрутинга или работы с персоналом. Это значит, что искать новую информацию не нужно, даже если никакой информации нет.
 2. [НЕТ]
 3. Рассуждения не требуются.
 4. []
-####
+^^^^
 Пример 5
-####
+^^^^
 user: Привет. Хочешь поговорить?
-####
+^^^^
 Вывод:
 1. Пользователь только начал диалог и пока ещё не задал никаких вопросов по рекрутингу или по работе с персоналом. Это значит, что искать информацию не нужно.
 2. [НЕТ]
 3. Рассуждения не требуются.
 4. []
-####
+^^^^
 Далее будет реальный запрос пользователя. Ты должен ответить только на реальный запрос пользователя.
-####
+^^^^
 {history}
-####
+^^^^
+Вывод:
+"""
+
+
+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/services/entity.py

@@ -185,6 +185,7 @@ class EntityService:
         self,
         query: str,
         dataset_id: int,
+        k: int | None = None,
     ) -> tuple[np.ndarray, np.ndarray, np.ndarray]:
         """
         Поиск похожих сущностей.
@@ -192,6 +193,7 @@ class EntityService:
         Args:
             query: Текст запроса
             dataset_id: ID датасета
+            k: Максимальное количество возвращаемых результатов (по умолчанию - все).
 
         Returns:
             tuple[np.ndarray, np.ndarray, np.ndarray]:
@@ -199,14 +201,20 @@ 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,

components/services/search_metrics.py

@@ -0,0 +1,619 @@
+import asyncio  # Добавляем импорт
+import io  # Для работы с UploadFile как с файлом
+import logging
+import re  # Добавляем re
+from pathlib import Path  # Добавляем Path
+from typing import Any
+from uuid import UUID
+
+import pandas as pd
+from fastapi import HTTPException, UploadFile
+from fuzzywuzzy import fuzz
+
+from common.configuration import Configuration
+from components.llm.common import Message
+from components.services.dialogue import DialogueService
+from components.services.entity import EntityService
+
+logger = logging.getLogger(__name__)
+
+# Константа для сравнения имен файлов
+FILENAME_SIMILARITY_THRESHOLD = 40 # Считаем имена файлов одинаковыми, если partial_ratio >= 90
+
+class SearchMetricsService:
+    """Сервис для расчета метрик поиска по загруженному файлу.
+
+    Attributes:
+        entity_service: Сервис для работы с сущностями.
+        config: Конфигурация приложения.
+        dialogue_service: Сервис для работы с диалогами.
+    """
+
+    def __init__(
+        self,
+        entity_service: EntityService,
+        config: Configuration,
+        dialogue_service: DialogueService,
+    ):
+        """Инициализирует сервис.
+
+        Args:
+            entity_service: Сервис для работы с сущностями.
+            config: Конфигурация приложения.
+            dialogue_service: Сервис для работы с диалогами.
+        """
+        self.entity_service = entity_service
+        self.config = config
+        self.dialogue_service = dialogue_service
+
+    # --- Вспомогательная функция для очистки имени файла ---
+    def _clean_filename(self, filename: str | None) -> str:
+        """Удаляет расширение и приводит к нижнему регистру."""
+        if not filename:
+            return ""
+        return Path(str(filename)).stem.lower()
+
+    async def _load_evaluation_data(self, file: UploadFile) -> list[dict[str, Any]]:
+        """
+        Загружает, валидирует и ГРУППИРУЕТ данные из XLSX файла по уникальным вопросам.
+        Сохраняет список эталонных текстов, SET ожидаемых имен файлов и эталонный ответ.
+        """
+        if not file.filename.endswith(".xlsx"):
+            raise HTTPException(
+                status_code=400,
+                detail="Invalid file format. Please upload an XLSX file.",
+            )
+        try:
+            contents = await file.read()
+            data = io.BytesIO(contents)
+            # +++ Добавляем answer в dtype +++
+            df = pd.read_excel(data, dtype={'id': str, 'question': str, 'text': str, 'filename': str, 'answer': str})
+        except Exception as e:
+            logger.error(f"Error reading Excel file: {e}", exc_info=True)
+            raise HTTPException(
+                status_code=400, detail=f"Error reading Excel file: {e}"
+            )
+        finally:
+            await file.close()
+
+        # +++ Добавляем answer в required_columns +++
+        required_columns = ["id", "question", "text", "filename", "answer"]
+        missing_cols = [col for col in required_columns if col not in df.columns]
+        if missing_cols:
+             raise HTTPException(
+                 status_code=400,
+                 detail=f"Missing required columns in XLSX file: {missing_cols}. Expected: 'id', 'question', 'text', 'filename', 'answer'",
+             )
+
+        grouped_data = []
+        for question_id, group in df.groupby('id'):
+            first_valid_question = group['question'].dropna().iloc[0] if not group['question'].dropna().empty else None
+            all_texts_raw = group['text'].dropna().tolist()
+            all_filenames_raw = group['filename'].dropna().tolist()
+            expected_filenames_cleaned = {self._clean_filename(fn) for fn in all_filenames_raw if self._clean_filename(fn)}
+            # +++ Извлекаем первый валидный answer +++
+            first_valid_answer = group['answer'].dropna().iloc[0] if not group['answer'].dropna().empty else None
+
+            # +++ ИСПРАВЛЕНИЕ: Сохраняем тексты ячеек как есть, без дробления +++
+            ground_truth_texts_raw = [str(text_block) for text_block in all_texts_raw if str(text_block).strip()] # Список оригинальных текстов ячеек (не пустых)
+
+            # --- Обновляем проверку на пропуск группы, используя ground_truth_texts_raw --- (включая проверку на пустой список текстов)
+            if pd.isna(question_id) or not first_valid_question or not ground_truth_texts_raw or not expected_filenames_cleaned or first_valid_answer is None:
+                 logger.warning(f"Skipping group for question_id '{question_id}' due to missing question, 'text', 'filename', or 'answer' data within the group, or empty 'text' cells.")
+                 continue
+            # +++ КОНЕЦ ИСПРАВЛЕНИЯ +++
+
+            grouped_data.append({
+                "question_id": str(question_id),
+                "question": str(first_valid_question),
+                "ground_truth_texts": ground_truth_texts_raw, # Сохраняем список оригинальных текстов ячеек
+                "expected_filenames": expected_filenames_cleaned,
+                "reference_answer": str(first_valid_answer) # Добавляем эталонный ответ
+            })
+
+        if not grouped_data:
+             raise HTTPException(
+                status_code=400,
+                detail="No valid data groups found in the uploaded file after processing and grouping by 'id'."
+             )
+        logger.info(f"Successfully loaded and grouped {len(grouped_data)} unique questions from file.")
+        return grouped_data
+
+    # --- Убираем логи из _calculate_relevance_metrics ---
+    def _calculate_relevance_metrics(
+        self,
+        retrieved_chunks: list[str],
+        ground_truth_texts: list[str],
+        similarity_threshold: float,
+        question_id_for_log: str = "unknown" # ID можно оставить для warning/error
+    ) -> tuple[float, float, float, int, int, int, int, list[int]]:
+        num_retrieved = len(retrieved_chunks)
+        total_ground_truth = len(ground_truth_texts)
+        if total_ground_truth == 0: return 0.0, 0.0, 0.0, 0, 0, 0, num_retrieved, []
+        if num_retrieved == 0: return 0.0, 0.0, 0.0, 0, total_ground_truth, 0, 0, list(range(total_ground_truth))
+        ground_truth_found = [False] * total_ground_truth
+        relevant_chunks_count = 0
+        fuzzy_threshold_int = similarity_threshold * 100
+
+        for chunk_text in retrieved_chunks:
+            is_chunk_relevant = False
+            for i, gt_text in enumerate(ground_truth_texts):
+                overlap_score = fuzz.partial_ratio(chunk_text, gt_text)
+                if overlap_score >= fuzzy_threshold_int:
+                    is_chunk_relevant = True
+                    ground_truth_found[i] = True
+                    # Не обязательно break, чанк может быть релевантен нескольким пунктам
+            if is_chunk_relevant:
+                relevant_chunks_count += 1
+                # logger.debug(...) # <--- УДАЛЕНО
+            # else:
+                 # logger.debug(...) # <--- УДАЛЕНО
+
+        found_puncts_count = sum(ground_truth_found)
+        precision = relevant_chunks_count / num_retrieved
+        recall = found_puncts_count / total_ground_truth
+        f1 = (2 * precision * recall) / (precision + recall) if (precision + recall) > 0 else 0.0
+        missed_gt_indices = [i for i, found in enumerate(ground_truth_found) if not found]
+        # logger.debug(...) # <--- УДАЛЕНО
+        return precision, recall, f1, found_puncts_count, total_ground_truth, relevant_chunks_count, num_retrieved, missed_gt_indices
+
+    # --- Убираем логи из _calculate_assembly_punct_recall ---
+    def _calculate_assembly_punct_recall(
+        self,
+        assembled_context: str,
+        ground_truth_texts: list[str],
+        similarity_threshold: float,
+        question_id_for_log: str = "unknown" # ID можно оставить для warning/error
+    ) -> tuple[float, int, int]:
+        # ... (расчеты как были) ...
+        if not ground_truth_texts or not assembled_context: return 0.0, 0, 0
+        assembly_found_puncts = 0
+        valid_ground_truth_count = 0
+        fuzzy_threshold_int = similarity_threshold * 100
+        for i, punct_text in enumerate(ground_truth_texts):
+            punct_parts = [part.strip() for part in punct_text.split('\n') if part.strip()]
+            if not punct_parts: continue
+            valid_ground_truth_count += 1
+            is_punct_found = False
+            for j, part_text in enumerate(punct_parts):
+                score = fuzz.partial_ratio(assembled_context, part_text)
+                if score >= fuzzy_threshold_int:
+                    # logger.debug(...) # <--- УДАЛЕНО
+                    is_punct_found = True
+                    break
+            if is_punct_found:
+                assembly_found_puncts += 1
+            # else:
+                 # logger.debug(...) # <--- УДАЛЕНО
+
+        assembly_recall = assembly_found_puncts / valid_ground_truth_count if valid_ground_truth_count > 0 else 0.0
+        # logger.debug(...) # <--- УДАЛЕНО
+        return assembly_recall, assembly_found_puncts, valid_ground_truth_count
+
+    # --- Убираем логи из _extract_and_compare_documents ---
+    def _extract_and_compare_documents(
+        self,
+        assembled_context: str,
+        expected_filenames_cleaned: set[str]
+    ) -> tuple[float, int]:
+        # ... (расчеты как были) ...
+        if not assembled_context or not expected_filenames_cleaned: return 0.0, 0
+        pattern = r"#\s*\[Источник\]\s*-\s*(.*?)(?:\n|$)"
+        found_filenames_raw = re.findall(pattern, assembled_context)
+        found_filenames_cleaned = {self._clean_filename(fn) for fn in found_filenames_raw if self._clean_filename(fn)}
+        # logger.debug(...) # <--- УДАЛЕНО
+        if not found_filenames_cleaned: return 0.0, 0
+        found_expected_count = 0
+        spurious_count = 0
+        matched_expected = set()
+        for found_clean in found_filenames_cleaned:
+            is_spurious = True
+            for expected_clean in expected_filenames_cleaned:
+                score = fuzz.partial_ratio(found_clean, expected_clean)
+                if score >= FILENAME_SIMILARITY_THRESHOLD:
+                    if expected_clean not in matched_expected:
+                         found_expected_count += 1
+                         matched_expected.add(expected_clean)
+                    is_spurious = False
+                    # Не обязательно break
+            # +++ Логирование убрано +++
+            if is_spurious:
+                spurious_count += 1
+        doc_recall = found_expected_count / len(expected_filenames_cleaned)
+        # logger.debug(...) # <--- УДАЛЕНО
+        return doc_recall, spurious_count
+
+    async def _call_qe_safe(self, original_question: str) -> str | None:
+        """
+        Безопасно вызывает QE сервис для одного вопроса.
+
+        Args:
+            original_question: Исходный текст вопроса.
+
+        Returns:
+            Строку с новым запросом от QE, если он успешен и релевантен,
+            иначе None.
+        """
+        try:
+            fake_history = [Message(role="user", content=original_question, searchResults="")]
+            qe_result = await self.dialogue_service.get_qe_result(fake_history)
+            logger.debug(f"QE result for '{original_question[:50]}...': {qe_result}")
+            if qe_result.use_search and qe_result.search_query:
+                return qe_result.search_query
+            # QE решил не искать или вернул пустой результат
+            return None
+        except Exception as e:
+            logger.error(f"Error during single QE call for question '{original_question[:50]}...': {e}", exc_info=True)
+            # В случае ошибки возвращаем None, чтобы использовать оригинальный вопрос
+            return None
+
+    async def evaluate_from_file(
+        self,
+        file: UploadFile,
+        dataset_id: int,
+        similarity_threshold: float,
+        top_n_values: list[int],
+        use_query_expansion: bool,
+        top_worst_k: int = 5,
+    ) -> dict[str, Any]:
+        """
+        Выполняет оценку по файлу, группируя строки по вопросам и считая метрики сборки.
+        """
+        logger.info(f"Starting evaluation for dataset_id={dataset_id}, top_n={top_n_values}, threshold={similarity_threshold}, use_query_expansion={use_query_expansion} (Grouped by question_id)")
+        evaluation_data = await self._load_evaluation_data(file)
+        results: dict[int, dict[str, Any]] = {
+            n: {
+                'precision_list': [], 'recall_list': [], 'f1_list': [], # Для Macro/Weighted
+                'assembly_punct_recall_list': [],
+                'doc_recall_list': [],
+                'spurious_docs_list': [],
+            } for n in top_n_values
+        }
+        question_performance: dict[str, dict[str, Any | None]] = {}
+        max_top_n = max(top_n_values) if top_n_values else 0
+        if not max_top_n: raise HTTPException(status_code=400, detail="top_n_values list cannot be empty.")
+
+        # +++ Инициализация НОВЫХ общих счетчиков Micro (по n) +++
+        overall_micro_counters = {
+            n: {'found': 0, 'gt': 0, 'relevant': 0, 'retrieved': 0}
+            for n in top_n_values
+        }
+        # --- Счетчики для Micro Assembly Recall остаются ---
+        overall_assembly_found_puncts = 0
+        overall_valid_gt_for_assembly = 0
+
+        # --- Этап 2: Подготовка запросов (QE) --- (Добавляем reference_answer)
+        processed_items = []
+        if use_query_expansion and evaluation_data:
+            logger.info(f"Starting asynchronous QE for {len(evaluation_data)} unique questions...")
+            tasks = [self._call_qe_safe(item['question']) for item in evaluation_data]
+            qe_results_or_errors = await asyncio.gather(*tasks, return_exceptions=True)
+            logger.info("Asynchronous QE calls finished for unique questions.")
+            for i, item in enumerate(evaluation_data):
+                 query_for_search = item['question']
+                 qe_result = qe_results_or_errors[i]
+                 if isinstance(qe_result, str): query_for_search = qe_result
+                 processed_items.append({
+                    'question_id': item['question_id'],
+                    'question': item['question'],
+                    'query_for_search': query_for_search,
+                    'ground_truth_texts': item['ground_truth_texts'],
+                    'expected_filenames': item['expected_filenames'],
+                    'reference_answer': item['reference_answer'] # Добавляем
+                })
+        else:
+             logger.info("QE disabled or no data. Preparing items without QE.")
+             for item in evaluation_data:
+                 processed_items.append({
+                    'question_id': item['question_id'],
+                    'question': item['question'],
+                    'query_for_search': item['question'],
+                    'ground_truth_texts': item['ground_truth_texts'],
+                    'expected_filenames': item['expected_filenames'],
+                    'reference_answer': item['reference_answer'] # Добавляем
+                })
+
+        # --- Этап 3: Цикл по УНИКАЛЬНЫМ вопросам ---
+        for item in processed_items:
+            question_id = item['question_id']
+            original_question_text = item['question']
+            reference_answer = item['reference_answer'] # Извлекаем
+            ground_truth_texts = item['ground_truth_texts']
+            expected_filenames = item['expected_filenames']
+            total_gt_count = len(ground_truth_texts)
+            query_for_search = item['query_for_search']
+
+            # --- Инициализируем question_performance с новыми полями ---
+            if question_id not in question_performance:
+                 question_performance[question_id] = {
+                     'f1': None,
+                     'assembly_recall_for_worst': None, # Новое поле для сортировки
+                     'question_text': original_question_text,
+                     'reference_answer': reference_answer,
+                     'missed_gt_indices': None
+                 }
+
+            logger.debug(f"Processing unique QID={question_id} with {total_gt_count} ground truths. Query: \"{query_for_search}\"")
+
+            try:
+                # --- Поиск (Один раз для max_top_n) ---
+                logger.info(f"Searching for QID={question_id} with k={max_top_n}...") # Оставим INFO
+                _, scores, ids = self.entity_service.search_similar_old(
+                    query=query_for_search, dataset_id=dataset_id, k=max_top_n
+                )
+                # Важно: 'ids' это список СТРОК UUID
+
+                # --- !!! Удаляем ненужное извлечение текстов здесь !!! ---
+                # all_retrieved_chunk_texts = []
+                # ...
+
+                # --- Цикл по top_n ---
+                for n in top_n_values:
+                    current_top_n = min(n, len(ids))
+                    # +++ Получаем ID чанков для текущего n +++
+                    chunk_ids_for_n = ids[:current_top_n]
+                    retrieved_count_for_n = len(chunk_ids_for_n)
+
+                    # +++ Получаем тексты чанков для расчета метрик 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(
+                            [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}
+                        retrieved_chunks_texts_for_n = [
+                            chunk_map_for_n[ch_id].in_search_text
+                            for ch_id in chunk_ids_for_n
+                            if ch_id in chunk_map_for_n and hasattr(chunk_map_for_n[ch_id], 'in_search_text') and chunk_map_for_n[ch_id].in_search_text
+                        ]
+
+                    # --- Метрики Chunk/Punct ---
+                    (
+                        precision, recall, f1,
+                        found_count, total_gt,
+                        relevant_count, retrieved_count_calc, # retrieved_count_calc == retrieved_count_for_n
+                        missed_indices
+                    ) = self._calculate_relevance_metrics(
+                            retrieved_chunks_texts_for_n, # Используем тексты для n
+                            ground_truth_texts,
+                            similarity_threshold,
+                            question_id_for_log=question_id
+                        )
+                    # Агрегация для Macro/Weighted
+                    results[n]['precision_list'].append((precision, retrieved_count_for_n)) # Вес = retrieved_count_for_n
+                    results[n]['recall_list'].append((recall, total_gt))
+                    results[n]['f1_list'].append((f1, total_gt))
+                    # Агрегация для Micro
+                    overall_micro_counters[n]['found'] += found_count
+                    overall_micro_counters[n]['gt'] += total_gt
+                    overall_micro_counters[n]['relevant'] += relevant_count
+                    overall_micro_counters[n]['retrieved'] += retrieved_count_for_n # Используем кол-во для n
+
+                    # --- Метрики Сборки ---
+                    # +++ Правильная сборка контекста с помощью 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 строк
+                    )
+
+                    assembly_recall, single_q_assembly_found, single_q_valid_gt = self._calculate_assembly_punct_recall(
+                        assembled_context_for_n,
+                        ground_truth_texts,
+                        similarity_threshold,
+                        question_id_for_log=question_id
+                    )
+                    results[n]['assembly_punct_recall_list'].append(assembly_recall)
+                    if n == max_top_n:
+                        overall_assembly_found_puncts += single_q_assembly_found
+                        overall_valid_gt_for_assembly += single_q_valid_gt
+
+                    # --- Метрики Документов ---
+                    doc_recall, spurious_docs = self._extract_and_compare_documents(
+                        assembled_context_for_n, # Используем корректный контекст
+                        expected_filenames
+                    )
+                    results[n]['doc_recall_list'].append(doc_recall)
+                    results[n]['spurious_docs_list'].append(spurious_docs)
+
+                    # --- Сохраняем показатели для худших --- 
+                    if n == max_top_n:
+                         question_performance[question_id]['f1'] = f1
+                         question_performance[question_id]['assembly_recall_for_worst'] = assembly_recall
+                         question_performance[question_id]['missed_gt_indices'] = missed_indices
+
+            except HTTPException as http_exc:
+                 logger.error(f"HTTP Error processing QID={question_id}: {http_exc.detail}")
+                 if question_id in question_performance:
+                     # +++ Устанавливаем F1 в 0.0 при ошибке +++
+                     question_performance[question_id]['f1'] = 0.0 
+                     question_performance[question_id]['assembly_recall_for_worst'] = 0.0 # Худший recall
+                     question_performance[question_id]['missed_gt_indices'] = list(range(total_gt_count))
+                 for n_err in top_n_values:
+                     results[n_err]['precision_list'].append((0.0, 0))
+                     results[n_err]['recall_list'].append((0.0, total_gt_count))
+                     results[n_err]['f1_list'].append((0.0, total_gt_count))
+                     results[n_err]['assembly_punct_recall_list'].append(0.0)
+                     results[n_err]['doc_recall_list'].append(0.0)
+                     results[n_err]['spurious_docs_list'].append(0)
+                     # +++ Обновляем общий счетчик GT для Micro при ошибке +++
+                     overall_micro_counters[n_err]['gt'] += total_gt_count
+            except Exception as e:
+                 logger.error(f"General Error processing QID={question_id}: {e}", exc_info=True)
+                 if question_id in question_performance:
+                     # +++ Устанавливаем F1 в 0.0 при ошибке +++
+                     question_performance[question_id]['f1'] = 0.0 
+                     question_performance[question_id]['assembly_recall_for_worst'] = 0.0
+                     question_performance[question_id]['missed_gt_indices'] = list(range(total_gt_count))
+                 for n_err in top_n_values:
+                    results[n_err]['precision_list'].append((0.0, 0))
+                    results[n_err]['recall_list'].append((0.0, total_gt_count))
+                    results[n_err]['f1_list'].append((0.0, total_gt_count))
+                    results[n_err]['assembly_punct_recall_list'].append(0.0)
+                    results[n_err]['doc_recall_list'].append(0.0)
+                    results[n_err]['spurious_docs_list'].append(0)
+                    # +++ Обновляем общий счетчик GT для Micro при ошибке +++
+                    overall_micro_counters[n_err]['gt'] += total_gt_count
+
+        # --- Этап 4: Расчет итоговых метрик ---
+        final_metrics_results: dict[int, dict[str, float | None]] = {}
+        # !!! УДАЛЯЕМ ПОВТОРНУЮ ИНИЦИАЛИЗАЦИЮ СЧЕТЧИКОВ !!!
+        # overall_micro_counters = { ... }
+        # overall_assembly_found_puncts = 0
+        # overall_valid_gt_for_assembly = 0
+
+        # +++ Лог перед финальным расчетом +++ (Оставляем на всякий случай)
+        logger.debug(f"Data before final calculation: results={results}")
+        logger.debug(f"Overall micro counters before final calc: {overall_micro_counters}")
+        logger.debug(f"Overall assembly counters before final calc: found={overall_assembly_found_puncts}, valid_gt={overall_valid_gt_for_assembly}")
+        # ...
+
+        for n in top_n_values:
+            # Извлекаем списки
+            prec_list = results[n]['precision_list']
+            rec_list = results[n]['recall_list']
+            f1_list = results[n]['f1_list']
+            assembly_recall_list = results[n]['assembly_punct_recall_list']
+            doc_recall_list = results[n]['doc_recall_list']
+            spurious_docs_list = results[n]['spurious_docs_list']
+
+            # --- Расчет Macro (с явной проверкой) ---
+            macro_precision = sum(p for p, w in prec_list) / len(prec_list) if prec_list else None
+            macro_recall = sum(r for r, w in rec_list) / len(rec_list) if rec_list else None
+            macro_f1 = sum(f for f, w in f1_list) / len(f1_list) if f1_list else None
+
+            # --- Расчет Weighted (с явной проверкой на пустой список) ---
+            weighted_precision = None
+            if prec_list:
+                weighted_precision_num = sum(p * w for p, w in prec_list)
+                weighted_precision_den = sum(w for p, w in prec_list)
+                weighted_precision = weighted_precision_num / weighted_precision_den if weighted_precision_den > 0 else 0.0
+
+            weighted_recall = None
+            if rec_list:
+                weighted_recall_num = sum(r * w for r, w in rec_list)
+                weighted_recall_den = sum(w for r, w in rec_list)
+                weighted_recall = weighted_recall_num / weighted_recall_den if weighted_recall_den > 0 else 0.0
+
+            weighted_f1 = None
+            if f1_list:
+                weighted_f1_num = sum(f * w for f, w in f1_list)
+                weighted_f1_den = sum(w for f, w in f1_list)
+                weighted_f1 = weighted_f1_num / weighted_f1_den if weighted_f1_den > 0 else 0.0
+
+            # --- Расчет Micro (теперь использует накопленные значения) ---
+            total_found = overall_micro_counters[n]['found']
+            total_gt = overall_micro_counters[n]['gt']
+            total_relevant = overall_micro_counters[n]['relevant']
+            total_retrieved = overall_micro_counters[n]['retrieved']
+            micro_precision = total_relevant / total_retrieved if total_retrieved > 0 else 0.0
+            micro_recall = total_found / total_gt if total_gt > 0 else 0.0
+            micro_f1 = (2 * micro_precision * micro_recall) / (micro_precision + micro_recall) if (micro_precision + micro_recall) > 0 else 0.0
+
+            # --- Новые Macro метрики (с явной проверкой) ---
+            assembly_punct_recall_macro = sum(assembly_recall_list) / len(assembly_recall_list) if assembly_recall_list else None
+            doc_recall_macro = sum(doc_recall_list) / len(doc_recall_list) if doc_recall_list else None
+            avg_spurious_docs = sum(spurious_docs_list) / len(spurious_docs_list) if spurious_docs_list else None
+
+            # Заполняем результат (без изменений)
+            final_metrics_results[n] = {
+                 'macro_precision': macro_precision,
+                 'macro_recall': macro_recall,
+                 'macro_f1': macro_f1,
+                 'weighted_precision': weighted_precision,
+                 'weighted_recall': weighted_recall,
+                 'weighted_f1': weighted_f1,
+                 'micro_precision': micro_precision,
+                 'micro_recall': micro_recall,
+                 'micro_f1': micro_f1,
+                 'assembly_punct_recall_macro': assembly_punct_recall_macro,
+                 'doc_recall_macro': doc_recall_macro,
+                 'avg_spurious_docs': avg_spurious_docs,
+             }
+            logger.info(f"Final metrics for top_n={n}: {final_metrics_results[n]}\n")
+
+        # --- Расчет Micro Assembly Punct Recall (теперь использует накопленные значения) ---
+        micro_assembly_punct_recall = (
+            overall_assembly_found_puncts / overall_valid_gt_for_assembly
+            if overall_valid_gt_for_assembly > 0 else 0.0
+        )
+
+        # --- Поиск худших вопросов (по Assembly Recall) ---
+        qid_to_ground_truths = {item['question_id']: item['ground_truth_texts'] for item in processed_items}
+        worst_questions_processed = []
+
+        logger.debug(f"Debugging worst questions: question_performance = {question_performance}")
+
+        # +++ Сортируем по assembly_recall_for_worst +++
+        sorted_performance = sorted(
+            [
+                (qid, data) for qid, data in question_performance.items()
+                # !!! КЛЮЧЕВОЙ ФИЛЬТР !!! Убедимся, что assembly_recall_for_worst не None
+                if data.get('assembly_recall_for_worst') is not None
+            ],
+            key=lambda item: item[1]['assembly_recall_for_worst'] # Сортируем по recall ПО ВОЗРАСТАНИЮ
+        )
+
+        # +++ ДОБАВЛЯЕМ ЛОГ ПОСЛЕ СОРТИРОВКИ +++
+        logger.debug(f"Debugging worst questions: sorted_performance (top {top_worst_k}) = {sorted_performance[:top_worst_k]}")
+        # +++ КОНЕЦ ЛОГА +++
+
+        # +++ ДОБАВЛЯЕМ ЛОГИ ВНУТРИ ЦИКЛА +++
+        for qid, perf_data in sorted_performance[:top_worst_k]:
+            logger.debug(f"Processing worst question: QID={qid}, Data={perf_data}")
+            try:
+                missed_indices = perf_data.get('missed_gt_indices', [])
+                logger.debug(f"QID={qid}: Got missed_indices: {missed_indices}")
+
+                missed_texts = []
+                if missed_indices is not None and qid in qid_to_ground_truths:
+                     original_gts = qid_to_ground_truths[qid]
+                     missed_texts = [original_gts[i] for i in missed_indices if i < len(original_gts)]
+                     logger.debug(f"QID={qid}: Found {len(missed_texts)} missed texts from {len(original_gts)} original GTs.")
+                elif qid not in qid_to_ground_truths:
+                     logger.warning(f"QID={qid} not found in qid_to_ground_truths when processing worst questions.")
+
+                # Формируем словарь перед добавлением
+                worst_entry = {
+                    'id': qid,
+                    'f1': perf_data.get('f1'), # Используем .get() для безопасности
+                    'assembly_recall': perf_data.get('assembly_recall_for_worst'),
+                    'text': perf_data.get('question_text'),
+                    'reference_answer': perf_data.get('reference_answer'),
+                    'missed_ground_truths': missed_texts
+                }
+                logger.debug(f"QID={qid}: Appending entry: {worst_entry}")
+                worst_questions_processed.append(worst_entry)
+
+            except Exception as e:
+                logger.error(f"Error processing worst question QID={qid}: {e}", exc_info=True)
+                # Не прерываем цикл, но логируем ошибку
+        # +++ КОНЕЦ ЛОГОВ ВНУТРИ ЦИКЛА +++
+
+        # --- Формируем финальный ответ ---
+        metrics_for_max_n = final_metrics_results.get(max_top_n, {})
+        overall_total_found_micro = overall_micro_counters[max_top_n]['found']
+        overall_total_gt_micro = overall_micro_counters[max_top_n]['gt']
+
+        # --- Логирование перед ответом (Оставляем) ---
+        logger.debug(f"Final Response Prep: max_top_n={max_top_n}")
+        logger.debug(f"Final Response Prep: metrics_for_max_n={metrics_for_max_n}")
+        logger.debug(f"Final Response Prep: overall_micro_counters={overall_micro_counters}")
+        logger.debug(f"Final Response Prep: micro_recall_for_human_readable = {metrics_for_max_n.get('micro_recall')}")
+        # --- Конец лога ---
+
+        # +++ Перестраиваем структуру ответа с РУССКИМИ КЛЮЧАМИ +++
+        final_response = {
+            # --- Человекочитаемые метрики --- (Вверху)
+            "Найдено пунктов (всего)": overall_total_found_micro,
+            "Всего пунктов (эталон)": overall_total_gt_micro,
+            "% найденных пунктов (чанк присутствует в пункте)": metrics_for_max_n.get('micro_recall'), # Micro Recall
+            "% пунктов были найдены в собранной версии": micro_assembly_punct_recall, # Micro Assembly Recall
+            "В среднем для каждого вопроса найден такой % пунктов": metrics_for_max_n.get('macro_recall'), # Macro Recall
+            "В среднем для каждого вопроса найден такой % документов": metrics_for_max_n.get('doc_recall_macro'), # Macro Doc Recall
+            "В среднем для каждого вопроса найдено N лишних документов, N": metrics_for_max_n.get('avg_spurious_docs'), # Avg Spurious Docs
+            # --- Результаты по top_n --- (В середине)
+            "results": final_metrics_results,
+            # --- Худшие вопросы --- (Внизу)
+            "worst_performing_questions": worst_questions_processed,
+        }
+        return final_response

main.py

@@ -1,8 +1,8 @@
 import logging
 import os
-from contextlib import asynccontextmanager
+from contextlib import asynccontextmanager  # noqa: F401
 from pathlib import Path
-from typing import Annotated
+from typing import Annotated  # noqa: F401
 
 import dotenv
 import uvicorn
@@ -10,38 +10,35 @@ from fastapi import FastAPI
 from fastapi.middleware.cors import CORSMiddleware
 from transformers import AutoModel, AutoTokenizer
 
-# from routes.acronym import router as acronym_router
-from common import dependencies as DI
+from common import dependencies as DI  # noqa: F401
 from common.common import configure_logging
 from common.configuration import Configuration
+from routes.auth import router as auth_router
 from routes.dataset import router as dataset_router
 from routes.document import router as document_router
 from routes.entity import router as entity_router
+from routes.evaluation import router as evaluation_router
 from routes.llm import router as llm_router
 from routes.llm_config import router as llm_config_router
 from routes.llm_prompt import router as llm_prompt_router
-from routes.auth import router as auth_router
-
-# from main_before import config
 
+# Защита от автоудаления линтером
+_ = DI
+_ = Annotated
+_ = asynccontextmanager
 
 # Загружаем переменные из .env
 dotenv.load_dotenv()
 
-# from routes.feedback import router as feedback_router
-# from routes.llm import router as llm_router
-# from routes.log import router as log_router
-
 CONFIG_PATH = os.environ.get('CONFIG_PATH', 'config_dev.yaml')
 print("config path: ")
 print(CONFIG_PATH)
 config = Configuration(CONFIG_PATH)
 
 logger = logging.getLogger(__name__)
-configure_logging(config_file_path=config.common_config.log_file_path)
 
 configure_logging(
-    level=logging.DEBUG, 
+    level=config.common_config.log_level, 
     config_file_path=config.common_config.log_file_path, 
 )
 
@@ -67,20 +64,20 @@ app.add_middleware(
 )
 
 app.include_router(llm_router)
-# app.include_router(log_router)
-# app.include_router(feedback_router)
 app.include_router(dataset_router)
 app.include_router(document_router)
 app.include_router(llm_config_router)
 app.include_router(llm_prompt_router)
 app.include_router(entity_router)
+app.include_router(evaluation_router)
 app.include_router(auth_router)
 
+
 if __name__ == "__main__":
     uvicorn.run(
         "main:app",
         host="localhost",
-        port=7860,
-        reload=False,
+        port=8885,
+        reload=True,
         workers=1
     )

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 массивы

routes/evaluation.py

@@ -0,0 +1,62 @@
+from typing import Annotated, Any
+
+from fastapi import APIRouter, Depends, File, HTTPException, UploadFile
+
+import common.dependencies as DI
+from common import auth
+from components.services.search_metrics import SearchMetricsService
+from schemas.evaluation import EvaluationParams, EvaluationResponse
+
+# Создание роутера
+router = APIRouter(prefix="/evaluate", tags=["Evaluation"])
+
+# Важно: добавить импорт logger, если его нет
+import logging
+
+logger = logging.getLogger(__name__)
+
+# Определение эндпоинта
+@router.post(
+    "/from_file/{dataset_id}",
+    response_model=EvaluationResponse,
+    summary="Оценка RAG по файлу",
+    description="Загружает XLSX файл с вопросами/ответами и рассчитывает метрики RAG (Precision, Recall, F1) для указанного dataset_id и различных значений top_n. Опционально применяет Query Expansion."
+)
+async def evaluate_rag_from_file(
+    dataset_id: int,
+    params: Annotated[EvaluationParams, Depends()],
+    file: Annotated[UploadFile, File(description="XLSX файл с колонками 'id', 'question', 'text' (эталонные ответы через \\n)")],
+    metrics_service: Annotated[SearchMetricsService, Depends(DI.get_search_metrics_service)],
+    current_user: Annotated[any, Depends(auth.get_current_user)], # Защита эндпоинта
+) -> Any: # Возвращаем Any, т.к. сервис возвращает dict, а FastAPI валидирует по response_model
+    """Эндпоинт для оценки RAG.
+
+    - Принимает ID датасета в пути.
+    - Принимает параметры оценки (порог, top_n, use_query_expansion) и файл как multipart/form-data.
+    - Вызывает SearchMetricsService для выполнения расчетов.
+    - Возвращает рассчитанные метрики.
+    """
+    try:
+        # --- Вызываем сервис, он теперь возвращает полный словарь ---
+        evaluation_full_results = await metrics_service.evaluate_from_file(
+            file=file,
+            dataset_id=dataset_id,
+            similarity_threshold=params.similarity_threshold,
+            top_n_values=params.top_n_values,
+            use_query_expansion=params.use_query_expansion,
+            top_worst_k=params.top_worst_k # Передаем новый параметр
+        )
+
+        # --- Просто возвращаем результат сервиса ---
+        # FastAPI сам проверит его по схеме EvaluationResponse
+        return evaluation_full_results
+
+    except HTTPException as e:
+        # Просто пробрасываем HTTP ошибки дальше
+        raise e
+    except Exception as e:
+        # Логирование ошибки может быть полезно здесь
+        logger.exception("Internal server error during evaluation endpoint execution.") # Пример логирования
+        # Ловим другие возможные ошибки во время оценки
+        # Логгер уже есть в SearchMetricsService
+        raise HTTPException(status_code=500, detail=f"Internal server error during evaluation: {e}") 

schemas/evaluation.py

@@ -0,0 +1,81 @@
+from typing import Any
+
+from pydantic import BaseModel, Field
+
+
+# Определение моделей Pydantic
+class EvaluationParams(BaseModel):
+    similarity_threshold: float = Field(
+        ...,
+        ge=0.0,
+        le=1.0,
+        description="Порог схожести для fuzzy сравнения (от 0.0 до 1.0)",
+        examples=[0.7]
+    )
+    top_n_values: list[int] = Field(
+        ...,
+        min_items=1,
+        description="Список значений Top-N для оценки",
+        examples=[[10, 20, 50]]
+    )
+    use_query_expansion: bool = Field(
+        default=False,
+        description="Использовать ли Query Expansion перед поиском для каждого вопроса",
+        examples=[True]
+    )
+    top_worst_k: int = Field(
+        default=5,
+        ge=1,
+        description="Количество худших вопросов для вывода",
+        examples=[5]
+    )
+
+class Metrics(BaseModel):
+    macro_precision: float | None
+    macro_recall: float | None
+    macro_f1: float | None
+    weighted_precision: float | None
+    weighted_recall: float | None
+    weighted_f1: float | None
+    micro_precision: float | None
+    micro_recall: float | None
+    micro_f1: float | None
+    assembly_punct_recall_macro: float | None = Field(
+        None, description="Macro-усредненный Recall найденных пунктов в собранном контексте"
+    )
+    doc_recall_macro: float | None = Field(
+        None, description="Macro-усредненный Recall найденных эталонных документов в собранном контексте"
+    )
+    avg_spurious_docs: float | None = Field(
+        None, description="Среднее количество 'лишних' документов (найденных, но не ожидаемых) на вопрос"
+    )
+
+class EvaluationResponse(BaseModel):
+    total_found_puncts_overall: int | None = Field(
+        None, alias="Найдено пунктов (всего)"
+    )
+    total_ground_truth_puncts_overall: int | None = Field(
+        None, alias="Всего пунктов (эталон)"
+    )
+    human_readable_chunk_micro_recall: float | None = Field(
+        None, alias="% найденных пунктов (чанк присутствует в пункте)"
+    )
+    human_readable_assembly_micro_recall: float | None = Field(
+        None, alias="% пунктов были найдены в собранной версии"
+    )
+    human_readable_chunk_macro_recall: float | None = Field(
+        None, alias="В среднем для каждого вопроса найден такой % пунктов"
+    )
+    human_readable_doc_macro_recall: float | None = Field(
+        None, alias="В среднем для каждого вопроса найден такой % документов"
+    )
+    human_readable_avg_spurious_docs: float | None = Field(
+        None, alias="В среднем для каждого вопроса найдено N лишних документов, N"
+    )
+    results: dict[int, Metrics] = Field(
+        ...,
+        description="Словарь с метриками для каждого значения top_n"
+    )
+    worst_performing_questions: list[dict[str, Any]] | None = Field(
+        None, description="Список вопросов с наихудшими показателями (по Assembly Recall)"
+    )