From 5ab18b8aa842c0178291795737851eb0643da777 Mon Sep 17 00:00:00 2001
From: TS426 <antoine.billiet@partnre.com>
Date: Tue, 10 Feb 2026 08:49:55 +0100
Subject: [PATCH 1/3] [DERCBOT-1783] Admin: add evaluation sample management
 API

- Add EvaluationSample and Evaluation models with all required fields
- Add ActionRef, EvaluationReason, EvaluationsResult, Evaluator models
- Implement EvaluationSampleDAO and EvaluationDAO interfaces
- Implement MongoDB DAOs with proper indexing
- Add EvaluationService with sample creation, evaluation, and status management
- Add EvaluationVerticle with REST endpoints for CRUD operations
- Add unit tests for service and integration tests for DAOs
- Support pagination for action-refs with status filtering
- Add evaluationsResult computation (total, evaluated, remaining, positiveCount, negativeCount)
---
 .idea/runConfigurations/BotAdmin.xml          |    1 +
 .../server/src/main/kotlin/BotAdminService.kt |    5 +
 .../src/main/kotlin/BotAdminVerticle.kt       |    3 +
 .../main/kotlin/model/DialogsSearchQuery.kt   |   21 +-
 .../model/evaluation/EvaluationRequests.kt    |  169 +++
 .../main/kotlin/service/EvaluationService.kt  |  321 +++++
 .../verticle/AbstractNamespaceRetriever.kt    |   41 +
 .../kotlin/verticle/EvaluationVerticle.kt     |  117 ++
 .../src/main/kotlin/verticle/GenAIVerticle.kt |   63 +-
 .../model/evaluation/EvaluationModelTest.kt   |   51 +
 .../kotlin/service/EvaluationServiceTest.kt   | 1282 +++++++++++++++++
 .../kotlin/admin/dialog/DialogReportDAO.kt    |    2 +
 .../kotlin/admin/dialog/DialogReportQuery.kt  |   14 +
 .../main/kotlin/admin/evaluation/ActionRef.kt |   29 +
 .../kotlin/admin/evaluation/Evaluation.kt     |   40 +
 .../kotlin/admin/evaluation/EvaluationDAO.kt  |   69 +
 .../admin/evaluation/EvaluationReason.kt      |   33 +
 .../admin/evaluation/EvaluationSample.kt      |   47 +
 .../admin/evaluation/EvaluationSampleDAO.kt   |   52 +
 .../evaluation/EvaluationSampleStatus.kt      |   26 +
 .../admin/evaluation/EvaluationStatus.kt      |   26 +
 .../admin/evaluation/EvaluationsResult.kt     |   47 +
 .../main/kotlin/admin/evaluation/Evaluator.kt |   25 +
 .../src/main/kotlin/DialogCol.kt              |   22 +-
 .../src/main/kotlin/EvaluationMongoDAO.kt     |  146 ++
 .../main/kotlin/EvaluationSampleMongoDAO.kt   |  117 ++
 bot/storage-mongo/src/main/kotlin/Ioc.kt      |    4 +
 .../src/main/kotlin/UserTimelineMongoDAO.kt   |  130 +-
 .../src/test/kotlin/AbstractTest.kt           |    3 +
 .../src/test/kotlin/EvaluationMongoDAOTest.kt |  247 ++++
 .../kotlin/EvaluationSampleMongoDAOTest.kt    |  194 +++
 .../test/kotlin/UserTimelineMongoDAOTest.kt   |  378 +++++
 .../rest/UnprocessableEntityException.kt      |   37 +
 33 files changed, 3673 insertions(+), 89 deletions(-)
 create mode 100644 bot/admin/server/src/main/kotlin/model/evaluation/EvaluationRequests.kt
 create mode 100644 bot/admin/server/src/main/kotlin/service/EvaluationService.kt
 create mode 100644 bot/admin/server/src/main/kotlin/verticle/AbstractNamespaceRetriever.kt
 create mode 100644 bot/admin/server/src/main/kotlin/verticle/EvaluationVerticle.kt
 create mode 100644 bot/admin/server/src/test/kotlin/model/evaluation/EvaluationModelTest.kt
 create mode 100644 bot/admin/server/src/test/kotlin/service/EvaluationServiceTest.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/ActionRef.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/Evaluation.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/EvaluationDAO.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/EvaluationReason.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/EvaluationSample.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleDAO.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleStatus.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/EvaluationStatus.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/EvaluationsResult.kt
 create mode 100644 bot/engine/src/main/kotlin/admin/evaluation/Evaluator.kt
 create mode 100644 bot/storage-mongo/src/main/kotlin/EvaluationMongoDAO.kt
 create mode 100644 bot/storage-mongo/src/main/kotlin/EvaluationSampleMongoDAO.kt
 create mode 100644 bot/storage-mongo/src/test/kotlin/EvaluationMongoDAOTest.kt
 create mode 100644 bot/storage-mongo/src/test/kotlin/EvaluationSampleMongoDAOTest.kt
 create mode 100644 shared/src/main/kotlin/exception/rest/UnprocessableEntityException.kt

diff --git a/.idea/runConfigurations/BotAdmin.xml b/.idea/runConfigurations/BotAdmin.xml
index ae2753d4ca..bad8861fa8 100644
--- a/.idea/runConfigurations/BotAdmin.xml
+++ b/.idea/runConfigurations/BotAdmin.xml
@@ -4,6 +4,7 @@
       <env name="botadminverticle_body_limit" value="-1" />
       <env name="botadminverticle_port" value="7999" />
       <env name="tock_bot_global_message" value="Dev platform" />
+      <env name="tock_mongo_url" value="mongodb://mongo:27017,mongo2:27018,mongo3:27019/?replicaSet=tock" />
     </envs>
     <option name="MAIN_CLASS_NAME" value="ai.tock.bot.admin.StartBotAdminServerKt" />
     <module name="tock-bot-admin-server" />
diff --git a/bot/admin/server/src/main/kotlin/BotAdminService.kt b/bot/admin/server/src/main/kotlin/BotAdminService.kt
index 8be5638722..36a1ba988c 100644
--- a/bot/admin/server/src/main/kotlin/BotAdminService.kt
+++ b/bot/admin/server/src/main/kotlin/BotAdminService.kt
@@ -53,6 +53,7 @@ import ai.tock.bot.admin.dialog.DialogReportQueryResult
 import ai.tock.bot.admin.dialog.DialogStatsQuery
 import ai.tock.bot.admin.dialog.DialogStatsQueryResult
 import ai.tock.bot.admin.dialog.RatingReportQueryResult
+import ai.tock.bot.admin.evaluation.EvaluationSampleDAO
 import ai.tock.bot.admin.indicators.IndicatorDAO
 import ai.tock.bot.admin.indicators.metric.MetricDAO
 import ai.tock.bot.admin.kotlin.compiler.KotlinFile
@@ -156,6 +157,7 @@ object BotAdminService {
     private val i18n: I18nDAO by injector.instance()
     private val indicatorDAO: IndicatorDAO by injector.instance()
     private val metricDAO: MetricDAO get() = injector.provide()
+    private val evaluationSampleDAO: EvaluationSampleDAO get() = injector.provide()
 
     private class BotStoryDefinitionConfigurationDumpController(
         override val targetNamespace: String,
@@ -1656,6 +1658,9 @@ object BotAdminService {
         // delete Indicators and Metrics
         indicatorDAO.deleteByApplicationName(app.namespace, app.name)
         metricDAO.deleteByApplicationName(app.namespace, app.name)
+
+        // delete evaluation samples and their evaluations
+        evaluationSampleDAO.deleteByNamespaceAndBotId(app.namespace, app.name)
     }
 
     fun changeSupportedLocales(newApp: ApplicationDefinition) {
diff --git a/bot/admin/server/src/main/kotlin/BotAdminVerticle.kt b/bot/admin/server/src/main/kotlin/BotAdminVerticle.kt
index e4b4973848..059482c416 100644
--- a/bot/admin/server/src/main/kotlin/BotAdminVerticle.kt
+++ b/bot/admin/server/src/main/kotlin/BotAdminVerticle.kt
@@ -49,6 +49,7 @@ import ai.tock.bot.admin.story.dump.StoryDefinitionConfigurationDumpImport
 import ai.tock.bot.admin.test.TestPlanService
 import ai.tock.bot.admin.test.findTestService
 import ai.tock.bot.admin.verticle.DialogVerticle
+import ai.tock.bot.admin.verticle.EvaluationVerticle
 import ai.tock.bot.admin.verticle.GenAIVerticle
 import ai.tock.bot.admin.verticle.IndicatorVerticle
 import ai.tock.bot.connector.ConnectorType.Companion.rest
@@ -100,6 +101,7 @@ open class BotAdminVerticle : AdminVerticle() {
     private val indicatorVerticle = IndicatorVerticle()
     private val dialogVerticle = DialogVerticle()
     private val aiVerticle = GenAIVerticle()
+    private val evaluationVerticle = EvaluationVerticle()
 
     override val logger: KLogger = KotlinLogging.logger {}
 
@@ -162,6 +164,7 @@ open class BotAdminVerticle : AdminVerticle() {
         indicatorVerticle.configure(this)
         dialogVerticle.configure(this)
         aiVerticle.configure(this)
+        evaluationVerticle.configure(this)
 
         blockingJsonPost("/users/search", botUser) { context, query: UserSearchQuery ->
             if (context.organization == query.namespace) {
diff --git a/bot/admin/server/src/main/kotlin/model/DialogsSearchQuery.kt b/bot/admin/server/src/main/kotlin/model/DialogsSearchQuery.kt
index 85ad27a47d..f72e1246fd 100644
--- a/bot/admin/server/src/main/kotlin/model/DialogsSearchQuery.kt
+++ b/bot/admin/server/src/main/kotlin/model/DialogsSearchQuery.kt
@@ -55,16 +55,17 @@ data class DialogsSearchQuery(
 ) : PaginatedQuery() {
     fun toDialogReportQuery(): DialogReportQuery {
         return DialogReportQuery(
-            namespace,
-            applicationName,
-            language,
-            start,
-            size,
-            playerId,
-            text,
-            dialogId,
-            intentName,
-            exactMatch,
+            namespace = namespace,
+            nlpModel = applicationName,
+            language = language,
+            start = start,
+            size = size,
+            playerId = playerId,
+            text = text,
+            dialogId = dialogId,
+            dialogIds = null,
+            intentName = intentName,
+            exactMatch = exactMatch,
             connectorType = connectorType,
             displayTests = displayTests,
             obfuscated = true,
diff --git a/bot/admin/server/src/main/kotlin/model/evaluation/EvaluationRequests.kt b/bot/admin/server/src/main/kotlin/model/evaluation/EvaluationRequests.kt
new file mode 100644
index 0000000000..ba6ef2d942
--- /dev/null
+++ b/bot/admin/server/src/main/kotlin/model/evaluation/EvaluationRequests.kt
@@ -0,0 +1,169 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.model.evaluation
+
+import ai.tock.bot.admin.dialog.DialogReport
+import ai.tock.bot.admin.evaluation.ActionRef
+import ai.tock.bot.admin.evaluation.Evaluation
+import ai.tock.bot.admin.evaluation.EvaluationReason
+import ai.tock.bot.admin.evaluation.EvaluationSample
+import ai.tock.bot.admin.evaluation.EvaluationSampleStatus
+import ai.tock.bot.admin.evaluation.EvaluationStatus
+import ai.tock.bot.admin.evaluation.EvaluationsResult
+import java.time.Instant
+
+/**
+ * Request to create a new evaluation sample.
+ */
+data class CreateEvaluationSampleRequest(
+    val name: String?,
+    val description: String?,
+    val dialogActivityFrom: Instant,
+    val dialogActivityTo: Instant,
+    val requestedDialogCount: Int,
+    val allowTestDialogs: Boolean = false,
+)
+
+/**
+ * Query for paginated evaluation dialogs.
+ * Pagination is by dialog (dialogs are sorted by dialog id, ascending).
+ * POST body follows Tock convention for search endpoints.
+ *
+ * @param start Offset (index of first dialog), default 0
+ * @param size Number of dialogs per page, default 20
+ */
+data class EvaluationDialogsQuery(
+    val start: Int = 0,
+    val size: Int = 10,
+)
+
+/**
+ * Response for paginated evaluation dialogs.
+ * Contains action refs with evaluations for the requested page of dialogs,
+ * plus the corresponding dialog reports.
+ *
+ * @param start Requested offset
+ * @param size Number of action refs returned (one per evaluable action in the page)
+ * @param total Total number of dialogs in the sample
+ * @param actionRefs Action refs with their evaluations for the current page
+ * @param dialogs Found dialog reports and missing action refs
+ */
+data class EvaluationDialogsResponse(
+    val start: Int,
+    val size: Int,
+    /**
+     *  exclusive. start + dialogs.size()
+     */
+    val end: Int,
+    val total: Long,
+    val actionRefs: List<ActionRefWithEvaluation>,
+    val dialogs: List<DialogEntry>,
+)
+
+/**
+ * An action ref with its associated evaluation.
+ */
+data class ActionRefWithEvaluation(
+    val dialogId: String,
+    val actionId: String,
+    val evaluation: Evaluation,
+)
+
+data class DialogEntry(
+    val dialogId: String,
+    val dialog: DialogReport?,
+)
+
+/**
+ * Result containing found and missing dialogs.
+ */
+data class DialogsResult(
+    val found: List<DialogReport>,
+    val missing: List<ActionRef>,
+)
+
+/**
+ * Request to evaluate an action (PATCH).
+ */
+data class EvaluateRequest(
+    val status: EvaluationStatus,
+    val reason: EvaluationReason? = null,
+)
+
+/**
+ * Request to change the status of an evaluation sample.
+ */
+data class ChangeStatusRequest(
+    val targetStatus: EvaluationSampleStatus,
+    val comment: String? = null,
+)
+
+/**
+ * DTO for evaluation sample with computed evaluationsResult.
+ */
+data class EvaluationSampleDTO(
+    val _id: String,
+    val botId: String,
+    val namespace: String,
+    val name: String?,
+    val description: String?,
+    val dialogActivityFrom: Instant,
+    val dialogActivityTo: Instant,
+    val requestedDialogCount: Int,
+    val dialogsCount: Int,
+    val totalDialogCount: Int,
+    val botActionCount: Int,
+    val allowTestDialogs: Boolean,
+    val status: EvaluationSampleStatus,
+    val createdBy: String,
+    val creationDate: Instant,
+    val statusChangedBy: String,
+    val statusChangeDate: Instant,
+    val statusComment: String?,
+    val lastUpdateDate: Instant,
+    val evaluationsResult: EvaluationsResult,
+) {
+    companion object {
+        fun from(
+            sample: EvaluationSample,
+            evaluationsResult: EvaluationsResult,
+        ): EvaluationSampleDTO {
+            return EvaluationSampleDTO(
+                _id = sample._id.toString(),
+                botId = sample.botId,
+                namespace = sample.namespace,
+                name = sample.name,
+                description = sample.description,
+                dialogActivityFrom = sample.dialogActivityFrom,
+                dialogActivityTo = sample.dialogActivityTo,
+                requestedDialogCount = sample.requestedDialogCount,
+                dialogsCount = sample.dialogsCount,
+                totalDialogCount = sample.totalDialogCount,
+                botActionCount = sample.botActionCount,
+                allowTestDialogs = sample.allowTestDialogs,
+                status = sample.status,
+                createdBy = sample.createdBy,
+                creationDate = sample.creationDate,
+                statusChangedBy = sample.statusChangedBy,
+                statusChangeDate = sample.statusChangeDate,
+                statusComment = sample.statusComment,
+                lastUpdateDate = sample.lastUpdateDate,
+                evaluationsResult = evaluationsResult,
+            )
+        }
+    }
+}
diff --git a/bot/admin/server/src/main/kotlin/service/EvaluationService.kt b/bot/admin/server/src/main/kotlin/service/EvaluationService.kt
new file mode 100644
index 0000000000..ccabec4a4c
--- /dev/null
+++ b/bot/admin/server/src/main/kotlin/service/EvaluationService.kt
@@ -0,0 +1,321 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.service
+
+import ai.tock.bot.admin.dialog.DialogReportDAO
+import ai.tock.bot.admin.dialog.DialogReportQuery
+import ai.tock.bot.admin.evaluation.ActionRef
+import ai.tock.bot.admin.evaluation.Evaluation
+import ai.tock.bot.admin.evaluation.EvaluationDAO
+import ai.tock.bot.admin.evaluation.EvaluationReason
+import ai.tock.bot.admin.evaluation.EvaluationSample
+import ai.tock.bot.admin.evaluation.EvaluationSampleDAO
+import ai.tock.bot.admin.evaluation.EvaluationSampleStatus
+import ai.tock.bot.admin.evaluation.EvaluationStatus
+import ai.tock.bot.admin.evaluation.EvaluationsResult
+import ai.tock.bot.admin.evaluation.Evaluator
+import ai.tock.bot.admin.model.evaluation.ActionRefWithEvaluation
+import ai.tock.bot.admin.model.evaluation.CreateEvaluationSampleRequest
+import ai.tock.bot.admin.model.evaluation.DialogEntry
+import ai.tock.bot.admin.model.evaluation.EvaluationDialogsResponse
+import ai.tock.bot.admin.model.evaluation.EvaluationSampleDTO
+import ai.tock.shared.exception.rest.BadRequestException
+import ai.tock.shared.exception.rest.UnprocessableEntityException
+import ai.tock.shared.injector
+import ai.tock.shared.provide
+import mu.KotlinLogging
+import org.litote.kmongo.toId
+import java.time.Instant
+import java.time.ZoneOffset
+
+private val logger = KotlinLogging.logger {}
+
+object EvaluationService {
+    private val evaluationSampleDAO: EvaluationSampleDAO get() = injector.provide()
+    private val evaluationDAO: EvaluationDAO get() = injector.provide()
+    private val dialogReportDAO: DialogReportDAO get() = injector.provide()
+
+    fun findSamplesByBotId(
+        namespace: String,
+        botId: String,
+        status: EvaluationSampleStatus? = null,
+    ): List<EvaluationSampleDTO> {
+        val samples = evaluationSampleDAO.findByNamespaceAndBotId(namespace, botId, status)
+        return samples.map { sample ->
+            val statusCounts = evaluationDAO.countByStatus(sample._id)
+            val evaluationsResult = EvaluationsResult.fromStatusCounts(statusCounts)
+            EvaluationSampleDTO.from(sample, evaluationsResult)
+        }
+    }
+
+    fun findSampleById(sampleId: String): EvaluationSampleDTO? {
+        val sample = evaluationSampleDAO.findById(sampleId.toId()) ?: return null
+        val statusCounts = evaluationDAO.countByStatus(sample._id)
+        val evaluationsResult = EvaluationsResult.fromStatusCounts(statusCounts)
+        return EvaluationSampleDTO.from(sample, evaluationsResult)
+    }
+
+    fun createEvaluationSample(
+        namespace: String,
+        botId: String,
+        request: CreateEvaluationSampleRequest,
+        createdBy: String,
+    ): EvaluationSampleDTO {
+        logger.info { "Creating evaluation sample for bot $botId in namespace $namespace" }
+
+        val dialogQuery =
+            DialogReportQuery(
+                namespace = namespace,
+                nlpModel = botId,
+                dialogActivityFrom = request.dialogActivityFrom.atZone(ZoneOffset.UTC),
+                dialogActivityTo = request.dialogActivityTo.atZone(ZoneOffset.UTC),
+                displayTests = request.allowTestDialogs,
+                withAnnotations = false,
+                start = 0L,
+                size = request.requestedDialogCount,
+                random = true,
+                evaluableActionsOnly = true,
+            )
+
+        val dialogResult = dialogReportDAO.search(dialogQuery)
+        val totalDialogCount = dialogResult.total.toInt()
+
+        val actionRefs =
+            dialogResult.dialogs.flatMap { dialog ->
+                dialog.actions.map { action ->
+                    ActionRef(
+                        dialogId = dialog.id,
+                        actionId = action.id,
+                    )
+                }
+            }
+
+        if (actionRefs.isEmpty()) {
+            throw UnprocessableEntityException(
+                errorCode = 4221,
+                message = "No dialog matching query",
+            )
+        }
+
+        val selectedDialogs = actionRefs.map { it.dialogId }.distinct()
+        val now = Instant.now()
+        val sample =
+            EvaluationSample(
+                botId = botId,
+                namespace = namespace,
+                name = request.name,
+                description = request.description,
+                dialogActivityFrom = request.dialogActivityFrom,
+                dialogActivityTo = request.dialogActivityTo,
+                requestedDialogCount = request.requestedDialogCount,
+                dialogsCount = selectedDialogs.size,
+                totalDialogCount = totalDialogCount,
+                botActionCount = actionRefs.size,
+                allowTestDialogs = request.allowTestDialogs,
+                actionRefs = actionRefs,
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = createdBy,
+                creationDate = now,
+                statusChangedBy = createdBy,
+                statusChangeDate = now,
+                lastUpdateDate = now,
+            )
+
+        val savedSample = evaluationSampleDAO.save(sample)
+
+        val evaluations =
+            actionRefs.map { ref ->
+                Evaluation(
+                    evaluationSampleId = savedSample._id,
+                    dialogId = ref.dialogId,
+                    actionId = ref.actionId,
+                    status = EvaluationStatus.UNSET,
+                    creationDate = now,
+                    lastUpdateDate = now,
+                )
+            }
+        evaluationDAO.createAll(evaluations)
+
+        logger.info { "Created evaluation sample ${savedSample._id} with ${actionRefs.size} bot actions from ${selectedDialogs.size} dialogs" }
+
+        val evaluationsResult =
+            EvaluationsResult(
+                total = actionRefs.size,
+                evaluated = 0,
+                remaining = actionRefs.size,
+                positiveCount = 0,
+                negativeCount = 0,
+            )
+
+        return EvaluationSampleDTO.from(savedSample, evaluationsResult)
+    }
+
+    /**
+     * Returns paginated evaluation dialogs for a sample.
+     * Dialogs are sorted by dialog id (ascending). Each page contains action refs with their evaluations.
+     */
+    fun getEvaluationDialogs(
+        sampleId: String,
+        start: Int,
+        size: Int,
+    ): EvaluationDialogsResponse {
+        val sample =
+            evaluationSampleDAO.findById(sampleId.toId())
+                ?: run {
+                    logger.error { "Evaluation sample not found for getEvaluationDialogs: sampleId=$sampleId" }
+                    throw BadRequestException("Evaluation sample not found: $sampleId")
+                }
+        val groupedEvaluations =
+            evaluationDAO.findGroupedEvaluationsBySampleId(
+                sampleId = sample._id,
+                start = start,
+                size = size,
+            )
+
+        val pageDialogIds = groupedEvaluations.map { it._id }
+        val foundDialogs = dialogReportDAO.findByDialogByIds(pageDialogIds.toSet())
+        val dialogsById = foundDialogs.associateBy { it.id }
+        val evaluations = groupedEvaluations.flatMap { it.evaluations }
+        val actionRefsWithEvaluation =
+            evaluations.map { eval ->
+                ActionRefWithEvaluation(
+                    dialogId = eval.dialogId.toString(),
+                    actionId = eval.actionId.toString(),
+                    evaluation = eval,
+                )
+            }
+
+        val dialogsOrdered =
+            pageDialogIds.map { dialogId ->
+                DialogEntry(
+                    dialogId = dialogId.toString(),
+                    dialog = dialogsById[dialogId],
+                )
+            }
+
+        return EvaluationDialogsResponse(
+            start = start,
+            size = actionRefsWithEvaluation.size,
+            end = start + dialogsOrdered.size,
+            total = sample.dialogsCount.toLong(),
+            actionRefs = actionRefsWithEvaluation,
+            dialogs = dialogsOrdered,
+        )
+    }
+
+    fun evaluate(
+        sampleId: String,
+        evaluationId: String,
+        status: EvaluationStatus,
+        reason: EvaluationReason?,
+        evaluatorId: String,
+    ): Evaluation? {
+        val sample =
+            evaluationSampleDAO.findById(sampleId.toId())
+                ?: run {
+                    logger.error { "Evaluation sample not found: sampleId=$sampleId, evaluationId=$evaluationId" }
+                    throw BadRequestException("Evaluation sample not found: $sampleId")
+                }
+
+        if (sample.status != EvaluationSampleStatus.IN_PROGRESS) {
+            logger.error { "Cannot evaluate: sample status is ${sample.status}, sampleId=$sampleId, evaluationId=$evaluationId" }
+            throw BadRequestException("Cannot evaluate: sample status is ${sample.status}")
+        }
+
+        val evaluation =
+            evaluationDAO.findById(evaluationId.toId())
+                ?: run {
+                    logger.error { "Evaluation not found: sampleId=$sampleId, evaluationId=$evaluationId" }
+                    throw BadRequestException("Evaluation not found: $evaluationId")
+                }
+
+        if (evaluation.evaluationSampleId != sample._id) {
+            logger.error { "Evaluation does not belong to sample: sampleId=$sampleId, evaluationId=$evaluationId" }
+            throw BadRequestException("Evaluation $evaluationId does not belong to sample $sampleId")
+        }
+
+        if (status == EvaluationStatus.UNSET) {
+            logger.error { "Cannot set evaluation status to UNSET: sampleId=$sampleId, evaluationId=$evaluationId" }
+            throw BadRequestException("Cannot set evaluation status to UNSET")
+        }
+
+        if (status == EvaluationStatus.UP && reason != null) {
+            logger.error { "Reason must be null for UP evaluation: sampleId=$sampleId, evaluationId=$evaluationId" }
+            throw BadRequestException("Reason must be null for UP evaluation")
+        }
+
+        if (status == EvaluationStatus.DOWN && reason == null) {
+            logger.error { "Reason is required for DOWN evaluation: sampleId=$sampleId, evaluationId=$evaluationId" }
+            throw BadRequestException("Reason is required for DOWN evaluation")
+        }
+
+        val now = Instant.now()
+        val updated =
+            evaluation.copy(
+                status = status,
+                reason = reason,
+                evaluator = Evaluator(evaluatorId),
+                evaluationDate = now,
+                lastUpdateDate = now,
+            )
+
+        return evaluationDAO.update(updated)
+    }
+
+    fun changeStatus(
+        sampleId: String,
+        targetStatus: EvaluationSampleStatus,
+        changedBy: String,
+        comment: String?,
+    ): EvaluationSampleDTO? {
+        val sample =
+            evaluationSampleDAO.findById(sampleId.toId())
+                ?: run {
+                    logger.error { "Evaluation sample not found for changeStatus: sampleId=$sampleId" }
+                    throw BadRequestException("Evaluation sample not found: $sampleId")
+                }
+
+        if (sample.status != EvaluationSampleStatus.IN_PROGRESS) {
+            logger.error { "Cannot change status: sample is already ${sample.status}, sampleId=$sampleId" }
+            throw BadRequestException("Cannot change status: sample is already ${sample.status}")
+        }
+
+        if (targetStatus == EvaluationSampleStatus.IN_PROGRESS) {
+            logger.error { "Cannot change status to IN_PROGRESS: sampleId=$sampleId" }
+            throw BadRequestException("Cannot change status to IN_PROGRESS")
+        }
+
+        val updatedSample =
+            evaluationSampleDAO.updateStatus(
+                id = sample._id,
+                status = targetStatus,
+                changedBy = changedBy,
+                comment = comment,
+            ) ?: return null
+
+        val statusCounts = evaluationDAO.countByStatus(updatedSample._id)
+        val evaluationsResult = EvaluationsResult.fromStatusCounts(statusCounts)
+
+        return EvaluationSampleDTO.from(updatedSample, evaluationsResult)
+    }
+
+    fun deleteSample(sampleId: String): Boolean {
+        val id = sampleId.toId<EvaluationSample>()
+        evaluationDAO.deleteByEvaluationSampleId(id)
+        return evaluationSampleDAO.delete(id)
+    }
+}
diff --git a/bot/admin/server/src/main/kotlin/verticle/AbstractNamespaceRetriever.kt b/bot/admin/server/src/main/kotlin/verticle/AbstractNamespaceRetriever.kt
new file mode 100644
index 0000000000..2c898818d6
--- /dev/null
+++ b/bot/admin/server/src/main/kotlin/verticle/AbstractNamespaceRetriever.kt
@@ -0,0 +1,41 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.verticle
+
+import ai.tock.nlp.front.client.FrontClient
+import ai.tock.nlp.front.shared.config.ApplicationDefinition
+import ai.tock.shared.exception.rest.NotFoundException
+import ai.tock.shared.security.TockUser
+import io.vertx.ext.web.RoutingContext
+
+abstract class AbstractNamespaceRetriever {
+    val front = FrontClient
+
+    /**
+     * Get the namespace from the context
+     * @param context : the vertx routing context
+     */
+    fun getNamespace(context: RoutingContext): String? = ((context.user() ?: context.session()?.get("tockUser")) as? TockUser)?.namespace
+
+    fun currentContextApp(context: RoutingContext): ApplicationDefinition? {
+        val botId = context.pathParam("botId")
+
+        return getNamespace(context)?.let { namespace ->
+            front.getApplicationByNamespaceAndName(namespace, botId)
+        } ?: throw NotFoundException(404, "Could not find $botId in namespace")
+    }
+}
diff --git a/bot/admin/server/src/main/kotlin/verticle/EvaluationVerticle.kt b/bot/admin/server/src/main/kotlin/verticle/EvaluationVerticle.kt
new file mode 100644
index 0000000000..3958067b56
--- /dev/null
+++ b/bot/admin/server/src/main/kotlin/verticle/EvaluationVerticle.kt
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.verticle
+
+import ai.tock.bot.admin.model.evaluation.ChangeStatusRequest
+import ai.tock.bot.admin.model.evaluation.CreateEvaluationSampleRequest
+import ai.tock.bot.admin.model.evaluation.EvaluateRequest
+import ai.tock.bot.admin.model.evaluation.EvaluationDialogsQuery
+import ai.tock.bot.admin.service.EvaluationService
+import ai.tock.shared.security.TockUserRole.botUser
+import ai.tock.shared.vertx.WebVerticle
+import io.vertx.ext.web.RoutingContext
+
+/**
+ * Verticle handling evaluation sample endpoints.
+ */
+class EvaluationVerticle : AbstractNamespaceRetriever() {
+    companion object {
+        private const val PATH_SAMPLES = "/bots/:botId/evaluation-samples"
+        private const val PATH_SAMPLE = "/bots/:botId/evaluation-samples/:sampleId"
+        private const val PATH_ACTION_REFS = "/bots/:botId/evaluation-samples/:sampleId/action-refs"
+        private const val PATH_EVALUATION = "/bots/:botId/evaluation-samples/:sampleId/evaluations/:evaluationId"
+        private const val PATH_CHANGE_STATUS = "/bots/:botId/evaluation-samples/:sampleId/change-status"
+    }
+
+    fun configure(verticle: WebVerticle) {
+        with(verticle) {
+            // GET /bots/:botId/evaluation-samples - List all evaluation samples for a bot
+            blockingJsonGet(PATH_SAMPLES, botUser) { context ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
+                    val botId = context.pathParam("botId")
+                    val namespace = context.organization
+                    val statusParam = context.queryParam("status").firstOrNull()
+                    val status =
+                        statusParam?.let {
+                            ai.tock.bot.admin.evaluation.EvaluationSampleStatus.valueOf(it)
+                        }
+                    EvaluationService.findSamplesByBotId(namespace, botId, status)
+                }
+            }
+
+            // POST /bots/:botId/evaluation-samples - Create a new evaluation sample (returns 201 Created)
+            blockingJsonPost(PATH_SAMPLES, botUser) { context, request: CreateEvaluationSampleRequest ->
+                val result =
+                    checkNamespaceAndExecute(context, ::currentContextApp) { app ->
+                        val botId = context.pathParam("botId")
+                        val namespace = context.organization
+                        val createdBy = context.userLogin
+                        EvaluationService.createEvaluationSample(namespace, botId, request, createdBy)
+                    }
+                context.response().statusCode = 201
+                result
+            }
+
+            // GET /bots/:botId/evaluation-samples/:sampleId - Get a specific evaluation sample
+            blockingJsonGet(PATH_SAMPLE, botUser) { context ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
+                    val sampleId = context.pathParam("sampleId")
+                    EvaluationService.findSampleById(sampleId)
+                }
+            }
+
+            // DELETE /bots/:botId/evaluation-samples/:sampleId - Delete an evaluation sample (returns 204 No Content)
+            blockingDeleteEmptyResponse(PATH_SAMPLE, setOf(botUser)) { context ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
+                    val sampleId = context.pathParam("sampleId")
+                    EvaluationService.deleteSample(sampleId)
+                }
+            }
+
+            // POST /bots/:botId/evaluation-samples/:sampleId/action-refs - Get paginated evaluation dialogs (POST with body)
+            // Returns dialogs sorted by creation date, with their action refs and evaluations
+            blockingJsonPost(PATH_ACTION_REFS, botUser) { context, query: EvaluationDialogsQuery ->
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) { app ->
+                    val sampleId = context.pathParam("sampleId")
+                    EvaluationService.getEvaluationDialogs(sampleId, query.start, query.size)
+                }
+            }
+
+            // PUT /bots/:botId/evaluation-samples/:sampleId/evaluations/:evaluationId - Evaluate an action
+            blockingJsonPut(
+                PATH_EVALUATION,
+                setOf(botUser),
+            ) { context: RoutingContext, request: EvaluateRequest ->
+                return@blockingJsonPut checkNamespaceAndExecute(context, ::currentContextApp) { app ->
+                    val sampleId = context.pathParam("sampleId")
+                    val evaluationId = context.pathParam("evaluationId")
+                    val evaluatorId = context.userLogin
+                    EvaluationService.evaluate(sampleId, evaluationId, request.status, request.reason, evaluatorId)
+                }
+            }
+
+            // POST /bots/:botId/evaluation-samples/:sampleId/change-status - Change sample status
+            blockingJsonPost(PATH_CHANGE_STATUS, botUser) { context, request: ChangeStatusRequest ->
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) { app ->
+                    val sampleId = context.pathParam("sampleId")
+                    val changedBy = context.userLogin
+                    EvaluationService.changeStatus(sampleId, request.targetStatus, changedBy, request.comment)
+                }
+            }
+        }
+    }
+}
diff --git a/bot/admin/server/src/main/kotlin/verticle/GenAIVerticle.kt b/bot/admin/server/src/main/kotlin/verticle/GenAIVerticle.kt
index b51fbb9269..ccf29d0898 100644
--- a/bot/admin/server/src/main/kotlin/verticle/GenAIVerticle.kt
+++ b/bot/admin/server/src/main/kotlin/verticle/GenAIVerticle.kt
@@ -31,10 +31,6 @@ import ai.tock.bot.admin.service.ObservabilityService
 import ai.tock.bot.admin.service.RAGService
 import ai.tock.bot.admin.service.SentenceGenerationService
 import ai.tock.bot.admin.service.VectorStoreService
-import ai.tock.nlp.front.client.FrontClient
-import ai.tock.nlp.front.shared.config.ApplicationDefinition
-import ai.tock.shared.exception.rest.NotFoundException
-import ai.tock.shared.security.TockUser
 import ai.tock.shared.security.TockUserRole.admin
 import ai.tock.shared.security.TockUserRole.botUser
 import ai.tock.shared.security.TockUserRole.nlpUser
@@ -44,7 +40,7 @@ import io.vertx.ext.web.RoutingContext
 /**
  * [GenAIVerticle] contains all the routes and actions associated with the AI tasks
  */
-class GenAIVerticle {
+class GenAIVerticle : AbstractNamespaceRetriever() {
     companion object {
         // Configuration
         private const val PATH_CONFIG_RAG = "/gen-ai/bots/:botId/configuration/rag"
@@ -59,29 +55,14 @@ class GenAIVerticle {
         private const val PATH_COMPLETION_PLAYGROUND = "/gen-ai/bots/:botId/completion/playground"
     }
 
-    private val front = FrontClient
-
     fun configure(webVerticle: WebVerticle) {
         with(webVerticle) {
-            /**
-             * lamdba calling database to retrieve application definition from request context
-             * @return [ApplicationDefinition]
-             */
-            val currentContextApp: (RoutingContext) -> ApplicationDefinition? = { context ->
-                val botId = context.pathParam("botId")
-                getNamespace(context)?.let { namespace ->
-                    front.getApplicationByNamespaceAndName(
-                        namespace, botId,
-                    )
-                } ?: throw NotFoundException(404, "Could not find $botId in namespace")
-            }
-
             // --------------------------------------- Config - RAG ----------------------------------------
             blockingJsonPost(
                 PATH_CONFIG_RAG,
                 admin,
             ) { context: RoutingContext, request: BotRAGConfigurationDTO ->
-                return@blockingJsonPost checkNamespaceAndExecute(context, currentContextApp) {
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) {
                     logger.info { "Saving 'RAG' configuration..." }
                     BotRAGConfigurationDTO(
                         RAGService.saveRag(request),
@@ -93,7 +74,7 @@ class GenAIVerticle {
                 PATH_CONFIG_RAG,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Retrieving 'RAG' configuration..." }
                     RAGService.getRAGConfiguration(app.namespace, app.name)?.let { BotRAGConfigurationDTO(it) }
                 }
@@ -103,7 +84,7 @@ class GenAIVerticle {
                 PATH_CONFIG_RAG,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Deleting 'RAG' configuration..." }
                     RAGService.deleteConfig(app.namespace, app.name)
                 }
@@ -114,7 +95,7 @@ class GenAIVerticle {
                 PATH_CONFIG_SENTENCE_GENERATION,
                 admin,
             ) { context: RoutingContext, request: BotSentenceGenerationConfigurationDTO ->
-                return@blockingJsonPost checkNamespaceAndExecute(context, currentContextApp) {
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) {
                     logger.info { "Saving 'Sentence Generation' configuration..." }
                     BotSentenceGenerationConfigurationDTO(
                         SentenceGenerationService.saveSentenceGeneration(request),
@@ -126,7 +107,7 @@ class GenAIVerticle {
                 PATH_CONFIG_SENTENCE_GENERATION,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Retrieving 'Sentence Generation' configuration..." }
                     SentenceGenerationService.getSentenceGenerationConfiguration(app.namespace, app.name)
                         ?.let { BotSentenceGenerationConfigurationDTO(it) }
@@ -137,7 +118,7 @@ class GenAIVerticle {
                 PATH_CONFIG_SENTENCE_GENERATION_INFO,
                 nlpUser,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Retrieving 'Sentence Generation' configuration info..." }
                     SentenceGenerationService.getSentenceGenerationConfiguration(app.namespace, app.name)
                         ?.let { BotSentenceGenerationInfoDTO(it) } ?: BotSentenceGenerationInfoDTO()
@@ -148,7 +129,7 @@ class GenAIVerticle {
                 PATH_CONFIG_SENTENCE_GENERATION,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Deleting 'Sentence Generation' configuration..." }
                     SentenceGenerationService.deleteConfig(app.namespace, app.name)
                 }
@@ -159,7 +140,7 @@ class GenAIVerticle {
                 PATH_CONFIG_VECTOR_STORE,
                 admin,
             ) { context: RoutingContext, request: BotVectorStoreConfigurationDTO ->
-                return@blockingJsonPost checkNamespaceAndExecute(context, currentContextApp) {
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) {
                     logger.info { "Saving 'Vector Store' configuration..." }
                     BotVectorStoreConfigurationDTO(
                         VectorStoreService.saveVectorStore(request),
@@ -171,7 +152,7 @@ class GenAIVerticle {
                 PATH_CONFIG_VECTOR_STORE,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Retrieving 'Vector Store' configuration..." }
                     VectorStoreService.getVectorStoreConfiguration(app.namespace, app.name)
                         ?.let { BotVectorStoreConfigurationDTO(it) }
@@ -182,7 +163,7 @@ class GenAIVerticle {
                 PATH_CONFIG_VECTOR_STORE,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Deleting 'Vector Store' configuration..." }
                     VectorStoreService.deleteConfig(app.namespace, app.name)
                 }
@@ -193,7 +174,7 @@ class GenAIVerticle {
                 PATH_CONFIG_VECTOR_OBSERVABILITY,
                 admin,
             ) { context: RoutingContext, request: BotObservabilityConfigurationDTO ->
-                return@blockingJsonPost checkNamespaceAndExecute(context, currentContextApp) {
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) {
                     logger.info { "Saving 'Observability' configuration..." }
                     BotObservabilityConfigurationDTO(
                         ObservabilityService.saveObservability(request),
@@ -205,7 +186,7 @@ class GenAIVerticle {
                 PATH_CONFIG_VECTOR_OBSERVABILITY,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Retrieving 'Observability' configuration..." }
                     ObservabilityService.getObservabilityConfiguration(app.namespace, app.name)
                         ?.let { BotObservabilityConfigurationDTO(it) }
@@ -216,7 +197,7 @@ class GenAIVerticle {
                 PATH_CONFIG_VECTOR_OBSERVABILITY,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Deleting 'Observability' configuration..." }
                     ObservabilityService.deleteConfig(app.namespace, app.name)
                 }
@@ -227,7 +208,7 @@ class GenAIVerticle {
                 PATH_CONFIG_DOCUMENT_COMPRESSOR,
                 admin,
             ) { context: RoutingContext, request: BotDocumentCompressorConfigurationDTO ->
-                return@blockingJsonPost checkNamespaceAndExecute(context, currentContextApp) {
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) {
                     logger.info { "Saving 'Document Compressor' configuration..." }
                     BotDocumentCompressorConfigurationDTO(
                         DocumentCompressorService.saveDocumentCompressor(request),
@@ -239,7 +220,7 @@ class GenAIVerticle {
                 PATH_CONFIG_DOCUMENT_COMPRESSOR,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Retrieving 'Document Compressor' configuration..." }
                     DocumentCompressorService.getDocumentCompressorConfiguration(app.namespace, app.name)
                         ?.let { BotDocumentCompressorConfigurationDTO(it) }
@@ -250,7 +231,7 @@ class GenAIVerticle {
                 PATH_CONFIG_DOCUMENT_COMPRESSOR,
                 admin,
             ) { context: RoutingContext ->
-                checkNamespaceAndExecute(context, currentContextApp) { app ->
+                checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "Deleting 'Document Compressor' configuration..." }
                     DocumentCompressorService.deleteConfig(app.namespace, app.name)
                 }
@@ -261,7 +242,7 @@ class GenAIVerticle {
                 PATH_COMPLETION_SENTENCE_GENERATION,
                 botUser,
             ) { context: RoutingContext, request: SentenceGenerationRequest ->
-                return@blockingJsonPost checkNamespaceAndExecute(context, currentContextApp) { app ->
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "GEN AI - Generating sentences..." }
                     CompletionService.generateSentences(request, app.namespace, app.name)
                 }
@@ -272,7 +253,7 @@ class GenAIVerticle {
                 PATH_COMPLETION_PLAYGROUND,
                 admin,
             ) { context: RoutingContext, request: PlaygroundRequest ->
-                return@blockingJsonPost checkNamespaceAndExecute(context, currentContextApp) { app ->
+                return@blockingJsonPost checkNamespaceAndExecute(context, ::currentContextApp) { app ->
                     logger.info { "GEN AI - Playground..." }
                     CompletionService.generate(request, app.namespace, app.name)
                 }
@@ -280,12 +261,6 @@ class GenAIVerticle {
         }
     }
 
-    /**
-     * Get the namespace from the context
-     * @param context : the vertx routing context
-     */
-    private fun getNamespace(context: RoutingContext): String? = ((context.user() ?: context.session()?.get("tockUser")) as? TockUser)?.namespace
-
     /**
      * Merge namespace and botId on requested [MetricFilter]
      * @param namespace the namespace
diff --git a/bot/admin/server/src/test/kotlin/model/evaluation/EvaluationModelTest.kt b/bot/admin/server/src/test/kotlin/model/evaluation/EvaluationModelTest.kt
new file mode 100644
index 0000000000..bb975ca962
--- /dev/null
+++ b/bot/admin/server/src/test/kotlin/model/evaluation/EvaluationModelTest.kt
@@ -0,0 +1,51 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.model.evaluation
+
+import ai.tock.shared.jackson.mapper
+import com.fasterxml.jackson.module.kotlin.readValue
+import org.junit.jupiter.api.Test
+import kotlin.test.assertEquals
+
+/**
+ * Tests for evaluation model serialization/deserialization.
+ * Vérifie EvaluationDialogsQuery (valeurs par défaut) et structure des réponses.
+ */
+class EvaluationModelTest {
+    @Test
+    fun `EvaluationDialogsQuery deserializes empty JSON with defaults`() {
+        val query: EvaluationDialogsQuery = mapper.readValue("{}")
+        assertEquals(0, query.start)
+        assertEquals(10, query.size)
+    }
+
+    @Test
+    fun `EvaluationDialogsQuery deserializes with explicit values`() {
+        val query: EvaluationDialogsQuery = mapper.readValue("""{"start":10,"size":5}""")
+        assertEquals(10, query.start)
+        assertEquals(5, query.size)
+    }
+
+    @Test
+    fun `EvaluationDialogsQuery serializes to JSON`() {
+        val query = EvaluationDialogsQuery(start = 0, size = 20)
+        val json = mapper.writeValueAsString(query)
+        val back: EvaluationDialogsQuery = mapper.readValue(json)
+        assertEquals(query.start, back.start)
+        assertEquals(query.size, back.size)
+    }
+}
diff --git a/bot/admin/server/src/test/kotlin/service/EvaluationServiceTest.kt b/bot/admin/server/src/test/kotlin/service/EvaluationServiceTest.kt
new file mode 100644
index 0000000000..aaf53dac20
--- /dev/null
+++ b/bot/admin/server/src/test/kotlin/service/EvaluationServiceTest.kt
@@ -0,0 +1,1282 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.service
+
+import ai.tock.bot.admin.AbstractTest
+import ai.tock.bot.admin.dialog.ActionReport
+import ai.tock.bot.admin.dialog.DialogReport
+import ai.tock.bot.admin.dialog.DialogReportDAO
+import ai.tock.bot.admin.dialog.DialogReportQuery
+import ai.tock.bot.admin.dialog.DialogReportQueryResult
+import ai.tock.bot.admin.evaluation.ActionRef
+import ai.tock.bot.admin.evaluation.Evaluation
+import ai.tock.bot.admin.evaluation.EvaluationDAO
+import ai.tock.bot.admin.evaluation.EvaluationReason
+import ai.tock.bot.admin.evaluation.EvaluationSample
+import ai.tock.bot.admin.evaluation.EvaluationSampleDAO
+import ai.tock.bot.admin.evaluation.EvaluationSampleStatus
+import ai.tock.bot.admin.evaluation.EvaluationStatus
+import ai.tock.bot.admin.evaluation.GroupedEvaluations
+import ai.tock.bot.admin.model.evaluation.CreateEvaluationSampleRequest
+import ai.tock.bot.engine.action.Action
+import ai.tock.bot.engine.action.ActionMetadata
+import ai.tock.bot.engine.action.SendAttachment
+import ai.tock.bot.engine.dialog.Dialog
+import ai.tock.bot.engine.message.Attachment
+import ai.tock.bot.engine.message.Choice
+import ai.tock.bot.engine.message.Sentence
+import ai.tock.bot.engine.user.PlayerId
+import ai.tock.bot.engine.user.PlayerType
+import ai.tock.shared.exception.rest.BadRequestException
+import ai.tock.shared.exception.rest.UnprocessableEntityException
+import ai.tock.shared.tockInternalInjector
+import ai.tock.translator.UserInterfaceType
+import com.github.salomonbrys.kodein.Kodein
+import com.github.salomonbrys.kodein.KodeinInjector
+import com.github.salomonbrys.kodein.bind
+import com.github.salomonbrys.kodein.provider
+import io.mockk.clearMocks
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.slot
+import io.mockk.verify
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.junit.jupiter.api.assertThrows
+import org.litote.kmongo.Id
+import org.litote.kmongo.newId
+import org.litote.kmongo.toId
+import java.time.Instant
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class EvaluationServiceTest : AbstractTest() {
+    companion object {
+        private const val NAMESPACE = "testNamespace"
+        private const val BOT_ID = "testBotId"
+        private const val USER = "testUser"
+
+        val evaluationSampleDAO: EvaluationSampleDAO = mockk()
+        val evaluationDAO: EvaluationDAO = mockk()
+        val dialogReportDAO: DialogReportDAO = mockk()
+
+        init {
+            tockInternalInjector = KodeinInjector()
+            val module =
+                Kodein.Module(allowSilentOverride = true) {
+                    bind<EvaluationSampleDAO>() with provider { evaluationSampleDAO }
+                    bind<EvaluationDAO>() with provider { evaluationDAO }
+                    bind<DialogReportDAO>() with provider { dialogReportDAO }
+                }
+            tockInternalInjector.inject(
+                Kodein {
+                    import(defaultModulesBinding())
+                    import(module, allowOverride = true)
+                },
+            )
+        }
+    }
+
+    @BeforeEach
+    fun setup() {
+        clearMocks(evaluationSampleDAO, evaluationDAO, dialogReportDAO)
+    }
+
+    private fun createDialogReport(
+        dialogId: String,
+        botActions: Int = 2,
+    ): DialogReport {
+        val actions = mutableListOf<ActionReport>()
+        for (i in 0 until botActions * 2) {
+            val isBot = i % 2 == 1
+            actions.add(
+                ActionReport(
+                    playerId = PlayerId(if (isBot) BOT_ID else "user", if (isBot) PlayerType.bot else PlayerType.user),
+                    recipientId = PlayerId(if (isBot) "user" else BOT_ID, if (isBot) PlayerType.user else PlayerType.bot),
+                    date = Instant.now(),
+                    message = Sentence(if (isBot) "Bot response $i" else "User message $i"),
+                    connectorType = null,
+                    userInterfaceType = UserInterfaceType.textChat,
+                    intent = null,
+                    applicationId = null,
+                    metadata = ActionMetadata(),
+                ),
+            )
+        }
+        return DialogReport(
+            actions = actions,
+            id = dialogId.toId(),
+            userInterface = UserInterfaceType.textChat,
+        )
+    }
+
+    @Test
+    fun `findSampleById returns DTO when sample exists`() {
+        val sampleId = newId<EvaluationSample>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.countByStatus(sampleId) } returns
+            mapOf(
+                EvaluationStatus.UNSET to 5L,
+                EvaluationStatus.UP to 10L,
+                EvaluationStatus.DOWN to 0L,
+            )
+
+        val result = EvaluationService.findSampleById(sampleId.toString())
+
+        assertNotNull(result)
+        assertEquals(sampleId.toString(), result._id)
+        assertEquals(BOT_ID, result.botId)
+        assertEquals(15, result.evaluationsResult.total)
+    }
+
+    @Test
+    fun `findSampleById returns null when sample not found`() {
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns null
+
+        val result = EvaluationService.findSampleById("507f1f77bcf86cd799439011")
+
+        assertNull(result)
+    }
+
+    @Test
+    fun `findSamplesByBotId returns samples with computed evaluationsResult`() {
+        val sampleId = newId<EvaluationSample>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test Sample",
+                description = null,
+                dialogActivityFrom = Instant.now().minusSeconds(86400),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        every { evaluationSampleDAO.findByNamespaceAndBotId(NAMESPACE, BOT_ID, null) } returns listOf(sample)
+        every { evaluationDAO.countByStatus(sampleId) } returns
+            mapOf(
+                EvaluationStatus.UNSET to 10L,
+                EvaluationStatus.UP to 3L,
+                EvaluationStatus.DOWN to 2L,
+            )
+
+        val result = EvaluationService.findSamplesByBotId(NAMESPACE, BOT_ID)
+
+        assertEquals(1, result.size)
+        val dto = result[0]
+        assertEquals(15, dto.evaluationsResult.total)
+        assertEquals(5, dto.evaluationsResult.evaluated)
+        assertEquals(10, dto.evaluationsResult.remaining)
+        assertEquals(3, dto.evaluationsResult.positiveCount)
+        assertEquals(2, dto.evaluationsResult.negativeCount)
+    }
+
+    @Test
+    fun `createEvaluationSample throws UnprocessableEntityException when no evaluable actions found`() {
+        every { dialogReportDAO.search(any<DialogReportQuery>()) } returns
+            DialogReportQueryResult(
+                total = 0,
+                dialogs = emptyList(),
+            )
+
+        val request =
+            CreateEvaluationSampleRequest(
+                name = "Test Sample",
+                description = null,
+                dialogActivityFrom = Instant.now().minusSeconds(86400),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                allowTestDialogs = false,
+            )
+
+        assertThrows<UnprocessableEntityException> {
+            EvaluationService.createEvaluationSample(NAMESPACE, BOT_ID, request, USER)
+        }
+
+        verify(exactly = 0) { evaluationSampleDAO.save(any()) }
+        verify(exactly = 0) { evaluationDAO.createAll(any()) }
+    }
+
+    @Test
+    fun `createEvaluationSample throws when no evaluable actions in returned dialogs`() {
+        val dialogWithEmptyActions =
+            DialogReport(
+                actions = emptyList(),
+                id = "dialog1".toId(),
+                userInterface = UserInterfaceType.textChat,
+            )
+
+        every { dialogReportDAO.search(any<DialogReportQuery>()) } returns
+            DialogReportQueryResult(
+                total = 1,
+                dialogs = listOf(dialogWithEmptyActions),
+            )
+
+        val request =
+            CreateEvaluationSampleRequest(
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now().minusSeconds(86400),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                allowTestDialogs = false,
+            )
+
+        assertThrows<UnprocessableEntityException> {
+            EvaluationService.createEvaluationSample(NAMESPACE, BOT_ID, request, USER)
+        }
+
+        verify(exactly = 0) { evaluationSampleDAO.save(any()) }
+    }
+
+    @Test
+    fun `createEvaluationSample passes evaluableActionsOnly to dialog query`() {
+        val dialog1 = createDialogReport("dialog1", 2)
+        val dialog2 = createDialogReport("dialog2", 3)
+        val querySlot = slot<DialogReportQuery>()
+        every { dialogReportDAO.search(capture(querySlot)) } returns
+            DialogReportQueryResult(
+                total = 2,
+                dialogs = listOf(dialog1, dialog2),
+            )
+        every { evaluationSampleDAO.save(any()) } answers { firstArg() }
+        every { evaluationDAO.createAll(any()) } returns Unit
+
+        val request =
+            CreateEvaluationSampleRequest(
+                name = "Test Sample",
+                description = null,
+                dialogActivityFrom = Instant.now().minusSeconds(86400),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                allowTestDialogs = false,
+            )
+
+        EvaluationService.createEvaluationSample(NAMESPACE, BOT_ID, request, USER)
+
+        assertTrue(querySlot.captured.evaluableActionsOnly)
+    }
+
+    @Test
+    fun `createEvaluationSample creates sample and evaluations`() {
+        val dialog1 = createDialogReport("dialog1", 2)
+        val dialog2 = createDialogReport("dialog2", 3)
+
+        every { dialogReportDAO.search(any<DialogReportQuery>()) } returns
+            DialogReportQueryResult(
+                total = 2,
+                dialogs = listOf(dialog1, dialog2),
+            )
+
+        val sampleSlot = slot<EvaluationSample>()
+        every { evaluationSampleDAO.save(capture(sampleSlot)) } answers { sampleSlot.captured }
+
+        val evaluationsSlot = slot<List<Evaluation>>()
+        every { evaluationDAO.createAll(capture(evaluationsSlot)) } returns Unit
+
+        val request =
+            CreateEvaluationSampleRequest(
+                name = "Test Sample",
+                description = "Test description",
+                dialogActivityFrom = Instant.now().minusSeconds(86400),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                allowTestDialogs = false,
+            )
+
+        val result = EvaluationService.createEvaluationSample(NAMESPACE, BOT_ID, request, USER)
+
+        assertNotNull(result)
+        assertEquals("Test Sample", result.name)
+        assertEquals(BOT_ID, result.botId)
+        assertEquals(NAMESPACE, result.namespace)
+        assertEquals(2, result.dialogsCount)
+        assertTrue(result.botActionCount > 0)
+        assertEquals(EvaluationSampleStatus.IN_PROGRESS, result.status)
+
+        verify { evaluationSampleDAO.save(any()) }
+        verify { evaluationDAO.createAll(any()) }
+
+        val createdEvaluations = evaluationsSlot.captured
+        assertTrue(createdEvaluations.isNotEmpty())
+        assertTrue(createdEvaluations.all { it.status == EvaluationStatus.UNSET })
+        assertEquals(result.botActionCount.toLong(), createdEvaluations.size.toLong())
+    }
+
+    @Test
+    fun `createEvaluationSample includes Choice actions`() {
+        val dialogWithChoice =
+            DialogReport(
+                actions =
+                    listOf(
+                        ActionReport(
+                            playerId = PlayerId(BOT_ID, PlayerType.bot),
+                            recipientId = PlayerId("user", PlayerType.user),
+                            date = Instant.now(),
+                            message = Choice("test_intent", emptyMap()),
+                            connectorType = null,
+                            userInterfaceType = UserInterfaceType.textChat,
+                            intent = null,
+                            applicationId = null,
+                            metadata = ActionMetadata(),
+                        ),
+                    ),
+                id = "dialog1".toId(),
+                userInterface = UserInterfaceType.textChat,
+            )
+
+        every { dialogReportDAO.search(any<DialogReportQuery>()) } returns
+            DialogReportQueryResult(
+                total = 1,
+                dialogs = listOf(dialogWithChoice),
+            )
+        every { evaluationSampleDAO.save(any()) } answers { firstArg() }
+        every { evaluationDAO.createAll(any()) } returns Unit
+
+        val request =
+            CreateEvaluationSampleRequest(
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now().minusSeconds(86400),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                allowTestDialogs = false,
+            )
+
+        val result = EvaluationService.createEvaluationSample(NAMESPACE, BOT_ID, request, USER)
+
+        assertNotNull(result)
+        assertEquals(1, result.botActionCount)
+        assertEquals(1, result.dialogsCount)
+    }
+
+    @Test
+    fun `createEvaluationSample includes Attachment and Location actions`() {
+        val dialogWithAttachment =
+            DialogReport(
+                actions =
+                    listOf(
+                        ActionReport(
+                            playerId = PlayerId(BOT_ID, PlayerType.bot),
+                            recipientId = PlayerId("user", PlayerType.user),
+                            date = Instant.now(),
+                            message = Attachment("https://example.com/file.pdf", SendAttachment.AttachmentType.file),
+                            connectorType = null,
+                            userInterfaceType = UserInterfaceType.textChat,
+                            intent = null,
+                            applicationId = null,
+                            metadata = ActionMetadata(),
+                        ),
+                    ),
+                id = "dialog1".toId(),
+                userInterface = UserInterfaceType.textChat,
+            )
+
+        every { dialogReportDAO.search(any<DialogReportQuery>()) } returns
+            DialogReportQueryResult(
+                total = 1,
+                dialogs = listOf(dialogWithAttachment),
+            )
+        every { evaluationSampleDAO.save(any()) } answers { firstArg() }
+        every { evaluationDAO.createAll(any()) } returns Unit
+
+        val request =
+            CreateEvaluationSampleRequest(
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now().minusSeconds(86400),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                allowTestDialogs = false,
+            )
+
+        val result = EvaluationService.createEvaluationSample(NAMESPACE, BOT_ID, request, USER)
+
+        assertNotNull(result)
+        assertEquals(1, result.botActionCount)
+    }
+
+    @Test
+    fun `evaluate updates evaluation with UP status`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluationId = newId<Evaluation>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = listOf(ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>())),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        val evaluation =
+            Evaluation(
+                _id = evaluationId,
+                evaluationSampleId = sampleId,
+                dialogId = "dialog1".toId(),
+                actionId = "action1".toId(),
+                status = EvaluationStatus.UNSET,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.findById(any<Id<Evaluation>>()) } returns evaluation
+        every { evaluationDAO.update(any()) } answers { firstArg() }
+
+        val result =
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = evaluationId.toString(),
+                status = EvaluationStatus.UP,
+                reason = null,
+                evaluatorId = USER,
+            )
+
+        assertNotNull(result)
+        assertEquals(EvaluationStatus.UP, result.status)
+        assertNull(result.reason)
+        assertNotNull(result.evaluator)
+        assertEquals(USER, result.evaluator?.id)
+    }
+
+    @Test
+    fun `evaluate updates evaluation with DOWN status and reason`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluationId = newId<Evaluation>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = listOf(ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>())),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        val evaluation =
+            Evaluation(
+                _id = evaluationId,
+                evaluationSampleId = sampleId,
+                dialogId = "dialog1".toId(),
+                actionId = "action1".toId(),
+                status = EvaluationStatus.UNSET,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.findById(any<Id<Evaluation>>()) } returns evaluation
+        every { evaluationDAO.update(any()) } answers { firstArg() }
+
+        val result =
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = evaluationId.toString(),
+                status = EvaluationStatus.DOWN,
+                reason = EvaluationReason.HALLUCINATION,
+                evaluatorId = USER,
+            )
+
+        assertNotNull(result)
+        assertEquals(EvaluationStatus.DOWN, result.status)
+        assertEquals(EvaluationReason.HALLUCINATION, result.reason)
+    }
+
+    @Test
+    fun `evaluate throws when DOWN without reason`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluationId = newId<Evaluation>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = listOf(ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>())),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        val evaluation =
+            Evaluation(
+                _id = evaluationId,
+                evaluationSampleId = sampleId,
+                dialogId = "dialog1".toId(),
+                actionId = "action1".toId(),
+                status = EvaluationStatus.UNSET,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.findById(any<Id<Evaluation>>()) } returns evaluation
+
+        assertThrows<BadRequestException> {
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = evaluationId.toString(),
+                status = EvaluationStatus.DOWN,
+                reason = null,
+                evaluatorId = USER,
+            )
+        }
+
+        verify(exactly = 0) { evaluationDAO.update(any()) }
+    }
+
+    @Test
+    fun `evaluate throws when evaluation does not belong to sample`() {
+        val sampleId = newId<EvaluationSample>()
+        val otherSampleId = newId<EvaluationSample>()
+        val evaluationId = newId<Evaluation>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = listOf(ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>())),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+        val evaluation =
+            Evaluation(
+                _id = evaluationId,
+                evaluationSampleId = otherSampleId,
+                dialogId = "dialog1".toId(),
+                actionId = "action1".toId(),
+                status = EvaluationStatus.UNSET,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.findById(any<Id<Evaluation>>()) } returns evaluation
+
+        assertThrows<BadRequestException> {
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = evaluationId.toString(),
+                status = EvaluationStatus.UP,
+                reason = null,
+                evaluatorId = USER,
+            )
+        }
+        verify(exactly = 0) { evaluationDAO.update(any()) }
+    }
+
+    @Test
+    fun `evaluate throws when evaluation not found`() {
+        val sampleId = newId<EvaluationSample>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = listOf(ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>())),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.findById(any<Id<Evaluation>>()) } returns null
+
+        assertThrows<BadRequestException> {
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = "507f1f77bcf86cd799439012",
+                status = EvaluationStatus.UP,
+                reason = null,
+                evaluatorId = USER,
+            )
+        }
+    }
+
+    @Test
+    fun `evaluate throws when status is UNSET`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluationId = newId<Evaluation>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = listOf(ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>())),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+        val evaluation =
+            Evaluation(
+                _id = evaluationId,
+                evaluationSampleId = sampleId,
+                dialogId = "dialog1".toId(),
+                actionId = "action1".toId(),
+                status = EvaluationStatus.UNSET,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.findById(any<Id<Evaluation>>()) } returns evaluation
+
+        assertThrows<BadRequestException> {
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = evaluationId.toString(),
+                status = EvaluationStatus.UNSET,
+                reason = null,
+                evaluatorId = USER,
+            )
+        }
+        verify(exactly = 0) { evaluationDAO.update(any()) }
+    }
+
+    @Test
+    fun `evaluate throws when UP with reason`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluationId = newId<Evaluation>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = listOf(ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>())),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+        val evaluation =
+            Evaluation(
+                _id = evaluationId,
+                evaluationSampleId = sampleId,
+                dialogId = "dialog1".toId(),
+                actionId = "action1".toId(),
+                status = EvaluationStatus.UNSET,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.findById(any<Id<Evaluation>>()) } returns evaluation
+
+        assertThrows<BadRequestException> {
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = evaluationId.toString(),
+                status = EvaluationStatus.UP,
+                reason = EvaluationReason.HALLUCINATION,
+                evaluatorId = USER,
+            )
+        }
+        verify(exactly = 0) { evaluationDAO.update(any()) }
+    }
+
+    @Test
+    fun `evaluate throws when sample is VALIDATED`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluationId = newId<Evaluation>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.VALIDATED,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+
+        assertThrows<BadRequestException> {
+            EvaluationService.evaluate(
+                sampleId = sampleId.toString(),
+                evaluationId = evaluationId.toString(),
+                status = EvaluationStatus.UP,
+                reason = null,
+                evaluatorId = USER,
+            )
+        }
+    }
+
+    @Test
+    fun `changeStatus throws when sample not found`() {
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns null
+
+        assertThrows<BadRequestException> {
+            EvaluationService.changeStatus(
+                sampleId = "507f1f77bcf86cd799439011",
+                targetStatus = EvaluationSampleStatus.VALIDATED,
+                changedBy = USER,
+                comment = null,
+            )
+        }
+    }
+
+    @Test
+    fun `changeStatus throws when sample is not IN_PROGRESS`() {
+        val sampleId = newId<EvaluationSample>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.VALIDATED,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+
+        assertThrows<BadRequestException> {
+            EvaluationService.changeStatus(
+                sampleId = sampleId.toString(),
+                targetStatus = EvaluationSampleStatus.CANCELLED,
+                changedBy = USER,
+                comment = null,
+            )
+        }
+        verify(exactly = 0) { evaluationSampleDAO.updateStatus(any(), any(), any(), any()) }
+    }
+
+    @Test
+    fun `changeStatus throws when target status is IN_PROGRESS`() {
+        val sampleId = newId<EvaluationSample>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+
+        assertThrows<BadRequestException> {
+            EvaluationService.changeStatus(
+                sampleId = sampleId.toString(),
+                targetStatus = EvaluationSampleStatus.IN_PROGRESS,
+                changedBy = USER,
+                comment = null,
+            )
+        }
+        verify(exactly = 0) { evaluationSampleDAO.updateStatus(any(), any(), any(), any()) }
+    }
+
+    @Test
+    fun `changeStatus validates sample when all evaluations are done`() {
+        val sampleId = newId<EvaluationSample>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        val updatedSample = sample.copy(status = EvaluationSampleStatus.VALIDATED)
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationDAO.countByStatus(any<Id<EvaluationSample>>()) } returns
+            mapOf(
+                EvaluationStatus.UNSET to 0L,
+                EvaluationStatus.UP to 10L,
+                EvaluationStatus.DOWN to 5L,
+            )
+        every { evaluationSampleDAO.updateStatus(any(), any(), any(), any()) } returns updatedSample
+
+        val result =
+            EvaluationService.changeStatus(
+                sampleId = sampleId.toString(),
+                targetStatus = EvaluationSampleStatus.VALIDATED,
+                changedBy = USER,
+                comment = "Validation complete",
+            )
+
+        assertNotNull(result)
+        assertEquals(EvaluationSampleStatus.VALIDATED, result.status)
+    }
+
+    @Test
+    fun `changeStatus allows cancellation`() {
+        val sampleId = newId<EvaluationSample>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 5,
+                totalDialogCount = 100,
+                botActionCount = 15,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        val updatedSample = sample.copy(status = EvaluationSampleStatus.CANCELLED)
+
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns sample
+        every { evaluationSampleDAO.updateStatus(any(), any(), any(), any()) } returns updatedSample
+        every { evaluationDAO.countByStatus(any<Id<EvaluationSample>>()) } returns
+            mapOf(
+                EvaluationStatus.UNSET to 5L,
+                EvaluationStatus.UP to 10L,
+                EvaluationStatus.DOWN to 0L,
+            )
+
+        val result =
+            EvaluationService.changeStatus(
+                sampleId = sampleId.toString(),
+                targetStatus = EvaluationSampleStatus.CANCELLED,
+                changedBy = USER,
+                comment = "Cancelled",
+            )
+
+        assertNotNull(result)
+        assertEquals(EvaluationSampleStatus.CANCELLED, result.status)
+    }
+
+    @Test
+    fun `getEvaluationDialogs returns paginated dialogs with action refs`() {
+        val sampleId = newId<EvaluationSample>()
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 3,
+                totalDialogCount = 100,
+                botActionCount = 6,
+                allowTestDialogs = false,
+                actionRefs =
+                    listOf(
+                        ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>()),
+                        ActionRef("dialog1".toId<Dialog>(), "action2".toId<Action>()),
+                        ActionRef("dialog2".toId<Dialog>(), "action3".toId<Action>()),
+                        ActionRef("dialog2".toId<Dialog>(), "action4".toId<Action>()),
+                        ActionRef("dialog3".toId<Dialog>(), "action5".toId<Action>()),
+                        ActionRef("dialog3".toId<Dialog>(), "action6".toId<Action>()),
+                    ),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        val evaluationsDialog1 =
+            listOf(
+                Evaluation(
+                    _id = newId<Evaluation>(),
+                    evaluationSampleId = sampleId,
+                    dialogId = "dialog1".toId(),
+                    actionId = "action1".toId(),
+                    status = EvaluationStatus.UNSET,
+                ),
+                Evaluation(
+                    _id = newId<Evaluation>(),
+                    evaluationSampleId = sampleId,
+                    dialogId = "dialog1".toId(),
+                    actionId = "action2".toId(),
+                    status = EvaluationStatus.UNSET,
+                ),
+            )
+
+        val evaluationsDialog2 =
+            listOf(
+                Evaluation(
+                    _id = newId<Evaluation>(),
+                    evaluationSampleId = sampleId,
+                    dialogId = "dialog2".toId(),
+                    actionId = "action3".toId(),
+                    status = EvaluationStatus.UNSET,
+                ),
+                Evaluation(
+                    _id = newId<Evaluation>(),
+                    evaluationSampleId = sampleId,
+                    dialogId = "dialog2".toId(),
+                    actionId = "action4".toId(),
+                    status = EvaluationStatus.UNSET,
+                ),
+            )
+
+        val dialogs =
+            setOf(
+                createDialogReport("dialog1", 2),
+                createDialogReport("dialog2", 2),
+            )
+
+        every { evaluationSampleDAO.findById(any()) } returns sample
+
+        every {
+            evaluationDAO.findGroupedEvaluationsBySampleId(
+                sampleId = sampleId,
+                start = 0,
+                size = 2,
+            )
+        } returns
+            listOf(
+                GroupedEvaluations("dialog1".toId(), evaluationsDialog1),
+                GroupedEvaluations("dialog2".toId(), evaluationsDialog2),
+            )
+
+        every {
+            dialogReportDAO.findByDialogByIds(setOf("dialog1".toId(), "dialog2".toId()))
+        } returns dialogs
+
+        val result =
+            EvaluationService.getEvaluationDialogs(
+                sampleId = sampleId.toString(),
+                start = 0,
+                size = 2,
+            )
+
+        assertEquals(0, result.start)
+        assertEquals(4, result.size) // 4 actions au total dans la page
+        assertEquals(3L, result.total) // sample.dialogsCount
+        assertEquals(4, result.actionRefs.size)
+        assertEquals(2, result.dialogs.size)
+
+        // Vérifie l’ordre et les valeurs
+        assertEquals("dialog1", result.dialogs[0].dialogId)
+        assertNotNull(result.dialogs[0].dialog)
+
+        assertEquals("dialog2", result.dialogs[1].dialogId)
+        assertNotNull(result.dialogs[1].dialog)
+    }
+
+    @Test
+    fun `getEvaluationDialogs throws when sample not found`() {
+        every { evaluationSampleDAO.findById(any<Id<EvaluationSample>>()) } returns null
+
+        assertThrows<BadRequestException> {
+            EvaluationService.getEvaluationDialogs(
+                sampleId = "507f1f77bcf86cd799439011",
+                start = 0,
+                size = 10,
+            )
+        }
+    }
+
+    @Test
+    fun `getEvaluationDialogs returns empty when sample has no action refs`() {
+        val sampleId = newId<EvaluationSample>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 0,
+                totalDialogCount = 100,
+                botActionCount = 0,
+                allowTestDialogs = false,
+                actionRefs = emptyList(),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        every { evaluationSampleDAO.findById(any()) } returns sample
+
+        every {
+            evaluationDAO.findGroupedEvaluationsBySampleId(
+                sampleId = sampleId,
+                start = 0,
+                size = 10,
+            )
+        } returns emptyList()
+
+        every {
+            dialogReportDAO.findByDialogByIds(any())
+        } returns emptySet()
+
+        val result =
+            EvaluationService.getEvaluationDialogs(
+                sampleId = sampleId.toString(),
+                start = 0,
+                size = 10,
+            )
+
+        assertEquals(0, result.start)
+        assertEquals(0, result.size)
+        assertEquals(0L, result.total)
+        assertEquals(0, result.end)
+        assertTrue(result.actionRefs.isEmpty())
+        assertTrue(result.dialogs.isEmpty())
+    }
+
+    @Test
+    fun `getEvaluationDialogs includes missing dialogs when some dialogs are not found`() {
+        val sampleId = newId<EvaluationSample>()
+
+        val sample =
+            EvaluationSample(
+                _id = sampleId,
+                botId = BOT_ID,
+                namespace = NAMESPACE,
+                name = "Test",
+                description = null,
+                dialogActivityFrom = Instant.now(),
+                dialogActivityTo = Instant.now(),
+                requestedDialogCount = 10,
+                dialogsCount = 2,
+                totalDialogCount = 100,
+                botActionCount = 2,
+                allowTestDialogs = false,
+                actionRefs =
+                    listOf(
+                        ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>()),
+                        ActionRef("dialog2".toId<Dialog>(), "action2".toId<Action>()),
+                    ),
+                status = EvaluationSampleStatus.IN_PROGRESS,
+                createdBy = USER,
+                statusChangedBy = USER,
+            )
+
+        val evaluationsDialog1 =
+            listOf(
+                Evaluation(
+                    _id = newId(),
+                    evaluationSampleId = sampleId,
+                    dialogId = "dialog1".toId(),
+                    actionId = "action1".toId(),
+                    status = EvaluationStatus.UNSET,
+                ),
+            )
+
+        val evaluationsDialog2 =
+            listOf(
+                Evaluation(
+                    _id = newId(),
+                    evaluationSampleId = sampleId,
+                    dialogId = "dialog2".toId(),
+                    actionId = "action2".toId(),
+                    status = EvaluationStatus.UNSET,
+                ),
+            )
+
+        every { evaluationSampleDAO.findById(any()) } returns sample
+
+        every {
+            evaluationDAO.findGroupedEvaluationsBySampleId(
+                sampleId = sampleId,
+                start = 0,
+                size = 10,
+            )
+        } returns
+            listOf(
+                GroupedEvaluations("dialog1".toId(), evaluationsDialog1),
+                GroupedEvaluations("dialog2".toId(), evaluationsDialog2),
+            )
+
+        // 👉 On retourne seulement dialog1, dialog2 sera missing
+        every {
+            dialogReportDAO.findByDialogByIds(setOf("dialog1".toId(), "dialog2".toId()))
+        } returns setOf(createDialogReport("dialog1", 1))
+
+        val result =
+            EvaluationService.getEvaluationDialogs(
+                sampleId = sampleId.toString(),
+                start = 0,
+                size = 10,
+            )
+
+        // ✅ 2 dialogues paginés
+        assertEquals(2, result.dialogs.size)
+
+        // ✅ dialog1 trouvé
+        assertNotNull(result.dialogs[0].dialog)
+
+        // ✅ dialog2 missing
+        assertNull(result.dialogs[1].dialog)
+
+        // ✅ start correct
+        assertEquals(0, result.start)
+
+        // ⚠️ si tu corriges ton service en inclusif :
+        // end = start + size - 1
+        // ici 0 + 2 - 1 = 1
+        assertEquals(2, result.end)
+    }
+
+    @Test
+    fun `deleteSample deletes evaluations and sample`() {
+        val sampleId = "507f1f77bcf86cd799439011"
+
+        every { evaluationDAO.deleteByEvaluationSampleId(any()) } returns 10L
+        every { evaluationSampleDAO.delete(any()) } returns true
+
+        val result = EvaluationService.deleteSample(sampleId)
+
+        assertTrue(result)
+        verify { evaluationDAO.deleteByEvaluationSampleId(any()) }
+        verify { evaluationSampleDAO.delete(any()) }
+    }
+}
diff --git a/bot/engine/src/main/kotlin/admin/dialog/DialogReportDAO.kt b/bot/engine/src/main/kotlin/admin/dialog/DialogReportDAO.kt
index 73ff7df89a..5b21ad852d 100644
--- a/bot/engine/src/main/kotlin/admin/dialog/DialogReportDAO.kt
+++ b/bot/engine/src/main/kotlin/admin/dialog/DialogReportDAO.kt
@@ -39,6 +39,8 @@ interface DialogReportDAO {
 
     fun getDialog(id: Id<Dialog>): DialogReport?
 
+    fun findByDialogByIds(ids: Set<Id<Dialog>>): Set<DialogReport>
+
     fun getNlpStats(
         dialogIds: List<Id<Dialog>>,
         namespace: String,
diff --git a/bot/engine/src/main/kotlin/admin/dialog/DialogReportQuery.kt b/bot/engine/src/main/kotlin/admin/dialog/DialogReportQuery.kt
index 29b654e174..fd5727ab8d 100644
--- a/bot/engine/src/main/kotlin/admin/dialog/DialogReportQuery.kt
+++ b/bot/engine/src/main/kotlin/admin/dialog/DialogReportQuery.kt
@@ -37,6 +37,10 @@ data class DialogReportQuery(
     val playerId: PlayerId? = null,
     val text: String? = null,
     val dialogId: String? = null,
+    /**
+     * When non-empty, filter dialogs by these IDs (fetches multiple dialogs by ID).
+     */
+    val dialogIds: Set<String>? = null,
     val intentName: String? = null,
     val exactMatch: Boolean = false,
     val connectorType: ConnectorType? = null,
@@ -77,4 +81,14 @@ data class DialogReportQuery(
      */
     val dialogActivityFrom: ZonedDateTime? = null,
     val dialogActivityTo: ZonedDateTime? = null,
+    /**
+     * Use random sampling instead of pagination.
+     * When true, uses MongoDB $sample to randomly select documents.
+     */
+    val random: Boolean = false,
+    /**
+     * When true, only returns dialogs that contain at least one evaluable bot action
+     * (Sentence or SentenceWithFootnotes with non-empty text, excluding DebugMessage).
+     */
+    val evaluableActionsOnly: Boolean = false,
 )
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/ActionRef.kt b/bot/engine/src/main/kotlin/admin/evaluation/ActionRef.kt
new file mode 100644
index 0000000000..55951add77
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/ActionRef.kt
@@ -0,0 +1,29 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+import ai.tock.bot.engine.action.Action
+import ai.tock.bot.engine.dialog.Dialog
+import org.litote.kmongo.Id
+
+/**
+ * Reference to a bot action within a dialog, used for evaluation.
+ */
+data class ActionRef(
+    val dialogId: Id<Dialog>,
+    val actionId: Id<Action>,
+)
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/Evaluation.kt b/bot/engine/src/main/kotlin/admin/evaluation/Evaluation.kt
new file mode 100644
index 0000000000..e12dfac549
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/Evaluation.kt
@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+import ai.tock.bot.engine.action.Action
+import ai.tock.bot.engine.dialog.Dialog
+import org.litote.kmongo.Id
+import org.litote.kmongo.newId
+import java.time.Instant
+
+/**
+ * An individual evaluation of a bot action.
+ * Created with status UNSET when the evaluation sample is created.
+ */
+data class Evaluation(
+    val _id: Id<Evaluation> = newId(),
+    val evaluationSampleId: Id<EvaluationSample>,
+    val dialogId: Id<Dialog>,
+    val actionId: Id<Action>,
+    val status: EvaluationStatus = EvaluationStatus.UNSET,
+    val reason: EvaluationReason? = null,
+    val evaluator: Evaluator? = null,
+    val evaluationDate: Instant? = null,
+    val creationDate: Instant = Instant.now(),
+    val lastUpdateDate: Instant = Instant.now(),
+)
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/EvaluationDAO.kt b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationDAO.kt
new file mode 100644
index 0000000000..222cf7130e
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationDAO.kt
@@ -0,0 +1,69 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+import ai.tock.bot.engine.dialog.Dialog
+import org.litote.kmongo.Id
+
+/**
+ * Result of a paginated, grouped query for evaluations by dialog.
+ *
+ * @property _id The dialog id used as group key.
+ * @property evaluations The evaluations for this dialog (order depends on DAO implementation).
+ */
+data class GroupedEvaluations(
+    val _id: Id<Dialog>,
+    val evaluations: List<Evaluation>,
+)
+
+/**
+ * DAO for individual evaluations.
+ */
+interface EvaluationDAO {
+    fun createAll(evaluations: List<Evaluation>)
+
+    fun findByEvaluationSampleId(
+        sampleId: Id<EvaluationSample>,
+        start: Int = 0,
+        size: Int = 20,
+    ): List<Evaluation>
+
+    fun findByEvaluationSampleIdAndDialogIds(
+        sampleId: Id<EvaluationSample>,
+        dialogIds: List<Id<Dialog>>,
+    ): List<Evaluation>
+
+    /**
+     * Returns evaluations grouped by dialog id for a given sample, paginated.
+     * Groups are sorted by dialog id (ascending) for stable pagination.
+     */
+    fun findGroupedEvaluationsBySampleId(
+        sampleId: Id<EvaluationSample>,
+        start: Int = 0,
+        size: Int = 20,
+    ): List<GroupedEvaluations>
+
+    fun countByEvaluationSampleId(sampleId: Id<EvaluationSample>): Long
+
+    fun findById(id: Id<Evaluation>): Evaluation?
+
+    fun update(evaluation: Evaluation): Evaluation?
+
+    fun countByStatus(sampleId: Id<EvaluationSample>): Map<EvaluationStatus, Long>
+
+    fun deleteByEvaluationSampleId(sampleId: Id<EvaluationSample>): Long
+}
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/EvaluationReason.kt b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationReason.kt
new file mode 100644
index 0000000000..0026dafee2
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationReason.kt
@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+/**
+ * Reasons for a negative (DOWN) evaluation.
+ * Reuses the same values as BotAnnotationReasonType for consistency.
+ */
+enum class EvaluationReason {
+    INACCURATE_ANSWER,
+    INCOMPLETE_ANSWER,
+    HALLUCINATION,
+    INCOMPLETE_SOURCES,
+    OBSOLETE_SOURCES,
+    WRONG_ANSWER_FORMAT,
+    BUSINESS_LEXICON_PROBLEM,
+    QUESTION_MISUNDERSTOOD,
+    OTHER,
+}
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSample.kt b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSample.kt
new file mode 100644
index 0000000000..63ea0a3cdb
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSample.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+import org.litote.kmongo.Id
+import org.litote.kmongo.newId
+import java.time.Instant
+
+/**
+ * An evaluation sample containing a set of bot actions to evaluate.
+ */
+data class EvaluationSample(
+    val _id: Id<EvaluationSample> = newId(),
+    val botId: String,
+    val namespace: String,
+    val name: String?,
+    val description: String?,
+    val dialogActivityFrom: Instant,
+    val dialogActivityTo: Instant,
+    val requestedDialogCount: Int,
+    val dialogsCount: Int,
+    val totalDialogCount: Int,
+    val botActionCount: Int,
+    val allowTestDialogs: Boolean,
+    val actionRefs: List<ActionRef>,
+    val status: EvaluationSampleStatus = EvaluationSampleStatus.IN_PROGRESS,
+    val createdBy: String,
+    val creationDate: Instant = Instant.now(),
+    val statusChangedBy: String,
+    val statusChangeDate: Instant = Instant.now(),
+    val statusComment: String? = null,
+    val lastUpdateDate: Instant = Instant.now(),
+)
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleDAO.kt b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleDAO.kt
new file mode 100644
index 0000000000..58323b6cc0
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleDAO.kt
@@ -0,0 +1,52 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+import org.litote.kmongo.Id
+
+/**
+ * DAO for evaluation samples.
+ */
+interface EvaluationSampleDAO {
+    fun findByNamespaceAndBotId(
+        namespace: String,
+        botId: String,
+        status: EvaluationSampleStatus? = null,
+    ): List<EvaluationSample>
+
+    fun findById(id: Id<EvaluationSample>): EvaluationSample?
+
+    fun save(sample: EvaluationSample): EvaluationSample
+
+    fun updateStatus(
+        id: Id<EvaluationSample>,
+        status: EvaluationSampleStatus,
+        changedBy: String,
+        comment: String?,
+    ): EvaluationSample?
+
+    fun delete(id: Id<EvaluationSample>): Boolean
+
+    /**
+     * Delete all evaluation samples and their evaluations for a bot.
+     * @return the number of deleted samples
+     */
+    fun deleteByNamespaceAndBotId(
+        namespace: String,
+        botId: String,
+    ): Long
+}
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleStatus.kt b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleStatus.kt
new file mode 100644
index 0000000000..d74ea06a36
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationSampleStatus.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+/**
+ * Status of an evaluation sample.
+ */
+enum class EvaluationSampleStatus {
+    IN_PROGRESS,
+    VALIDATED,
+    CANCELLED,
+}
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/EvaluationStatus.kt b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationStatus.kt
new file mode 100644
index 0000000000..51bfc42c77
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationStatus.kt
@@ -0,0 +1,26 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+/**
+ * Status of an individual evaluation.
+ */
+enum class EvaluationStatus {
+    UNSET,
+    UP,
+    DOWN,
+}
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/EvaluationsResult.kt b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationsResult.kt
new file mode 100644
index 0000000000..af60fe4297
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/EvaluationsResult.kt
@@ -0,0 +1,47 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+/**
+ * Computed evaluation statistics for an evaluation sample.
+ * This is calculated on-the-fly and not persisted in the database.
+ */
+data class EvaluationsResult(
+    val total: Int,
+    val evaluated: Int,
+    val remaining: Int,
+    val positiveCount: Int,
+    val negativeCount: Int,
+) {
+    companion object {
+        fun fromStatusCounts(counts: Map<EvaluationStatus, Long>): EvaluationsResult {
+            val unsetCount = counts[EvaluationStatus.UNSET] ?: 0L
+            val upCount = counts[EvaluationStatus.UP] ?: 0L
+            val downCount = counts[EvaluationStatus.DOWN] ?: 0L
+            val total = (unsetCount + upCount + downCount).toInt()
+            val evaluated = (upCount + downCount).toInt()
+
+            return EvaluationsResult(
+                total = total,
+                evaluated = evaluated,
+                remaining = unsetCount.toInt(),
+                positiveCount = upCount.toInt(),
+                negativeCount = downCount.toInt(),
+            )
+        }
+    }
+}
diff --git a/bot/engine/src/main/kotlin/admin/evaluation/Evaluator.kt b/bot/engine/src/main/kotlin/admin/evaluation/Evaluator.kt
new file mode 100644
index 0000000000..be61ff7594
--- /dev/null
+++ b/bot/engine/src/main/kotlin/admin/evaluation/Evaluator.kt
@@ -0,0 +1,25 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.admin.evaluation
+
+/**
+ * Represents the evaluator who performed an evaluation.
+ * The evaluator is detected automatically from the user context.
+ */
+data class Evaluator(
+    val id: String,
+)
diff --git a/bot/storage-mongo/src/main/kotlin/DialogCol.kt b/bot/storage-mongo/src/main/kotlin/DialogCol.kt
index d34e761c78..c4c5d5d2e5 100644
--- a/bot/storage-mongo/src/main/kotlin/DialogCol.kt
+++ b/bot/storage-mongo/src/main/kotlin/DialogCol.kt
@@ -38,6 +38,7 @@ import ai.tock.bot.engine.dialog.EventState
 import ai.tock.bot.engine.dialog.NextUserActionState
 import ai.tock.bot.engine.dialog.Story
 import ai.tock.bot.engine.user.PlayerId
+import ai.tock.bot.engine.user.PlayerType
 import ai.tock.bot.engine.user.UserLocation
 import ai.tock.shared.checkMaxLengthAllowed
 import ai.tock.shared.jackson.AnyValueWrapper
@@ -117,12 +118,15 @@ internal data class DialogCol(
         }
     }
 
-    fun toDialogReport(): DialogReport {
-        return DialogReport(
+    fun toDialogReport(evaluableActionsOnly: Boolean = false): DialogReport {
+        val actions =
             stories
                 .flatMap { it.actions }
                 .asSequence()
                 .distinctBy { it.id }
+                .let { seq ->
+                    if (evaluableActionsOnly) seq.filter { it.isEvaluable() } else seq
+                }
                 .map { it.toAction(_id) }
                 .toList()
                 .run {
@@ -163,7 +167,9 @@ internal data class DialogCol(
                         )
                     }
                 }
-                .toList(),
+                .toList()
+        return DialogReport(
+            actions,
             stories
                 .flatMap { it.actions }
                 .firstOrNull { it.state.userInterface != null }
@@ -286,6 +292,16 @@ internal data class DialogCol(
         }
 
         abstract fun toAction(dialogId: Id<Dialog>): Action
+
+        fun isEvaluable(): Boolean {
+            if (playerId.type != PlayerType.bot) return false
+            return when (this) {
+                is SendDebugMongoWrapper -> false
+                is SendSentenceMongoWrapper -> !text.isNullOrBlank()
+                is SendSentenceWithFootnotesMongoWrapper -> text.isNotBlank()
+                else -> true
+            }
+        }
     }
 
     @JsonTypeName(value = "sentence")
diff --git a/bot/storage-mongo/src/main/kotlin/EvaluationMongoDAO.kt b/bot/storage-mongo/src/main/kotlin/EvaluationMongoDAO.kt
new file mode 100644
index 0000000000..50152683b3
--- /dev/null
+++ b/bot/storage-mongo/src/main/kotlin/EvaluationMongoDAO.kt
@@ -0,0 +1,146 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.mongo
+
+import ai.tock.bot.admin.evaluation.Evaluation
+import ai.tock.bot.admin.evaluation.EvaluationDAO
+import ai.tock.bot.admin.evaluation.EvaluationSample
+import ai.tock.bot.admin.evaluation.EvaluationStatus
+import ai.tock.bot.admin.evaluation.GroupedEvaluations
+import ai.tock.bot.engine.dialog.Dialog
+import ai.tock.shared.ensureIndex
+import ai.tock.shared.ensureUniqueIndex
+import com.mongodb.client.model.Accumulators.push
+import mu.KotlinLogging
+import org.litote.kmongo.Id
+import org.litote.kmongo.aggregate
+import org.litote.kmongo.and
+import org.litote.kmongo.ascending
+import org.litote.kmongo.descending
+import org.litote.kmongo.eq
+import org.litote.kmongo.findOneById
+import org.litote.kmongo.getCollection
+import org.litote.kmongo.group
+import org.litote.kmongo.`in`
+import org.litote.kmongo.limit
+import org.litote.kmongo.match
+import org.litote.kmongo.save
+import org.litote.kmongo.skip
+import org.litote.kmongo.sort
+import org.litote.kmongo.sum
+
+private val logger = KotlinLogging.logger {}
+
+internal object EvaluationMongoDAO : EvaluationDAO {
+    internal val col = MongoBotConfiguration.database.getCollection<Evaluation>("evaluation")
+
+    init {
+        try {
+            col.ensureIndex(Evaluation::evaluationSampleId)
+            col.ensureUniqueIndex(
+                Evaluation::evaluationSampleId,
+                Evaluation::dialogId,
+                Evaluation::actionId,
+            )
+            col.ensureIndex(Evaluation::status)
+            col.ensureIndex(descending(Evaluation::creationDate))
+        } catch (e: Exception) {
+            logger.error(e) { "Error creating indexes for evaluation collection" }
+        }
+    }
+
+    override fun createAll(evaluations: List<Evaluation>) {
+        if (evaluations.isNotEmpty()) {
+            col.insertMany(evaluations)
+        }
+    }
+
+    override fun findByEvaluationSampleId(
+        sampleId: Id<EvaluationSample>,
+        start: Int,
+        size: Int,
+    ): List<Evaluation> {
+        return col.find(Evaluation::evaluationSampleId eq sampleId)
+            .skip(start)
+            .limit(size)
+            .sort(descending(Evaluation::creationDate))
+            .toList()
+    }
+
+    override fun findByEvaluationSampleIdAndDialogIds(
+        sampleId: Id<EvaluationSample>,
+        dialogIds: List<Id<Dialog>>,
+    ): List<Evaluation> {
+        if (dialogIds.isEmpty()) return emptyList()
+        return col.find(
+            and(
+                Evaluation::evaluationSampleId eq sampleId,
+                Evaluation::dialogId `in` dialogIds,
+            ),
+        ).toList()
+    }
+
+    override fun findGroupedEvaluationsBySampleId(
+        sampleId: Id<EvaluationSample>,
+        start: Int,
+        size: Int,
+    ): List<GroupedEvaluations> {
+        if (size <= 0) return emptyList()
+
+        return col.aggregate<GroupedEvaluations>(
+            match(Evaluation::evaluationSampleId eq sampleId),
+            // Ensures stable ordering inside each grouped array.
+            sort(ascending(Evaluation::dialogId, Evaluation::actionId)),
+            group(Evaluation::dialogId, push("evaluations", "\$\$ROOT")),
+            // Stable pagination by dialogId.
+            sort(ascending(GroupedEvaluations::_id)),
+            skip(start),
+            limit(size),
+        ).toList()
+    }
+
+    override fun countByEvaluationSampleId(sampleId: Id<EvaluationSample>): Long {
+        return col.countDocuments(Evaluation::evaluationSampleId eq sampleId)
+    }
+
+    override fun findById(id: Id<Evaluation>): Evaluation? {
+        return col.findOneById(id)
+    }
+
+    override fun update(evaluation: Evaluation): Evaluation? {
+        col.save(evaluation)
+        return findById(evaluation._id)
+    }
+
+    override fun countByStatus(sampleId: Id<EvaluationSample>): Map<EvaluationStatus, Long> {
+        data class StatusCount(val _id: EvaluationStatus, val count: Long)
+
+        val results =
+            col.aggregate<StatusCount>(
+                match(Evaluation::evaluationSampleId eq sampleId),
+                group(Evaluation::status, StatusCount::count sum 1),
+            ).toList()
+
+        return EvaluationStatus.entries.associateWith { status ->
+            results.find { it._id == status }?.count ?: 0L
+        }
+    }
+
+    override fun deleteByEvaluationSampleId(sampleId: Id<EvaluationSample>): Long {
+        return col.deleteMany(Evaluation::evaluationSampleId eq sampleId).deletedCount
+    }
+}
diff --git a/bot/storage-mongo/src/main/kotlin/EvaluationSampleMongoDAO.kt b/bot/storage-mongo/src/main/kotlin/EvaluationSampleMongoDAO.kt
new file mode 100644
index 0000000000..90f7f1a3b4
--- /dev/null
+++ b/bot/storage-mongo/src/main/kotlin/EvaluationSampleMongoDAO.kt
@@ -0,0 +1,117 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.mongo
+
+import ai.tock.bot.admin.evaluation.EvaluationSample
+import ai.tock.bot.admin.evaluation.EvaluationSampleDAO
+import ai.tock.bot.admin.evaluation.EvaluationSampleStatus
+import ai.tock.shared.ensureIndex
+import ai.tock.shared.error
+import mu.KotlinLogging
+import org.litote.kmongo.Id
+import org.litote.kmongo.and
+import org.litote.kmongo.combine
+import org.litote.kmongo.deleteOneById
+import org.litote.kmongo.descending
+import org.litote.kmongo.eq
+import org.litote.kmongo.findOneById
+import org.litote.kmongo.getCollection
+import org.litote.kmongo.save
+import org.litote.kmongo.setValue
+import org.litote.kmongo.updateOneById
+import java.time.Instant
+
+private val logger = KotlinLogging.logger {}
+
+internal object EvaluationSampleMongoDAO : EvaluationSampleDAO {
+    internal val col = MongoBotConfiguration.database.getCollection<EvaluationSample>("evaluation_sample")
+
+    init {
+        try {
+            col.ensureIndex(EvaluationSample::botId, EvaluationSample::namespace, EvaluationSample::status)
+            col.ensureIndex(descending(EvaluationSample::creationDate))
+            col.ensureIndex(EvaluationSample::status)
+        } catch (e: Exception) {
+            logger.error(e) { "Error creating indexes for evaluation_sample collection" }
+        }
+    }
+
+    override fun findByNamespaceAndBotId(
+        namespace: String,
+        botId: String,
+        status: EvaluationSampleStatus?,
+    ): List<EvaluationSample> {
+        val baseQuery =
+            and(
+                EvaluationSample::namespace eq namespace,
+                EvaluationSample::botId eq botId,
+            )
+        val query =
+            if (status != null) {
+                and(baseQuery, EvaluationSample::status eq status)
+            } else {
+                baseQuery
+            }
+        return col.find(query)
+            .sort(descending(EvaluationSample::creationDate))
+            .toList()
+    }
+
+    override fun findById(id: Id<EvaluationSample>): EvaluationSample? {
+        return col.findOneById(id)
+    }
+
+    override fun save(sample: EvaluationSample): EvaluationSample {
+        col.save(sample)
+        return sample
+    }
+
+    override fun updateStatus(
+        id: Id<EvaluationSample>,
+        status: EvaluationSampleStatus,
+        changedBy: String,
+        comment: String?,
+    ): EvaluationSample? {
+        val now = Instant.now()
+        col.updateOneById(
+            id,
+            combine(
+                setValue(EvaluationSample::status, status),
+                setValue(EvaluationSample::statusChangedBy, changedBy),
+                setValue(EvaluationSample::statusChangeDate, now),
+                setValue(EvaluationSample::statusComment, comment),
+                setValue(EvaluationSample::lastUpdateDate, now),
+            ),
+        )
+        return findById(id)
+    }
+
+    override fun delete(id: Id<EvaluationSample>): Boolean {
+        return col.deleteOneById(id).deletedCount > 0
+    }
+
+    override fun deleteByNamespaceAndBotId(
+        namespace: String,
+        botId: String,
+    ): Long {
+        val samples = col.find(and(EvaluationSample::namespace eq namespace, EvaluationSample::botId eq botId)).toList()
+        samples.forEach { sample ->
+            EvaluationMongoDAO.deleteByEvaluationSampleId(sample._id)
+        }
+        return col.deleteMany(and(EvaluationSample::namespace eq namespace, EvaluationSample::botId eq botId)).deletedCount
+    }
+}
diff --git a/bot/storage-mongo/src/main/kotlin/Ioc.kt b/bot/storage-mongo/src/main/kotlin/Ioc.kt
index db030fd065..c35229fd07 100644
--- a/bot/storage-mongo/src/main/kotlin/Ioc.kt
+++ b/bot/storage-mongo/src/main/kotlin/Ioc.kt
@@ -23,6 +23,8 @@ import ai.tock.bot.admin.bot.rag.BotRAGConfigurationDAO
 import ai.tock.bot.admin.bot.sentencegeneration.BotSentenceGenerationConfigurationDAO
 import ai.tock.bot.admin.bot.vectorstore.BotVectorStoreConfigurationDAO
 import ai.tock.bot.admin.dialog.DialogReportDAO
+import ai.tock.bot.admin.evaluation.EvaluationDAO
+import ai.tock.bot.admin.evaluation.EvaluationSampleDAO
 import ai.tock.bot.admin.indicators.IndicatorDAO
 import ai.tock.bot.admin.indicators.metric.MetricDAO
 import ai.tock.bot.admin.story.StoryDefinitionConfigurationDAO
@@ -77,4 +79,6 @@ val botMongoModule =
         bind<DialogFlowDAO>() with provider { DialogFlowMongoDAO }
         bind<IndicatorDAO>() with provider { IndicatorMongoDAO }
         bind<MetricDAO>() with provider { MetricMongoDAO }
+        bind<EvaluationSampleDAO>() with provider { EvaluationSampleMongoDAO }
+        bind<EvaluationDAO>() with provider { EvaluationMongoDAO }
     }
diff --git a/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt b/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
index 066e5636f2..4cb80cadc7 100644
--- a/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
+++ b/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
@@ -83,11 +83,13 @@ import ai.tock.shared.longProperty
 import ai.tock.shared.sumByLong
 import com.mongodb.ReadPreference.secondaryPreferred
 import com.mongodb.client.model.Accumulators.sum
+import com.mongodb.client.model.Aggregates.sample
+import com.mongodb.client.model.Filters.elemMatch
 import com.mongodb.client.model.Filters.eq
+import com.mongodb.client.model.Filters.exists
 import com.mongodb.client.model.Filters.gte
-import com.mongodb.client.model.Filters.`in`
 import com.mongodb.client.model.Filters.lte
-import com.mongodb.client.model.Filters.or
+import com.mongodb.client.model.Filters.ne
 import com.mongodb.client.model.IndexOptions
 import kotlinx.coroutines.runBlocking
 import mu.KotlinLogging
@@ -136,6 +138,9 @@ import java.time.ZoneOffset
 import java.time.ZonedDateTime
 import java.util.concurrent.TimeUnit.DAYS
 import kotlin.reflect.KProperty1
+import com.mongodb.client.model.Filters.and as filtersAnd
+import com.mongodb.client.model.Filters.or as filtersOr
+import com.mongodb.client.model.Filters.regex as filtersRegex
 
 /**
  *
@@ -708,20 +713,21 @@ internal object UserTimelineMongoDAO : UserTimelineDAO, UserReportDAO, DialogRep
                                     DialogCol::applicationIds `in` applicationsIds,
                                     DialogCol::namespace eq namespace,
                                 ),
-                            )?.toDialogReport()
+                            )?.toDialogReport(query.evaluableActionsOnly)
 
                         dialog?.let(::listOf).orEmpty().let {
                             DialogReportQueryResult(1, 0, 1, it)
                         }
                     } else {
                         val dialogIds =
-                            if (query.text.isNullOrBlank()) {
-                                emptySet()
-                            } else {
-                                if (query.exactMatch) {
+                            when {
+                                !query.dialogIds.isNullOrEmpty() -> query.dialogIds!!.map { it.toId<Dialog>() }.toSet()
+                                query.text.isNullOrBlank() -> emptySet()
+                                query.exactMatch -> {
                                     dialogTextCol.find(Text eq textKey(query.text!!.trim())).toList().map { it.dialogId }
                                         .toSet()
-                                } else {
+                                }
+                                else -> {
                                     dialogTextCol
                                         .find(Text.regex(textKey(query.text!!.trim()), "i"))
                                         .toList()
@@ -769,43 +775,61 @@ internal object UserTimelineMongoDAO : UserTimelineDAO, UserReportDAO, DialogRep
                                         query.dialogActivityFrom,
                                         query.dialogActivityTo,
                                     ),
+                                    if (query.evaluableActionsOnly) buildEvaluableActionsFilter() else null,
                                 )
                             logger.debug { "dialog search query: $filter" }
                             val c = dialogCol.withReadPreference(secondaryPreferred())
                             val count = c.countDocuments(filter, defaultCountOptions)
-                            if (count > start) {
-                                val sortBson =
-                                    when {
-                                        annotationSort != null -> {
-                                            if (annotationSort == SortDirection.ASC) {
-                                                ascending(Stories.actions.annotation.lastUpdateDate)
-                                            } else {
-                                                descending(Stories.actions.annotation.lastUpdateDate)
+                            val list =
+                                if (query.random) {
+                                    if (count > 0) {
+                                        c.aggregate<DialogCol>(
+                                            listOf(
+                                                match(filter),
+                                                sample(size.coerceAtLeast(1)),
+                                            ),
+                                        ).toList().map { it.toDialogReport(query.evaluableActionsOnly) }
+                                    } else {
+                                        emptyList()
+                                    }
+                                } else if (count > start) {
+                                    val sortBson =
+                                        when {
+                                            annotationSort != null -> {
+                                                if (annotationSort == SortDirection.ASC) {
+                                                    ascending(Stories.actions.annotation.lastUpdateDate)
+                                                } else {
+                                                    descending(Stories.actions.annotation.lastUpdateDate)
+                                                }
                                             }
-                                        }
 
-                                        dialogSort != null -> {
-                                            if (dialogSort == SortDirection.ASC) {
-                                                orderBy(mapOf(Stories.actions.date to true))
-                                            } else {
-                                                orderBy(mapOf(Stories.actions.date to false))
+                                            dialogSort != null -> {
+                                                if (dialogSort == SortDirection.ASC) {
+                                                    orderBy(mapOf(Stories.actions.date to true))
+                                                } else {
+                                                    orderBy(mapOf(Stories.actions.date to false))
+                                                }
                                             }
-                                        }
 
-                                        // If no filter is specified, we keep default filtering
-                                        else -> descending(LastUpdateDate)
-                                    }
-                                val list =
+                                            // If no filter is specified, we keep default filtering
+                                            else -> descending(LastUpdateDate)
+                                        }
                                     c.find(filter)
                                         .skip(start.toInt())
                                         .limit(size)
                                         .sort(sortBson)
                                         .toList()
-                                        .map { it.toDialogReport() }
-                                DialogReportQueryResult(count, start, start + list.size, list)
-                            } else {
-                                DialogReportQueryResult(0, 0, 0, emptyList())
-                            }
+                                        .map { it.toDialogReport(query.evaluableActionsOnly) }
+                                } else {
+                                    emptyList()
+                                }
+                            val result =
+                                if (query.random) {
+                                    DialogReportQueryResult(count, 0L, list.size.toLong(), list)
+                                } else {
+                                    DialogReportQueryResult(count, start, start + list.size, list)
+                                }
+                            result
                         }
                     }
                 }
@@ -863,6 +887,14 @@ internal object UserTimelineMongoDAO : UserTimelineDAO, UserReportDAO, DialogRep
         }
     }
 
+    override fun findByDialogByIds(ids: Set<Id<Dialog>>): Set<DialogReport> {
+        return runBlocking {
+            dialogCol.find(_id `in` ids).toList()
+                .mapNotNull { it.toDialogReport() }
+                .toSet()
+        }
+    }
+
     override suspend fun getClientDialogs(
         namespace: String,
         clientId: String,
@@ -1224,6 +1256,40 @@ internal object UserTimelineMongoDAO : UserTimelineDAO, UserReportDAO, DialogRep
         return if (conditions.isEmpty()) null else and(conditions)
     }
 
+    /**
+     * Builds a filter for dialogs that contain at least one evaluable bot action.
+     * Evaluable actions: Choice, Attachment, Location; Sentence/SentenceWithFootnotes with non-blank text; excludes Debug.
+     * If performance becomes an issue, consider adding a multikey index on stories.actions.type and stories.actions.playerId.type.
+     */
+    private fun buildEvaluableActionsFilter(): Bson =
+        elemMatch(
+            "stories",
+            elemMatch(
+                "actions",
+                filtersAnd(
+                    eq("playerId.type", "bot"),
+                    filtersOr(
+                        eq("type", "choice"),
+                        eq("type", "attachment"),
+                        eq("type", "location"),
+                        filtersAnd(
+                            eq("type", "sentence"),
+                            exists("text", true),
+                            ne("text", null),
+                            ne("text", ""),
+                            filtersRegex("text", "\\S"),
+                        ),
+                        filtersAnd(
+                            eq("type", "sentenceWithFootnotes"),
+                            exists("text", true),
+                            ne("text", ""),
+                            filtersRegex("text", "\\S"),
+                        ),
+                    ),
+                ),
+            ),
+        )
+
     /**
      * Calculates dialog statistics for a given [DialogStatsQuery].
      *
diff --git a/bot/storage-mongo/src/test/kotlin/AbstractTest.kt b/bot/storage-mongo/src/test/kotlin/AbstractTest.kt
index 98beedb8e5..89b8481fbd 100644
--- a/bot/storage-mongo/src/test/kotlin/AbstractTest.kt
+++ b/bot/storage-mongo/src/test/kotlin/AbstractTest.kt
@@ -60,6 +60,9 @@ abstract class AbstractTest(private val initDb: Boolean = true) {
                             )
                         }
                     bind<BotApplicationConfigurationDAO>() with provider { BotApplicationConfigurationMongoDAO }
+                    bind<EvaluationMongoDAO>() with provider { EvaluationMongoDAO }
+                    bind<EvaluationSampleMongoDAO>() with provider { EvaluationSampleMongoDAO }
+                    bind<UserTimelineMongoDAO>() with provider { UserTimelineMongoDAO }
                     bind<FeatureCache>() with provider { spyk(MongoFeatureCache()) }
                     bind<FeatureDAO>() with provider { FeatureMongoDAO(instance(), MongoBotConfiguration.asyncDatabase.getCollection<Feature>()) }
                 },
diff --git a/bot/storage-mongo/src/test/kotlin/EvaluationMongoDAOTest.kt b/bot/storage-mongo/src/test/kotlin/EvaluationMongoDAOTest.kt
new file mode 100644
index 0000000000..ea2629302a
--- /dev/null
+++ b/bot/storage-mongo/src/test/kotlin/EvaluationMongoDAOTest.kt
@@ -0,0 +1,247 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.mongo
+
+import ai.tock.bot.admin.evaluation.Evaluation
+import ai.tock.bot.admin.evaluation.EvaluationReason
+import ai.tock.bot.admin.evaluation.EvaluationSample
+import ai.tock.bot.admin.evaluation.EvaluationStatus
+import ai.tock.bot.admin.evaluation.Evaluator
+import ai.tock.bot.engine.action.Action
+import ai.tock.bot.engine.dialog.Dialog
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.litote.kmongo.Id
+import org.litote.kmongo.newId
+import org.litote.kmongo.toId
+import java.time.Instant
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class EvaluationMongoDAOTest : AbstractTest() {
+    @BeforeEach
+    fun setup() {
+        EvaluationMongoDAO.col.drop()
+    }
+
+    private fun createEvaluation(
+        sampleId: Id<EvaluationSample>,
+        dialogId: String,
+        actionId: String,
+        status: EvaluationStatus = EvaluationStatus.UNSET,
+    ): Evaluation {
+        return Evaluation(
+            evaluationSampleId = sampleId,
+            dialogId = dialogId.toId<Dialog>(),
+            actionId = actionId.toId<Action>(),
+            status = status,
+        )
+    }
+
+    @Test
+    fun `should save and retrieve evaluations`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluation1 = createEvaluation(sampleId, "dialog1", "action1")
+        val evaluation2 = createEvaluation(sampleId, "dialog2", "action2")
+
+        EvaluationMongoDAO.createAll(listOf(evaluation1, evaluation2))
+
+        val foundEvaluations = EvaluationMongoDAO.findByEvaluationSampleId(sampleId)
+        assertEquals(2, foundEvaluations.size)
+    }
+
+    @Test
+    fun `should count evaluations by sample id`() {
+        val sampleId = newId<EvaluationSample>()
+        EvaluationMongoDAO.createAll(
+            listOf(
+                createEvaluation(sampleId, "dialog1", "action1"),
+                createEvaluation(sampleId, "dialog2", "action2"),
+                createEvaluation(sampleId, "dialog3", "action3"),
+            ),
+        )
+
+        val count = EvaluationMongoDAO.countByEvaluationSampleId(sampleId)
+        assertEquals(3, count)
+    }
+
+    @Test
+    fun `should paginate evaluations`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluations = (0 until 10).map { createEvaluation(sampleId, "dialog$it", "action$it") }
+        EvaluationMongoDAO.createAll(evaluations)
+
+        val firstPage = EvaluationMongoDAO.findByEvaluationSampleId(sampleId, 0, 5)
+        assertEquals(5, firstPage.size)
+
+        val secondPage = EvaluationMongoDAO.findByEvaluationSampleId(sampleId, 5, 5)
+        assertEquals(5, secondPage.size)
+    }
+
+    @Test
+    fun `should find evaluations by sample id and dialog ids`() {
+        val sampleId = newId<EvaluationSample>()
+        EvaluationMongoDAO.createAll(
+            listOf(
+                createEvaluation(sampleId, "d1", "a1"),
+                createEvaluation(sampleId, "d2", "a2"),
+                createEvaluation(sampleId, "d3", "a3"),
+            ),
+        )
+
+        val result =
+            EvaluationMongoDAO.findByEvaluationSampleIdAndDialogIds(
+                sampleId,
+                listOf("d1".toId<Dialog>(), "d3".toId<Dialog>()),
+            )
+        assertEquals(2, result.size)
+        assertEquals(setOf("d1".toId<Dialog>(), "d3".toId<Dialog>()), result.map { it.dialogId }.toSet())
+    }
+
+    @Test
+    fun `should return empty list when findByEvaluationSampleIdAndDialogIds with empty dialog ids`() {
+        val sampleId = newId<EvaluationSample>()
+        EvaluationMongoDAO.createAll(listOf(createEvaluation(sampleId, "d1", "a1")))
+
+        val result = EvaluationMongoDAO.findByEvaluationSampleIdAndDialogIds(sampleId, emptyList())
+        assertTrue(result.isEmpty())
+    }
+
+    @Test
+    fun `should return grouped evaluations paginated and sorted by dialogId`() {
+        val sampleId = newId<EvaluationSample>()
+
+        // Insert in non-sorted order to validate ordering.
+        EvaluationMongoDAO.createAll(
+            listOf(
+                createEvaluation(sampleId, "d2", "a2"),
+                createEvaluation(sampleId, "d1", "a2"),
+                createEvaluation(sampleId, "d1", "a1"),
+                createEvaluation(sampleId, "d3", "a1"),
+                createEvaluation(sampleId, "d2", "a1"),
+            ),
+        )
+
+        val result = EvaluationMongoDAO.findGroupedEvaluationsBySampleId(sampleId, start = 0, size = 2)
+
+        assertEquals(2, result.size)
+        assertEquals(listOf("d1".toId<Dialog>(), "d2".toId<Dialog>()), result.map { it._id })
+
+        val d1 = result.first { it._id == "d1".toId<Dialog>() }.evaluations
+        assertEquals(listOf("a1".toId<Action>(), "a2".toId<Action>()), d1.map { it.actionId })
+
+        val d2 = result.first { it._id == "d2".toId<Dialog>() }.evaluations
+        assertEquals(listOf("a1".toId<Action>(), "a2".toId<Action>()), d2.map { it.actionId })
+    }
+
+    @Test
+    fun `should update evaluation`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluation = createEvaluation(sampleId, "dialog1", "action1")
+        EvaluationMongoDAO.createAll(listOf(evaluation))
+
+        val updated =
+            evaluation.copy(
+                status = EvaluationStatus.DOWN,
+                reason = EvaluationReason.HALLUCINATION,
+                evaluator = Evaluator("user123"),
+                evaluationDate = Instant.now(),
+            )
+        val result = EvaluationMongoDAO.update(updated)
+
+        assertNotNull(result)
+        assertEquals(EvaluationStatus.DOWN, result.status)
+        assertEquals(EvaluationReason.HALLUCINATION, result.reason)
+        assertNotNull(result.evaluator)
+        assertEquals("user123", result.evaluator?.id)
+    }
+
+    @Test
+    fun `should delete evaluations by sample id`() {
+        val sampleId1 = newId<EvaluationSample>()
+        val sampleId2 = newId<EvaluationSample>()
+        EvaluationMongoDAO.createAll(
+            listOf(
+                createEvaluation(sampleId1, "d1", "a1"),
+                createEvaluation(sampleId1, "d2", "a2"),
+                createEvaluation(sampleId2, "d3", "a3"),
+            ),
+        )
+
+        val deletedCount = EvaluationMongoDAO.deleteByEvaluationSampleId(sampleId1)
+        assertEquals(2, deletedCount)
+
+        val remaining = EvaluationMongoDAO.findByEvaluationSampleId(sampleId1)
+        assertTrue(remaining.isEmpty())
+
+        val sample2Evaluations = EvaluationMongoDAO.findByEvaluationSampleId(sampleId2)
+        assertEquals(1, sample2Evaluations.size)
+    }
+
+    @Test
+    fun `should count by status`() {
+        val sampleId = newId<EvaluationSample>()
+        EvaluationMongoDAO.createAll(
+            listOf(
+                createEvaluation(sampleId, "d1", "a1", EvaluationStatus.UNSET),
+                createEvaluation(sampleId, "d2", "a2", EvaluationStatus.UNSET),
+                createEvaluation(sampleId, "d3", "a3", EvaluationStatus.UP),
+                createEvaluation(sampleId, "d4", "a4", EvaluationStatus.UP),
+                createEvaluation(sampleId, "d5", "a5", EvaluationStatus.UP),
+                createEvaluation(sampleId, "d6", "a6", EvaluationStatus.DOWN),
+            ),
+        )
+
+        val counts = EvaluationMongoDAO.countByStatus(sampleId)
+        assertEquals(2L, counts[EvaluationStatus.UNSET])
+        assertEquals(3L, counts[EvaluationStatus.UP])
+        assertEquals(1L, counts[EvaluationStatus.DOWN])
+    }
+
+    @Test
+    fun `should find evaluation by id`() {
+        val sampleId = newId<EvaluationSample>()
+        val evaluation = createEvaluation(sampleId, "dialog1", "action1")
+        EvaluationMongoDAO.createAll(listOf(evaluation))
+
+        val found = EvaluationMongoDAO.findById(evaluation._id)
+        assertNotNull(found)
+        assertEquals(evaluation._id, found._id)
+    }
+
+    @Test
+    fun `should return null for non-existent evaluation`() {
+        val found = EvaluationMongoDAO.findById(newId())
+        assertNull(found)
+    }
+
+    @Test
+    fun `should return empty list for non-existent sample`() {
+        val found = EvaluationMongoDAO.findByEvaluationSampleId(newId())
+        assertTrue(found.isEmpty())
+    }
+
+    @Test
+    fun `should return zero counts for non-existent sample`() {
+        val counts = EvaluationMongoDAO.countByStatus(newId())
+        assertEquals(0L, counts[EvaluationStatus.UNSET])
+        assertEquals(0L, counts[EvaluationStatus.UP])
+        assertEquals(0L, counts[EvaluationStatus.DOWN])
+    }
+}
diff --git a/bot/storage-mongo/src/test/kotlin/EvaluationSampleMongoDAOTest.kt b/bot/storage-mongo/src/test/kotlin/EvaluationSampleMongoDAOTest.kt
new file mode 100644
index 0000000000..ff4f067c59
--- /dev/null
+++ b/bot/storage-mongo/src/test/kotlin/EvaluationSampleMongoDAOTest.kt
@@ -0,0 +1,194 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.bot.mongo
+
+import ai.tock.bot.admin.evaluation.ActionRef
+import ai.tock.bot.admin.evaluation.EvaluationSample
+import ai.tock.bot.admin.evaluation.EvaluationSampleStatus
+import ai.tock.bot.engine.action.Action
+import ai.tock.bot.engine.dialog.Dialog
+import ai.tock.shared.tockInternalInjector
+import com.github.salomonbrys.kodein.Kodein
+import com.github.salomonbrys.kodein.KodeinInjector
+import org.junit.jupiter.api.BeforeEach
+import org.junit.jupiter.api.Test
+import org.litote.kmongo.newId
+import org.litote.kmongo.toId
+import java.time.Instant
+import kotlin.test.assertEquals
+import kotlin.test.assertNotNull
+import kotlin.test.assertNull
+import kotlin.test.assertTrue
+
+class EvaluationSampleMongoDAOTest : AbstractTest() {
+    companion object {
+        private const val NAMESPACE = "testNamespace"
+        private const val BOT_ID = "testBotId"
+        private const val USER = "testUser"
+
+        init {
+            tockInternalInjector = KodeinInjector()
+            tockInternalInjector.inject(
+                Kodein {
+                    import(botMongoModule)
+                },
+            )
+        }
+    }
+
+    @BeforeEach
+    fun setup() {
+        EvaluationSampleMongoDAO.col.drop()
+    }
+
+    private fun createSample(
+        name: String,
+        botId: String = BOT_ID,
+        namespace: String = NAMESPACE,
+        status: EvaluationSampleStatus = EvaluationSampleStatus.IN_PROGRESS,
+    ): EvaluationSample {
+        val now = Instant.now()
+        return EvaluationSample(
+            botId = botId,
+            namespace = namespace,
+            name = name,
+            description = "Test description",
+            dialogActivityFrom = now.minusSeconds(86400),
+            dialogActivityTo = now,
+            requestedDialogCount = 10,
+            dialogsCount = 5,
+            totalDialogCount = 100,
+            botActionCount = 15,
+            allowTestDialogs = false,
+            actionRefs =
+                listOf(
+                    ActionRef("dialog1".toId<Dialog>(), "action1".toId<Action>()),
+                    ActionRef("dialog2".toId<Dialog>(), "action2".toId<Action>()),
+                ),
+            status = status,
+            createdBy = USER,
+            statusChangedBy = USER,
+            creationDate = now,
+            statusChangeDate = now,
+            lastUpdateDate = now,
+        )
+    }
+
+    @Test
+    fun `should save and retrieve evaluation sample`() {
+        val sample = createSample("Test Sample")
+        val savedSample = EvaluationSampleMongoDAO.save(sample)
+
+        assertNotNull(savedSample._id)
+        assertEquals(sample.name, savedSample.name)
+
+        val foundSample = EvaluationSampleMongoDAO.findById(savedSample._id)
+        assertNotNull(foundSample)
+        assertEquals(savedSample._id, foundSample._id)
+        assertEquals("Test Sample", foundSample.name)
+        assertEquals(2, foundSample.actionRefs.size)
+    }
+
+    @Test
+    fun `should find samples by namespace and botId`() {
+        EvaluationSampleMongoDAO.save(createSample("Sample 1"))
+        EvaluationSampleMongoDAO.save(createSample("Sample 2"))
+        EvaluationSampleMongoDAO.save(createSample("Sample 3", botId = "otherBot"))
+
+        val foundSamples = EvaluationSampleMongoDAO.findByNamespaceAndBotId(NAMESPACE, BOT_ID)
+        assertEquals(2, foundSamples.size)
+        assertTrue(foundSamples.any { it.name == "Sample 1" })
+        assertTrue(foundSamples.any { it.name == "Sample 2" })
+    }
+
+    @Test
+    fun `should find samples by status`() {
+        EvaluationSampleMongoDAO.save(createSample("Sample IN_PROGRESS", status = EvaluationSampleStatus.IN_PROGRESS))
+        EvaluationSampleMongoDAO.save(createSample("Sample VALIDATED", status = EvaluationSampleStatus.VALIDATED))
+        EvaluationSampleMongoDAO.save(createSample("Sample CANCELLED", status = EvaluationSampleStatus.CANCELLED))
+
+        val inProgressSamples = EvaluationSampleMongoDAO.findByNamespaceAndBotId(NAMESPACE, BOT_ID, EvaluationSampleStatus.IN_PROGRESS)
+        assertEquals(1, inProgressSamples.size)
+        assertEquals("Sample IN_PROGRESS", inProgressSamples[0].name)
+
+        val validatedSamples = EvaluationSampleMongoDAO.findByNamespaceAndBotId(NAMESPACE, BOT_ID, EvaluationSampleStatus.VALIDATED)
+        assertEquals(1, validatedSamples.size)
+        assertEquals("Sample VALIDATED", validatedSamples[0].name)
+    }
+
+    @Test
+    fun `should update sample status`() {
+        val sample = createSample("Test Sample")
+        val savedSample = EvaluationSampleMongoDAO.save(sample)
+
+        val updatedSample =
+            EvaluationSampleMongoDAO.updateStatus(
+                savedSample._id,
+                EvaluationSampleStatus.VALIDATED,
+                "validator",
+                "Validation complete",
+            )
+
+        assertNotNull(updatedSample)
+        assertEquals(EvaluationSampleStatus.VALIDATED, updatedSample.status)
+        assertEquals("validator", updatedSample.statusChangedBy)
+        assertEquals("Validation complete", updatedSample.statusComment)
+    }
+
+    @Test
+    fun `should delete sample`() {
+        val sample = createSample("Test Sample")
+        val savedSample = EvaluationSampleMongoDAO.save(sample)
+
+        val deleted = EvaluationSampleMongoDAO.delete(savedSample._id)
+        assertTrue(deleted)
+
+        val foundSample = EvaluationSampleMongoDAO.findById(savedSample._id)
+        assertNull(foundSample)
+    }
+
+    @Test
+    fun `should return null for non-existent id`() {
+        val foundSample = EvaluationSampleMongoDAO.findById(newId())
+        assertNull(foundSample)
+    }
+
+    @Test
+    fun `should return empty list for non-existent botId`() {
+        EvaluationSampleMongoDAO.save(createSample("Test Sample"))
+
+        val foundSamples = EvaluationSampleMongoDAO.findByNamespaceAndBotId(NAMESPACE, "nonExistentBot")
+        assertTrue(foundSamples.isEmpty())
+    }
+
+    @Test
+    fun `should return samples sorted by creation date descending`() {
+        val sample1 = createSample("Sample 1").copy(creationDate = Instant.now().minusSeconds(100))
+        val sample2 = createSample("Sample 2").copy(creationDate = Instant.now().minusSeconds(50))
+        val sample3 = createSample("Sample 3").copy(creationDate = Instant.now())
+
+        EvaluationSampleMongoDAO.save(sample1)
+        EvaluationSampleMongoDAO.save(sample2)
+        EvaluationSampleMongoDAO.save(sample3)
+
+        val foundSamples = EvaluationSampleMongoDAO.findByNamespaceAndBotId(NAMESPACE, BOT_ID)
+        assertEquals(3, foundSamples.size)
+        assertEquals("Sample 3", foundSamples[0].name)
+        assertEquals("Sample 2", foundSamples[1].name)
+        assertEquals("Sample 1", foundSamples[2].name)
+    }
+}
diff --git a/bot/storage-mongo/src/test/kotlin/UserTimelineMongoDAOTest.kt b/bot/storage-mongo/src/test/kotlin/UserTimelineMongoDAOTest.kt
index 56b4123c29..ab17423925 100644
--- a/bot/storage-mongo/src/test/kotlin/UserTimelineMongoDAOTest.kt
+++ b/bot/storage-mongo/src/test/kotlin/UserTimelineMongoDAOTest.kt
@@ -25,10 +25,14 @@ import ai.tock.bot.definition.SimpleStoryHandlerBase
 import ai.tock.bot.definition.StoryDefinitionBase
 import ai.tock.bot.engine.BotBus
 import ai.tock.bot.engine.action.ActionMetadata
+import ai.tock.bot.engine.action.SendAttachment
+import ai.tock.bot.engine.action.SendChoice
+import ai.tock.bot.engine.action.SendDebug
 import ai.tock.bot.engine.action.SendSentence
 import ai.tock.bot.engine.dialog.Dialog
 import ai.tock.bot.engine.dialog.EventState
 import ai.tock.bot.engine.dialog.Story
+import ai.tock.bot.engine.message.DebugMessage
 import ai.tock.bot.engine.user.PlayerId
 import ai.tock.bot.engine.user.PlayerType
 import ai.tock.bot.engine.user.UserTimeline
@@ -394,4 +398,378 @@ internal class UserTimelineMongoDAOTest : AbstractTest() {
                 BotApplicationConfigurationMongoDAO.delete(botConfig)
             }
         }
+
+    @Test
+    fun `evaluableActionsOnly filter excludes dialogs with only debug or empty text actions`() =
+        runBlocking {
+            val namespace = "test_evaluable_actions_filter"
+            val applicationId = "test_app_evaluable"
+            val nlpModel = "test_model_evaluable"
+            val userId = PlayerId("user_evaluable_test", PlayerType.user)
+            val botPlayerId = PlayerId("bot_evaluable_test", PlayerType.bot)
+
+            val botConfig =
+                BotApplicationConfiguration(
+                    applicationId = applicationId,
+                    botId = botPlayerId.id,
+                    namespace = namespace,
+                    nlpModel = nlpModel,
+                    connectorType = ConnectorType("test"),
+                )
+            BotApplicationConfigurationMongoDAO.save(botConfig)
+
+            try {
+                val storyHandler =
+                    object : SimpleStoryHandlerBase() {
+                        override fun action(bus: BotBus) {}
+                    }
+                val storyDef = StoryDefinitionBase("test_story_evaluable", storyHandler)
+                val actionDate = ZonedDateTime.parse("2025-12-15T10:00:00Z").toInstant()
+
+                // Dialog A: bot Sentence with non-empty text (evaluable)
+                val dialogA =
+                    Dialog(
+                        playerIds = setOf(userId, botPlayerId),
+                        stories =
+                            mutableListOf(
+                                Story(
+                                    storyDef,
+                                    Intent("test"),
+                                    actions =
+                                        mutableListOf(
+                                            SendSentence(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "Hello",
+                                                mutableListOf(),
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                        ),
+                                ),
+                            ),
+                    )
+
+                // Dialog B: only SendDebug (not evaluable)
+                val dialogB =
+                    Dialog(
+                        playerIds = setOf(userId, botPlayerId),
+                        stories =
+                            mutableListOf(
+                                Story(
+                                    storyDef,
+                                    Intent("test"),
+                                    actions =
+                                        mutableListOf(
+                                            SendDebug(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "debug text",
+                                                null,
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                        ),
+                                ),
+                            ),
+                    )
+
+                // Dialog C: bot Sentence with empty text (not evaluable)
+                val dialogC =
+                    Dialog(
+                        playerIds = setOf(userId, botPlayerId),
+                        stories =
+                            mutableListOf(
+                                Story(
+                                    storyDef,
+                                    Intent("test"),
+                                    actions =
+                                        mutableListOf(
+                                            SendSentence(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "",
+                                                mutableListOf(),
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                        ),
+                                ),
+                            ),
+                    )
+
+                // Dialog D: only SendChoice (evaluable - new behavior)
+                val dialogD =
+                    Dialog(
+                        playerIds = setOf(userId, botPlayerId),
+                        stories =
+                            mutableListOf(
+                                Story(
+                                    storyDef,
+                                    Intent("test"),
+                                    actions =
+                                        mutableListOf(
+                                            SendChoice(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "test_intent",
+                                                emptyMap(),
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                        ),
+                                ),
+                            ),
+                    )
+
+                val userTimeline =
+                    UserTimeline(
+                        playerId = userId,
+                        dialogs = mutableListOf(dialogA, dialogB, dialogC, dialogD),
+                    )
+
+                UserTimelineMongoDAO.save(userTimeline, namespace)
+                delay(100)
+
+                val queryWithFilter =
+                    DialogReportQuery(
+                        namespace = namespace,
+                        nlpModel = nlpModel,
+                        applicationId = applicationId,
+                        displayTests = true,
+                        evaluableActionsOnly = true,
+                    )
+                val resultWithFilter = UserTimelineMongoDAO.search(queryWithFilter)
+
+                assertEquals(
+                    2L,
+                    resultWithFilter.total,
+                    "DialogA (Sentence with text) and DialogD (Choice) should be included. " +
+                        "DialogB (Debug) and DialogC (empty text) should be excluded. Found: ${resultWithFilter.total}",
+                )
+
+                val queryWithoutFilter =
+                    DialogReportQuery(
+                        namespace = namespace,
+                        nlpModel = nlpModel,
+                        applicationId = applicationId,
+                        displayTests = true,
+                        evaluableActionsOnly = false,
+                    )
+                val resultWithoutFilter = UserTimelineMongoDAO.search(queryWithoutFilter)
+
+                assertTrue(
+                    resultWithoutFilter.total >= 4L,
+                    "Without evaluableActionsOnly filter, all 4 dialogs should be included. Found: ${resultWithoutFilter.total}",
+                )
+            } finally {
+                BotApplicationConfigurationMongoDAO.delete(botConfig)
+            }
+        }
+
+    @Test
+    fun `evaluableActionsOnly includes dialogs with only Attachment actions`() =
+        runBlocking {
+            val namespace = "test_evaluable_attachment"
+            val applicationId = "test_app_attachment"
+            val nlpModel = "test_model_attachment"
+            val userId = PlayerId("user_attachment_test", PlayerType.user)
+            val botPlayerId = PlayerId("bot_attachment_test", PlayerType.bot)
+
+            val botConfig =
+                BotApplicationConfiguration(
+                    applicationId = applicationId,
+                    botId = botPlayerId.id,
+                    namespace = namespace,
+                    nlpModel = nlpModel,
+                    connectorType = ConnectorType("test"),
+                )
+            BotApplicationConfigurationMongoDAO.save(botConfig)
+
+            try {
+                val storyHandler =
+                    object : SimpleStoryHandlerBase() {
+                        override fun action(bus: BotBus) {}
+                    }
+                val storyDef = StoryDefinitionBase("test_story_attachment", storyHandler)
+                val actionDate = ZonedDateTime.parse("2025-12-15T10:00:00Z").toInstant()
+
+                val dialogWithAttachment =
+                    Dialog(
+                        playerIds = setOf(userId, botPlayerId),
+                        stories =
+                            mutableListOf(
+                                Story(
+                                    storyDef,
+                                    Intent("test"),
+                                    actions =
+                                        mutableListOf(
+                                            SendAttachment(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "https://example.com/file.pdf",
+                                                SendAttachment.AttachmentType.file,
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                        ),
+                                ),
+                            ),
+                    )
+
+                val userTimeline =
+                    UserTimeline(
+                        playerId = userId,
+                        dialogs = mutableListOf(dialogWithAttachment),
+                    )
+
+                UserTimelineMongoDAO.save(userTimeline, namespace)
+                delay(100)
+
+                val query =
+                    DialogReportQuery(
+                        namespace = namespace,
+                        nlpModel = nlpModel,
+                        applicationId = applicationId,
+                        displayTests = true,
+                        evaluableActionsOnly = true,
+                    )
+                val result = UserTimelineMongoDAO.search(query)
+
+                assertEquals(
+                    1L,
+                    result.total,
+                    "Dialog with only SendAttachment should be included. Found: ${result.total}",
+                )
+            } finally {
+                BotApplicationConfigurationMongoDAO.delete(botConfig)
+            }
+        }
+
+    @Test
+    fun `evaluableActionsOnly filters actions when returning evaluable dialogs`() =
+        runBlocking {
+            val namespace = "test_evaluable_filter_actions"
+            val applicationId = "test_app_filter_actions"
+            val nlpModel = "test_model_filter_actions"
+            val userId = PlayerId("user_filter_test", PlayerType.user)
+            val botPlayerId = PlayerId("bot_filter_test", PlayerType.bot)
+
+            val botConfig =
+                BotApplicationConfiguration(
+                    applicationId = applicationId,
+                    botId = botPlayerId.id,
+                    namespace = namespace,
+                    nlpModel = nlpModel,
+                    connectorType = ConnectorType("test"),
+                )
+            BotApplicationConfigurationMongoDAO.save(botConfig)
+
+            try {
+                val storyHandler =
+                    object : SimpleStoryHandlerBase() {
+                        override fun action(bus: BotBus) {}
+                    }
+                val storyDef = StoryDefinitionBase("test_story_filter", storyHandler)
+                val actionDate = ZonedDateTime.parse("2025-12-15T10:00:00Z").toInstant()
+
+                val dialogWithMixedActions =
+                    Dialog(
+                        playerIds = setOf(userId, botPlayerId),
+                        stories =
+                            mutableListOf(
+                                Story(
+                                    storyDef,
+                                    Intent("test"),
+                                    actions =
+                                        mutableListOf(
+                                            SendSentence(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "Hello",
+                                                mutableListOf(),
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                            SendDebug(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "debug text",
+                                                null,
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                            SendChoice(
+                                                botPlayerId,
+                                                applicationId,
+                                                userId,
+                                                "test_intent",
+                                                emptyMap(),
+                                                newId(),
+                                                actionDate,
+                                                EventState(),
+                                                ActionMetadata(),
+                                            ),
+                                        ),
+                                ),
+                            ),
+                    )
+
+                val userTimeline =
+                    UserTimeline(
+                        playerId = userId,
+                        dialogs = mutableListOf(dialogWithMixedActions),
+                    )
+
+                UserTimelineMongoDAO.save(userTimeline, namespace)
+                delay(100)
+
+                val query =
+                    DialogReportQuery(
+                        namespace = namespace,
+                        nlpModel = nlpModel,
+                        applicationId = applicationId,
+                        displayTests = true,
+                        evaluableActionsOnly = true,
+                    )
+                val result = UserTimelineMongoDAO.search(query)
+
+                assertEquals(1, result.dialogs.size)
+                val dialogReport = result.dialogs.first()
+                assertEquals(
+                    2,
+                    dialogReport.actions.size,
+                    "DialogReport should contain only Sentence and Choice (Debug excluded). Found: ${dialogReport.actions.size}",
+                )
+                val hasDebugMessage =
+                    dialogReport.actions.any { it.message is DebugMessage }
+                assertTrue(
+                    !hasDebugMessage,
+                    "DialogReport actions should not contain DebugMessage",
+                )
+            } finally {
+                BotApplicationConfigurationMongoDAO.delete(botConfig)
+            }
+        }
 }
diff --git a/shared/src/main/kotlin/exception/rest/UnprocessableEntityException.kt b/shared/src/main/kotlin/exception/rest/UnprocessableEntityException.kt
new file mode 100644
index 0000000000..646f763d44
--- /dev/null
+++ b/shared/src/main/kotlin/exception/rest/UnprocessableEntityException.kt
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2017/2025 SNCF Connect & Tech
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package ai.tock.shared.exception.rest
+
+import ai.tock.shared.exception.error.ErrorMessage
+import ai.tock.shared.exception.error.ErrorMessageWrapper
+import io.netty.handler.codec.http.HttpResponseStatus
+
+/**
+ * Http 422 exception - Unprocessable Entity.
+ * Used when the request is syntactically correct but semantically invalid.
+ */
+class UnprocessableEntityException(httpResponseBody: ErrorMessageWrapper) :
+    RestException(httpResponseBody, HttpResponseStatus(422, "Unprocessable Entity")) {
+    constructor(errorCode: Int, message: String) :
+        this(ErrorMessageWrapper(setOf(ErrorMessage(errorCode.toString(), message))))
+
+    constructor(message: String) :
+        this(ErrorMessageWrapper(message))
+
+    constructor(errorMessages: Set<ErrorMessage>) :
+        this(ErrorMessageWrapper(errors = errorMessages))
+}

From 77088194e0a91d294a769db2b7b251dcb3d95c69 Mon Sep 17 00:00:00 2001
From: TS426 <antoine.billiet@partnre.com>
Date: Tue, 10 Mar 2026 15:19:19 +0100
Subject: [PATCH 2/3] feat: improve code compliance

see above
---
 .../src/main/kotlin/UserTimelineMongoDAO.kt        | 14 +++-----------
 1 file changed, 3 insertions(+), 11 deletions(-)

diff --git a/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt b/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
index 4cb80cadc7..8f1b557cc5 100644
--- a/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
+++ b/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
@@ -88,6 +88,7 @@ import com.mongodb.client.model.Filters.elemMatch
 import com.mongodb.client.model.Filters.eq
 import com.mongodb.client.model.Filters.exists
 import com.mongodb.client.model.Filters.gte
+import com.mongodb.client.model.Filters.`in`
 import com.mongodb.client.model.Filters.lte
 import com.mongodb.client.model.Filters.ne
 import com.mongodb.client.model.IndexOptions
@@ -1273,18 +1274,9 @@ internal object UserTimelineMongoDAO : UserTimelineDAO, UserReportDAO, DialogRep
                         eq("type", "attachment"),
                         eq("type", "location"),
                         filtersAnd(
-                            eq("type", "sentence"),
-                            exists("text", true),
-                            ne("text", null),
-                            ne("text", ""),
+                            `in`("type", listOf("sentence", "sentenceWithFootnotes")),
                             filtersRegex("text", "\\S"),
-                        ),
-                        filtersAnd(
-                            eq("type", "sentenceWithFootnotes"),
-                            exists("text", true),
-                            ne("text", ""),
-                            filtersRegex("text", "\\S"),
-                        ),
+                        )
                     ),
                 ),
             ),

From ea9c095f27f9570e842d568697d7d1cd81e19c64 Mon Sep 17 00:00:00 2001
From: TS426 <antoine.billiet@partnre.com>
Date: Tue, 10 Mar 2026 15:37:08 +0100
Subject: [PATCH 3/3] fix: klint report

see above
---
 bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt b/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
index 8f1b557cc5..315b7846cb 100644
--- a/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
+++ b/bot/storage-mongo/src/main/kotlin/UserTimelineMongoDAO.kt
@@ -86,11 +86,9 @@ import com.mongodb.client.model.Accumulators.sum
 import com.mongodb.client.model.Aggregates.sample
 import com.mongodb.client.model.Filters.elemMatch
 import com.mongodb.client.model.Filters.eq
-import com.mongodb.client.model.Filters.exists
 import com.mongodb.client.model.Filters.gte
 import com.mongodb.client.model.Filters.`in`
 import com.mongodb.client.model.Filters.lte
-import com.mongodb.client.model.Filters.ne
 import com.mongodb.client.model.IndexOptions
 import kotlinx.coroutines.runBlocking
 import mu.KotlinLogging
@@ -1276,7 +1274,7 @@ internal object UserTimelineMongoDAO : UserTimelineDAO, UserReportDAO, DialogRep
                         filtersAnd(
                             `in`("type", listOf("sentence", "sentenceWithFootnotes")),
                             filtersRegex("text", "\\S"),
-                        )
+                        ),
                     ),
                 ),
             ),