Merge remote-tracking branch 'origin/release-v1.16.0' into document-sorting

crates/meilisearch/Cargo.toml

@@ -169,5 +169,5 @@ german = ["meilisearch-types/german"]
 turkish = ["meilisearch-types/turkish"]
 
 [package.metadata.mini-dashboard]
-assets-url = "https://github.com/meilisearch/mini-dashboard/releases/download/v0.2.19/build.zip"
-sha1 = "7974430d5277c97f67cf6e95eec6faaac2788834"
+assets-url = "https://github.com/meilisearch/mini-dashboard/releases/download/v0.2.20/build.zip"
+sha1 = "82a7ddd7bf14bb5323c3d235d2b62892a98b6a59"

crates/meilisearch/src/analytics/segment_analytics.rs

@@ -197,11 +197,13 @@ struct Infos {
     experimental_max_number_of_batched_tasks: usize,
     experimental_limit_batched_tasks_total_size: u64,
     experimental_network: bool,
+    experimental_multimodal: bool,
     experimental_chat_completions: bool,
     experimental_get_task_documents_route: bool,
     experimental_composite_embedders: bool,
     experimental_embedding_cache_entries: usize,
     experimental_no_snapshot_compaction: bool,
+    experimental_no_edition_2024_for_settings: bool,
     gpu_enabled: bool,
     db_path: bool,
     import_dump: bool,
@@ -286,8 +288,12 @@ impl Infos {
             ScheduleSnapshot::Enabled(interval) => Some(interval),
         };
 
-        let IndexerOpts { max_indexing_memory, max_indexing_threads, skip_index_budget: _ } =
-            indexer_options;
+        let IndexerOpts {
+            max_indexing_memory,
+            max_indexing_threads,
+            skip_index_budget: _,
+            experimental_no_edition_2024_for_settings,
+        } = indexer_options;
 
         let RuntimeTogglableFeatures {
             metrics,
@@ -298,6 +304,7 @@ impl Infos {
             get_task_documents_route,
             composite_embedders,
             chat_completions,
+            multimodal,
         } = features;
 
         // We're going to override every sensible information.
@@ -317,6 +324,7 @@ impl Infos {
             experimental_reduce_indexing_memory_usage,
             experimental_network: network,
             experimental_chat_completions: chat_completions,
+            experimental_multimodal: multimodal,
             experimental_get_task_documents_route: get_task_documents_route,
             experimental_composite_embedders: composite_embedders,
             experimental_embedding_cache_entries,
@@ -350,6 +358,7 @@ impl Infos {
             ssl_require_auth,
             ssl_resumption,
             ssl_tickets,
+            experimental_no_edition_2024_for_settings,
         }
     }
 }

crates/meilisearch/src/error.rs

@@ -49,7 +49,7 @@ pub enum MeilisearchHttpError {
     TooManySearchRequests(usize),
     #[error("Internal error: Search limiter is down.")]
     SearchLimiterIsDown,
-    #[error("The provided payload reached the size limit. The maximum accepted payload size is {}.",  Byte::from_u64(*.0 as u64).get_appropriate_unit(UnitType::Binary))]
+    #[error("The provided payload reached the size limit. The maximum accepted payload size is {}.", Byte::from_u64(*.0 as u64).get_appropriate_unit(if *.0 % 1024 == 0 { UnitType::Binary } else { UnitType::Decimal }))]
     PayloadTooLarge(usize),
     #[error("Two indexes must be given for each swap. The list `[{}]` contains {} indexes.",
         .0.iter().map(|uid| format!("\"{uid}\"")).collect::<Vec<_>>().join(", "), .0.len()
@@ -76,8 +76,10 @@ pub enum MeilisearchHttpError {
     DocumentFormat(#[from] DocumentFormatError),
     #[error(transparent)]
     Join(#[from] JoinError),
-    #[error("Invalid request: missing `hybrid` parameter when `vector` is present.")]
+    #[error("Invalid request: missing `hybrid` parameter when `vector` or `media` are present.")]
     MissingSearchHybrid,
+    #[error("Invalid request: both `media` and `vector` parameters are present.")]
+    MediaAndVector,
 }
 
 impl MeilisearchHttpError {
@@ -111,6 +113,7 @@ impl ErrorCode for MeilisearchHttpError {
             MeilisearchHttpError::DocumentFormat(e) => e.error_code(),
             MeilisearchHttpError::Join(_) => Code::Internal,
             MeilisearchHttpError::MissingSearchHybrid => Code::MissingSearchHybrid,
+            MeilisearchHttpError::MediaAndVector => Code::InvalidSearchMediaAndVector,
             MeilisearchHttpError::FederationOptionsInNonFederatedRequest(_) => {
                 Code::InvalidMultiSearchFederationOptions
             }

crates/meilisearch/src/lib.rs

@@ -37,6 +37,7 @@ use index_scheduler::{IndexScheduler, IndexSchedulerOptions};
 use meilisearch_auth::{open_auth_store_env, AuthController};
 use meilisearch_types::milli::constants::VERSION_MAJOR;
 use meilisearch_types::milli::documents::{DocumentsBatchBuilder, DocumentsBatchReader};
+use meilisearch_types::milli::progress::{EmbedderStats, Progress};
 use meilisearch_types::milli::update::{
     default_thread_pool_and_threads, IndexDocumentsConfig, IndexDocumentsMethod, IndexerConfig,
 };
@@ -463,6 +464,7 @@ fn import_dump(
     index_scheduler: &mut IndexScheduler,
     auth: &mut AuthController,
 ) -> Result<(), anyhow::Error> {
+    let progress = Progress::default();
     let reader = File::open(dump_path)?;
     let mut dump_reader = dump::DumpReader::open(reader)?;
 
@@ -496,14 +498,20 @@ fn import_dump(
         keys.push(key);
     }
 
-    // 3. Import the runtime features and network
+    // 3. Import the `ChatCompletionSettings`s.
+    for result in dump_reader.chat_completions_settings()? {
+        let (name, settings) = result?;
+        index_scheduler.put_chat_settings(&name, &settings)?;
+    }
+
+    // 4. Import the runtime features and network
     let features = dump_reader.features()?.unwrap_or_default();
     index_scheduler.put_runtime_features(features)?;
 
     let network = dump_reader.network()?.cloned().unwrap_or_default();
     index_scheduler.put_network(network)?;
 
-    // 3.1 Use all cpus to process dump if `max_indexing_threads` not configured
+    // 4.1 Use all cpus to process dump if `max_indexing_threads` not configured
     let backup_config;
     let base_config = index_scheduler.indexer_config();
 
@@ -520,7 +528,7 @@ fn import_dump(
     // /!\ The tasks must be imported AFTER importing the indexes or else the scheduler might
     // try to process tasks while we're trying to import the indexes.
 
-    // 4. Import the indexes.
+    // 5. Import the indexes.
     for index_reader in dump_reader.indexes()? {
         let mut index_reader = index_reader?;
         let metadata = index_reader.metadata();
@@ -533,20 +541,20 @@ fn import_dump(
         let mut wtxn = index.write_txn()?;
 
         let mut builder = milli::update::Settings::new(&mut wtxn, &index, indexer_config);
-        // 4.1 Import the primary key if there is one.
+        // 5.1 Import the primary key if there is one.
         if let Some(ref primary_key) = metadata.primary_key {
             builder.set_primary_key(primary_key.to_string());
         }
 
-        // 4.2 Import the settings.
+        // 5.2 Import the settings.
         tracing::info!("Importing the settings.");
         let settings = index_reader.settings()?;
         apply_settings_to_builder(&settings, &mut builder);
-        builder
-            .execute(|indexing_step| tracing::debug!("update: {:?}", indexing_step), || false)?;
+        let embedder_stats: Arc<EmbedderStats> = Default::default();
+        builder.execute(&|| false, &progress, embedder_stats.clone())?;
 
-        // 4.3 Import the documents.
-        // 4.3.1 We need to recreate the grenad+obkv format accepted by the index.
+        // 5.3 Import the documents.
+        // 5.3.1 We need to recreate the grenad+obkv format accepted by the index.
         tracing::info!("Importing the documents.");
         let file = tempfile::tempfile()?;
         let mut builder = DocumentsBatchBuilder::new(BufWriter::new(file));
@@ -557,11 +565,11 @@ fn import_dump(
         // This flush the content of the batch builder.
         let file = builder.into_inner()?.into_inner()?;
 
-        // 4.3.2 We feed it to the milli index.
+        // 5.3.2 We feed it to the milli index.
         let reader = BufReader::new(file);
         let reader = DocumentsBatchReader::from_reader(reader)?;
 
-        let embedder_configs = index.embedding_configs(&wtxn)?;
+        let embedder_configs = index.embedding_configs().embedding_configs(&wtxn)?;
         let embedders = index_scheduler.embedders(uid.to_string(), embedder_configs)?;
 
         let builder = milli::update::IndexDocuments::new(
@@ -574,6 +582,7 @@ fn import_dump(
             },
             |indexing_step| tracing::trace!("update: {:?}", indexing_step),
             || false,
+            &embedder_stats,
         )?;
 
         let builder = builder.with_embedders(embedders);
@@ -588,15 +597,15 @@ fn import_dump(
         index_scheduler.refresh_index_stats(&uid)?;
     }
 
-    // 5. Import the queue
+    // 6. Import the queue
     let mut index_scheduler_dump = index_scheduler.register_dumped_task()?;
-    // 5.1. Import the batches
+    // 6.1. Import the batches
     for ret in dump_reader.batches()? {
         let batch = ret?;
         index_scheduler_dump.register_dumped_batch(batch)?;
     }
 
-    // 5.2. Import the tasks
+    // 6.2. Import the tasks
     for ret in dump_reader.tasks()? {
         let (task, file) = ret?;
         index_scheduler_dump.register_dumped_task(task, file)?;

crates/meilisearch/src/metrics.rs

@@ -15,6 +15,33 @@ lazy_static! {
         "Meilisearch number of degraded search requests"
     ))
     .expect("Can't create a metric");
+    pub static ref MEILISEARCH_CHAT_SEARCH_REQUESTS: IntCounterVec = register_int_counter_vec!(
+        opts!(
+            "meilisearch_chat_search_requests",
+            "Meilisearch number of search requests performed by the chat route itself"
+        ),
+        &["type"]
+    )
+    .expect("Can't create a metric");
+    pub static ref MEILISEARCH_CHAT_PROMPT_TOKENS_USAGE: IntCounterVec = register_int_counter_vec!(
+        opts!("meilisearch_chat_prompt_tokens_usage", "Meilisearch Chat Prompt Tokens Usage"),
+        &["workspace", "model"]
+    )
+    .expect("Can't create a metric");
+    pub static ref MEILISEARCH_CHAT_COMPLETION_TOKENS_USAGE: IntCounterVec =
+        register_int_counter_vec!(
+            opts!(
+                "meilisearch_chat_completion_tokens_usage",
+                "Meilisearch Chat Completion Tokens Usage"
+            ),
+            &["workspace", "model"]
+        )
+        .expect("Can't create a metric");
+    pub static ref MEILISEARCH_CHAT_TOTAL_TOKENS_USAGE: IntCounterVec = register_int_counter_vec!(
+        opts!("meilisearch_chat_total_tokens_usage", "Meilisearch Chat Total Tokens Usage"),
+        &["workspace", "model"]
+    )
+    .expect("Can't create a metric");
     pub static ref MEILISEARCH_DB_SIZE_BYTES: IntGauge =
         register_int_gauge!(opts!("meilisearch_db_size_bytes", "Meilisearch DB Size In Bytes"))
             .expect("Can't create a metric");

crates/meilisearch/src/option.rs

@@ -53,6 +53,8 @@ const MEILI_EXPERIMENTAL_DUMPLESS_UPGRADE: &str = "MEILI_EXPERIMENTAL_DUMPLESS_U
 const MEILI_EXPERIMENTAL_REPLICATION_PARAMETERS: &str = "MEILI_EXPERIMENTAL_REPLICATION_PARAMETERS";
 const MEILI_EXPERIMENTAL_ENABLE_LOGS_ROUTE: &str = "MEILI_EXPERIMENTAL_ENABLE_LOGS_ROUTE";
 const MEILI_EXPERIMENTAL_CONTAINS_FILTER: &str = "MEILI_EXPERIMENTAL_CONTAINS_FILTER";
+const MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_SETTINGS: &str =
+    "MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_SETTINGS";
 const MEILI_EXPERIMENTAL_ENABLE_METRICS: &str = "MEILI_EXPERIMENTAL_ENABLE_METRICS";
 const MEILI_EXPERIMENTAL_SEARCH_QUEUE_SIZE: &str = "MEILI_EXPERIMENTAL_SEARCH_QUEUE_SIZE";
 const MEILI_EXPERIMENTAL_DROP_SEARCH_AFTER: &str = "MEILI_EXPERIMENTAL_DROP_SEARCH_AFTER";
@@ -62,7 +64,7 @@ const MEILI_EXPERIMENTAL_REDUCE_INDEXING_MEMORY_USAGE: &str =
 const MEILI_EXPERIMENTAL_MAX_NUMBER_OF_BATCHED_TASKS: &str =
     "MEILI_EXPERIMENTAL_MAX_NUMBER_OF_BATCHED_TASKS";
 const MEILI_EXPERIMENTAL_LIMIT_BATCHED_TASKS_TOTAL_SIZE: &str =
-    "MEILI_EXPERIMENTAL_LIMIT_BATCHED_TASKS_SIZE";
+    "MEILI_EXPERIMENTAL_LIMIT_BATCHED_TASKS_TOTAL_SIZE";
 const MEILI_EXPERIMENTAL_EMBEDDING_CACHE_ENTRIES: &str =
     "MEILI_EXPERIMENTAL_EMBEDDING_CACHE_ENTRIES";
 const MEILI_EXPERIMENTAL_NO_SNAPSHOT_COMPACTION: &str = "MEILI_EXPERIMENTAL_NO_SNAPSHOT_COMPACTION";
@@ -749,12 +751,25 @@ pub struct IndexerOpts {
     #[clap(skip)]
     #[serde(skip)]
     pub skip_index_budget: bool,
+
+    /// Experimental no edition 2024 for settings feature. For more information,
+    /// see: <https://github.com/orgs/meilisearch/discussions/847>
+    ///
+    /// Enables the experimental no edition 2024 for settings feature.
+    #[clap(long, env = MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_SETTINGS)]
+    #[serde(default)]
+    pub experimental_no_edition_2024_for_settings: bool,
 }
 
 impl IndexerOpts {
     /// Exports the values to their corresponding env vars if they are not set.
     pub fn export_to_env(self) {
-        let IndexerOpts { max_indexing_memory, max_indexing_threads, skip_index_budget: _ } = self;
+        let IndexerOpts {
+            max_indexing_memory,
+            max_indexing_threads,
+            skip_index_budget: _,
+            experimental_no_edition_2024_for_settings,
+        } = self;
         if let Some(max_indexing_memory) = max_indexing_memory.0 {
             export_to_env_if_not_present(
                 MEILI_MAX_INDEXING_MEMORY,
@@ -767,6 +782,12 @@ impl IndexerOpts {
                 max_indexing_threads.to_string(),
             );
         }
+        if experimental_no_edition_2024_for_settings {
+            export_to_env_if_not_present(
+                MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_SETTINGS,
+                experimental_no_edition_2024_for_settings.to_string(),
+            );
+        }
     }
 }
 
@@ -785,7 +806,12 @@ impl TryFrom<&IndexerOpts> for IndexerConfig {
             max_threads: *other.max_indexing_threads,
             max_positions_per_attributes: None,
             skip_index_budget: other.skip_index_budget,
-            ..Default::default()
+            experimental_no_edition_2024_for_settings: other
+                .experimental_no_edition_2024_for_settings,
+            chunk_compression_type: Default::default(),
+            chunk_compression_level: Default::default(),
+            documents_chunk_size: Default::default(),
+            max_nb_chunks: Default::default(),
         })
     }
 }

crates/meilisearch/src/routes/chats/chat_completion_analytics.rs

@@ -0,0 +1,135 @@
+use std::collections::BinaryHeap;
+
+use serde_json::{json, Value};
+
+use crate::analytics::Aggregate;
+
+#[derive(Default)]
+pub struct ChatCompletionAggregator {
+    // requests
+    total_received: usize,
+    total_succeeded: usize,
+    time_spent: BinaryHeap<usize>,
+
+    // chat completion specific metrics
+    total_messages: usize,
+    total_streamed_requests: usize,
+    total_non_streamed_requests: usize,
+
+    // model usage tracking
+    models_used: std::collections::HashMap<String, usize>,
+}
+
+impl ChatCompletionAggregator {
+    pub fn from_request(model: &str, message_count: usize, is_stream: bool) -> Self {
+        let mut models_used = std::collections::HashMap::new();
+        models_used.insert(model.to_string(), 1);
+
+        Self {
+            total_received: 1,
+            total_succeeded: 0,
+            time_spent: BinaryHeap::new(),
+
+            total_messages: message_count,
+            total_streamed_requests: if is_stream { 1 } else { 0 },
+            total_non_streamed_requests: if is_stream { 0 } else { 1 },
+
+            models_used,
+        }
+    }
+
+    pub fn succeed(&mut self, time_spent: std::time::Duration) {
+        self.total_succeeded += 1;
+        self.time_spent.push(time_spent.as_millis() as usize);
+    }
+}
+
+impl Aggregate for ChatCompletionAggregator {
+    fn event_name(&self) -> &'static str {
+        "Chat Completion POST"
+    }
+
+    fn aggregate(mut self: Box<Self>, new: Box<Self>) -> Box<Self> {
+        let Self {
+            total_received,
+            total_succeeded,
+            mut time_spent,
+            total_messages,
+            total_streamed_requests,
+            total_non_streamed_requests,
+            models_used,
+            ..
+        } = *new;
+
+        // Aggregate time spent
+        self.time_spent.append(&mut time_spent);
+
+        // Aggregate counters
+        self.total_received = self.total_received.saturating_add(total_received);
+        self.total_succeeded = self.total_succeeded.saturating_add(total_succeeded);
+        self.total_messages = self.total_messages.saturating_add(total_messages);
+        self.total_streamed_requests =
+            self.total_streamed_requests.saturating_add(total_streamed_requests);
+        self.total_non_streamed_requests =
+            self.total_non_streamed_requests.saturating_add(total_non_streamed_requests);
+
+        // Aggregate model usage
+        for (model, count) in models_used {
+            *self.models_used.entry(model).or_insert(0) += count;
+        }
+
+        self
+    }
+
+    fn into_event(self: Box<Self>) -> Value {
+        let Self {
+            total_received,
+            total_succeeded,
+            time_spent,
+            total_messages,
+            total_streamed_requests,
+            total_non_streamed_requests,
+            models_used,
+            ..
+        } = *self;
+
+        // Compute time statistics
+        let time_spent: Vec<usize> = time_spent.into_sorted_vec();
+        let (max_time, min_time, avg_time) = if time_spent.is_empty() {
+            (0, 0, 0)
+        } else {
+            let max_time = time_spent.last().unwrap_or(&0);
+            let min_time = time_spent.first().unwrap_or(&0);
+            let sum: usize = time_spent.iter().sum();
+            let avg_time = sum / time_spent.len();
+            (*max_time, *min_time, avg_time)
+        };
+
+        // Compute average messages per request
+        let avg_messages_per_request =
+            if total_received > 0 { total_messages as f64 / total_received as f64 } else { 0.0 };
+
+        // Compute streaming vs non-streaming proportions
+        let streaming_ratio = if total_received > 0 {
+            total_streamed_requests as f64 / total_received as f64
+        } else {
+            0.0
+        };
+
+        json!({
+            "total_received": total_received,
+            "total_succeeded": total_succeeded,
+            "time_spent": {
+                "max": max_time,
+                "min": min_time,
+                "avg": avg_time
+            },
+            "total_messages": total_messages,
+            "avg_messages_per_request": avg_messages_per_request,
+            "total_streamed_requests": total_streamed_requests,
+            "total_non_streamed_requests": total_non_streamed_requests,
+            "streaming_ratio": streaming_ratio,
+            "models_used": models_used,
+        })
+    }
+}

crates/meilisearch/src/routes/chats/chat_completions.rs

@@ -13,9 +13,9 @@ use async_openai::types::{
     ChatCompletionRequestDeveloperMessageContent, ChatCompletionRequestMessage,
     ChatCompletionRequestSystemMessage, ChatCompletionRequestSystemMessageContent,
     ChatCompletionRequestToolMessage, ChatCompletionRequestToolMessageContent,
-    ChatCompletionStreamResponseDelta, ChatCompletionToolArgs, ChatCompletionToolType,
-    CreateChatCompletionRequest, CreateChatCompletionStreamResponse, FinishReason, FunctionCall,
-    FunctionCallStream, FunctionObjectArgs,
+    ChatCompletionStreamOptions, ChatCompletionStreamResponseDelta, ChatCompletionToolArgs,
+    ChatCompletionToolType, CreateChatCompletionRequest, CreateChatCompletionStreamResponse,
+    FinishReason, FunctionCall, FunctionCallStream, FunctionObjectArgs,
 };
 use async_openai::Client;
 use bumpalo::Bump;
@@ -36,6 +36,7 @@ use serde_json::json;
 use tokio::runtime::Handle;
 use tokio::sync::mpsc::error::SendError;
 
+use super::chat_completion_analytics::ChatCompletionAggregator;
 use super::config::Config;
 use super::errors::{MistralError, OpenAiOutsideError, StreamErrorEvent};
 use super::utils::format_documents;
@@ -43,10 +44,15 @@ use super::{
     ChatsParam, MEILI_APPEND_CONVERSATION_MESSAGE_NAME, MEILI_SEARCH_IN_INDEX_FUNCTION_NAME,
     MEILI_SEARCH_PROGRESS_NAME, MEILI_SEARCH_SOURCES_NAME,
 };
+use crate::analytics::Analytics;
 use crate::error::MeilisearchHttpError;
 use crate::extractors::authentication::policies::ActionPolicy;
 use crate::extractors::authentication::{extract_token_from_request, GuardedData, Policy as _};
-use crate::metrics::MEILISEARCH_DEGRADED_SEARCH_REQUESTS;
+use crate::metrics::{
+    MEILISEARCH_CHAT_COMPLETION_TOKENS_USAGE, MEILISEARCH_CHAT_PROMPT_TOKENS_USAGE,
+    MEILISEARCH_CHAT_SEARCH_REQUESTS, MEILISEARCH_CHAT_TOTAL_TOKENS_USAGE,
+    MEILISEARCH_DEGRADED_SEARCH_REQUESTS,
+};
 use crate::routes::chats::utils::SseEventSender;
 use crate::routes::indexes::search::search_kind;
 use crate::search::{add_search_rules, prepare_search, search_from_kind, SearchQuery};
@@ -64,6 +70,7 @@ async fn chat(
     req: HttpRequest,
     search_queue: web::Data<SearchQueue>,
     web::Json(chat_completion): web::Json<CreateChatCompletionRequest>,
+    analytics: web::Data<Analytics>,
 ) -> impl Responder {
     let ChatsParam { workspace_uid } = chats_param.into_inner();
 
@@ -76,6 +83,7 @@ async fn chat(
                 &workspace_uid,
                 req,
                 chat_completion,
+                analytics,
             )
             .await,
         )
@@ -88,6 +96,7 @@ async fn chat(
                 &workspace_uid,
                 req,
                 chat_completion,
+                analytics,
             )
             .await,
         )
@@ -281,7 +290,7 @@ async fn process_search_request(
     let output = output?;
     let mut documents = Vec::new();
     if let Ok((ref rtxn, ref search_result)) = output {
-        // aggregate.succeed(search_result);
+        MEILISEARCH_CHAT_SEARCH_REQUESTS.with_label_values(&["internal"]).inc();
         if search_result.degraded {
             MEILISEARCH_DEGRADED_SEARCH_REQUESTS.inc();
         }
@@ -315,9 +324,18 @@ async fn non_streamed_chat(
     workspace_uid: &str,
     req: HttpRequest,
     chat_completion: CreateChatCompletionRequest,
+    analytics: web::Data<Analytics>,
 ) -> Result<HttpResponse, ResponseError> {
     index_scheduler.features().check_chat_completions("using the /chats chat completions route")?;
 
+    // Create analytics aggregator
+    let aggregate = ChatCompletionAggregator::from_request(
+        &chat_completion.model,
+        chat_completion.messages.len(),
+        false, // non_streamed_chat is not streaming
+    );
+    let start_time = std::time::Instant::now();
+
     if let Some(n) = chat_completion.n.filter(|&n| n != 1) {
         return Err(ResponseError::from_msg(
             format!("You tried to specify n = {n} but only single choices are supported (n = 1)."),
@@ -414,6 +432,11 @@ async fn non_streamed_chat(
         }
     }
 
+    // Record success in analytics
+    let mut aggregate = aggregate;
+    aggregate.succeed(start_time.elapsed());
+    analytics.publish(aggregate, &req);
+
     Ok(HttpResponse::Ok().json(response))
 }
 
@@ -424,6 +447,7 @@ async fn streamed_chat(
     workspace_uid: &str,
     req: HttpRequest,
     mut chat_completion: CreateChatCompletionRequest,
+    analytics: web::Data<Analytics>,
 ) -> Result<impl Responder, ResponseError> {
     index_scheduler.features().check_chat_completions("using the /chats chat completions route")?;
     let filters = index_scheduler.filters();
@@ -445,6 +469,14 @@ async fn streamed_chat(
         }
     };
 
+    // Create analytics aggregator
+    let mut aggregate = ChatCompletionAggregator::from_request(
+        &chat_completion.model,
+        chat_completion.messages.len(),
+        true, // streamed_chat is always streaming
+    );
+    let start_time = std::time::Instant::now();
+
     let config = Config::new(&chat_settings);
     let auth_token = extract_token_from_request(&req)?.unwrap().to_string();
     let system_role = chat_settings.source.system_role(&chat_completion.model);
@@ -460,6 +492,7 @@ async fn streamed_chat(
 
     let (tx, rx) = tokio::sync::mpsc::channel(10);
     let tx = SseEventSender::new(tx);
+    let workspace_uid = workspace_uid.to_string();
     let _join_handle = Handle::current().spawn(async move {
         let client = Client::with_config(config.clone());
         let mut global_tool_calls = HashMap::<u32, Call>::new();
@@ -469,6 +502,7 @@ async fn streamed_chat(
             let output = run_conversation(
                 &index_scheduler,
                 &auth_ctrl,
+                &workspace_uid,
                 &search_queue,
                 &auth_token,
                 &client,
@@ -490,6 +524,10 @@ async fn streamed_chat(
         let _ = tx.stop().await;
     });
 
+    // Record success in analytics after the stream is set up
+    aggregate.succeed(start_time.elapsed());
+    analytics.publish(aggregate, &req);
+
     Ok(Sse::from_infallible_receiver(rx).with_retry_duration(Duration::from_secs(10)))
 }
 
@@ -502,6 +540,7 @@ async fn run_conversation<C: async_openai::config::Config>(
         Data<IndexScheduler>,
     >,
     auth_ctrl: &web::Data<AuthController>,
+    workspace_uid: &str,
     search_queue: &web::Data<SearchQueue>,
     auth_token: &str,
     client: &Client<C>,
@@ -511,13 +550,34 @@ async fn run_conversation<C: async_openai::config::Config>(
     global_tool_calls: &mut HashMap<u32, Call>,
     function_support: FunctionSupport,
 ) -> Result<ControlFlow<Option<FinishReason>, ()>, SendError<Event>> {
+    use DbChatCompletionSource::*;
+
     let mut finish_reason = None;
+    chat_completion.stream_options = match source {
+        OpenAi | AzureOpenAi => Some(ChatCompletionStreamOptions { include_usage: true }),
+        Mistral | VLlm => None,
+    };
+
     // safety: unwrap: can only happens if `stream` was set to `false`
     let mut response = client.chat().create_stream(chat_completion.clone()).await.unwrap();
     while let Some(result) = response.next().await {
         match result {
             Ok(resp) => {
-                let choice = &resp.choices[0];
+                if let Some(usage) = resp.usage.as_ref() {
+                    MEILISEARCH_CHAT_PROMPT_TOKENS_USAGE
+                        .with_label_values(&[workspace_uid, &chat_completion.model])
+                        .inc_by(usage.prompt_tokens as u64);
+                    MEILISEARCH_CHAT_COMPLETION_TOKENS_USAGE
+                        .with_label_values(&[workspace_uid, &chat_completion.model])
+                        .inc_by(usage.completion_tokens as u64);
+                    MEILISEARCH_CHAT_TOTAL_TOKENS_USAGE
+                        .with_label_values(&[workspace_uid, &chat_completion.model])
+                        .inc_by(usage.total_tokens as u64);
+                }
+                let choice = match resp.choices.first() {
+                    Some(choice) => choice,
+                    None => break,
+                };
                 finish_reason = choice.finish_reason;
 
                 let ChatCompletionStreamResponseDelta { ref tool_calls, .. } = &choice.delta;

crates/meilisearch/src/routes/chats/mod.rs

@@ -19,6 +19,7 @@ use crate::extractors::authentication::policies::ActionPolicy;
 use crate::extractors::authentication::GuardedData;
 use crate::routes::PAGINATION_DEFAULT_LIMIT;
 
+mod chat_completion_analytics;
 pub mod chat_completions;
 mod config;
 mod errors;

crates/meilisearch/src/routes/export.rs

@@ -0,0 +1,183 @@
+use std::collections::BTreeMap;
+use std::convert::Infallible;
+use std::str::FromStr as _;
+
+use actix_web::web::{self, Data};
+use actix_web::{HttpRequest, HttpResponse};
+use byte_unit::Byte;
+use deserr::actix_web::AwebJson;
+use deserr::Deserr;
+use index_scheduler::IndexScheduler;
+use meilisearch_types::deserr::DeserrJsonError;
+use meilisearch_types::error::deserr_codes::*;
+use meilisearch_types::error::ResponseError;
+use meilisearch_types::index_uid_pattern::IndexUidPattern;
+use meilisearch_types::keys::actions;
+use meilisearch_types::tasks::{ExportIndexSettings as DbExportIndexSettings, KindWithContent};
+use serde::Serialize;
+use serde_json::Value;
+use tracing::debug;
+use utoipa::{OpenApi, ToSchema};
+
+use crate::analytics::Analytics;
+use crate::extractors::authentication::policies::ActionPolicy;
+use crate::extractors::authentication::GuardedData;
+use crate::routes::export_analytics::ExportAnalytics;
+use crate::routes::{get_task_id, is_dry_run, SummarizedTaskView};
+use crate::Opt;
+
+#[derive(OpenApi)]
+#[openapi(
+    paths(export),
+    tags((
+        name = "Export",
+        description = "The `/export` route allows you to trigger an export process to a remote Meilisearch instance.",
+        external_docs(url = "https://www.meilisearch.com/docs/reference/api/export"),
+    )),
+)]
+pub struct ExportApi;
+
+pub fn configure(cfg: &mut web::ServiceConfig) {
+    cfg.service(web::resource("").route(web::post().to(export)));
+}
+
+#[utoipa::path(
+    post,
+    path = "",
+    tag = "Export",
+    security(("Bearer" = ["export", "*"])),
+    responses(
+        (status = 202, description = "Export successfully enqueued", body = SummarizedTaskView, content_type = "application/json", example = json!(
+            {
+                "taskUid": 1,
+                "status": "enqueued",
+                "type": "export",
+                "enqueuedAt": "2021-08-11T09:25:53.000000Z"
+            })),
+        (status = 401, description = "The authorization header is missing", body = ResponseError, content_type = "application/json", example = json!(
+            {
+                "message": "The Authorization header is missing. It must use the bearer authorization method.",
+                "code": "missing_authorization_header",
+                "type": "auth",
+                "link": "https://docs.meilisearch.com/errors#missing_authorization_header"
+            }
+        )),
+    )
+)]
+async fn export(
+    index_scheduler: GuardedData<ActionPolicy<{ actions::EXPORT }>, Data<IndexScheduler>>,
+    export: AwebJson<Export, DeserrJsonError>,
+    req: HttpRequest,
+    opt: web::Data<Opt>,
+    analytics: Data<Analytics>,
+) -> Result<HttpResponse, ResponseError> {
+    let export = export.into_inner();
+    debug!(returns = ?export, "Trigger export");
+
+    let analytics_aggregate = ExportAnalytics::from_export(&export);
+
+    let Export { url, api_key, payload_size, indexes } = export;
+
+    let indexes = match indexes {
+        Some(indexes) => indexes
+            .into_iter()
+            .map(|(pattern, ExportIndexSettings { filter, override_settings })| {
+                (pattern, DbExportIndexSettings { filter, override_settings })
+            })
+            .collect(),
+        None => BTreeMap::from([(
+            IndexUidPattern::new_unchecked("*"),
+            DbExportIndexSettings::default(),
+        )]),
+    };
+
+    let task = KindWithContent::Export {
+        url,
+        api_key,
+        payload_size: payload_size.map(|ByteWithDeserr(bytes)| bytes),
+        indexes,
+    };
+    let uid = get_task_id(&req, &opt)?;
+    let dry_run = is_dry_run(&req, &opt)?;
+    let task: SummarizedTaskView =
+        tokio::task::spawn_blocking(move || index_scheduler.register(task, uid, dry_run))
+            .await??
+            .into();
+
+    analytics.publish(analytics_aggregate, &req);
+
+    Ok(HttpResponse::Ok().json(task))
+}
+
+#[derive(Debug, Deserr, ToSchema, Serialize)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
+#[schema(rename_all = "camelCase")]
+pub struct Export {
+    #[schema(value_type = Option<String>, example = json!("https://ms-1234.heaven.meilisearch.com"))]
+    #[serde(default)]
+    #[deserr(default, error = DeserrJsonError<InvalidExportUrl>)]
+    pub url: String,
+    #[schema(value_type = Option<String>, example = json!("1234abcd"))]
+    #[serde(default)]
+    #[deserr(default, error = DeserrJsonError<InvalidExportApiKey>)]
+    pub api_key: Option<String>,
+    #[schema(value_type = Option<String>, example = json!("24MiB"))]
+    #[serde(default)]
+    #[deserr(default, error = DeserrJsonError<InvalidExportPayloadSize>)]
+    pub payload_size: Option<ByteWithDeserr>,
+    #[schema(value_type = Option<BTreeMap<String, ExportIndexSettings>>, example = json!({ "*": { "filter": null } }))]
+    #[deserr(default)]
+    #[serde(default)]
+    pub indexes: Option<BTreeMap<IndexUidPattern, ExportIndexSettings>>,
+}
+
+/// A wrapper around the `Byte` type that implements `Deserr`.
+#[derive(Debug, Serialize)]
+#[serde(transparent)]
+pub struct ByteWithDeserr(pub Byte);
+
+impl<E> deserr::Deserr<E> for ByteWithDeserr
+where
+    E: deserr::DeserializeError,
+{
+    fn deserialize_from_value<V: deserr::IntoValue>(
+        value: deserr::Value<V>,
+        location: deserr::ValuePointerRef,
+    ) -> Result<Self, E> {
+        use deserr::{ErrorKind, Value, ValueKind};
+        match value {
+            Value::Integer(integer) => Ok(ByteWithDeserr(Byte::from_u64(integer))),
+            Value::String(string) => Byte::from_str(&string).map(ByteWithDeserr).map_err(|e| {
+                deserr::take_cf_content(E::error::<Infallible>(
+                    None,
+                    ErrorKind::Unexpected { msg: e.to_string() },
+                    location,
+                ))
+            }),
+            actual => Err(deserr::take_cf_content(E::error(
+                None,
+                ErrorKind::IncorrectValueKind {
+                    actual,
+                    accepted: &[ValueKind::Integer, ValueKind::String],
+                },
+                location,
+            ))),
+        }
+    }
+}
+
+#[derive(Debug, Deserr, ToSchema, Serialize)]
+#[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
+#[serde(rename_all = "camelCase")]
+#[schema(rename_all = "camelCase")]
+pub struct ExportIndexSettings {
+    #[schema(value_type = Option<String>, example = json!("genres = action"))]
+    #[serde(default)]
+    #[deserr(default, error = DeserrJsonError<InvalidExportIndexFilter>)]
+    pub filter: Option<Value>,
+    #[schema(value_type = Option<bool>, example = json!(true))]
+    #[serde(default)]
+    #[deserr(default, error = DeserrJsonError<InvalidExportIndexOverrideSettings>)]
+    pub override_settings: bool,
+}

crates/meilisearch/src/routes/export_analytics.rs

@@ -0,0 +1,111 @@
+use url::Url;
+
+use crate::analytics::Aggregate;
+use crate::routes::export::Export;
+
+#[derive(Default)]
+pub struct ExportAnalytics {
+    total_received: usize,
+    has_api_key: bool,
+    sum_exports_meilisearch_cloud: usize,
+    sum_index_patterns: usize,
+    sum_patterns_with_filter: usize,
+    sum_patterns_with_override_settings: usize,
+    payload_sizes: Vec<u64>,
+}
+
+impl ExportAnalytics {
+    pub fn from_export(export: &Export) -> Self {
+        let Export { url, api_key, payload_size, indexes } = export;
+
+        let url = Url::parse(url).ok();
+        let is_meilisearch_cloud = url.as_ref().and_then(Url::host_str).is_some_and(|host| {
+            host.ends_with("meilisearch.dev")
+                || host.ends_with("meilisearch.com")
+                || host.ends_with("meilisearch.io")
+        });
+        let has_api_key = api_key.is_some();
+        let index_patterns_count = indexes.as_ref().map_or(0, |indexes| indexes.len());
+        let patterns_with_filter_count = indexes.as_ref().map_or(0, |indexes| {
+            indexes.values().filter(|settings| settings.filter.is_some()).count()
+        });
+        let patterns_with_override_settings_count = indexes.as_ref().map_or(0, |indexes| {
+            indexes.values().filter(|settings| settings.override_settings).count()
+        });
+        let payload_sizes =
+            if let Some(crate::routes::export::ByteWithDeserr(byte_size)) = payload_size {
+                vec![byte_size.as_u64()]
+            } else {
+                vec![]
+            };
+
+        Self {
+            total_received: 1,
+            has_api_key,
+            sum_exports_meilisearch_cloud: is_meilisearch_cloud as usize,
+            sum_index_patterns: index_patterns_count,
+            sum_patterns_with_filter: patterns_with_filter_count,
+            sum_patterns_with_override_settings: patterns_with_override_settings_count,
+            payload_sizes,
+        }
+    }
+}
+
+impl Aggregate for ExportAnalytics {
+    fn event_name(&self) -> &'static str {
+        "Export Triggered"
+    }
+
+    fn aggregate(mut self: Box<Self>, other: Box<Self>) -> Box<Self> {
+        self.total_received += other.total_received;
+        self.has_api_key |= other.has_api_key;
+        self.sum_exports_meilisearch_cloud += other.sum_exports_meilisearch_cloud;
+        self.sum_index_patterns += other.sum_index_patterns;
+        self.sum_patterns_with_filter += other.sum_patterns_with_filter;
+        self.sum_patterns_with_override_settings += other.sum_patterns_with_override_settings;
+        self.payload_sizes.extend(other.payload_sizes);
+        self
+    }
+
+    fn into_event(self: Box<Self>) -> serde_json::Value {
+        let avg_payload_size = if self.payload_sizes.is_empty() {
+            None
+        } else {
+            Some(self.payload_sizes.iter().sum::<u64>() / self.payload_sizes.len() as u64)
+        };
+
+        let avg_exports_meilisearch_cloud = if self.total_received == 0 {
+            None
+        } else {
+            Some(self.sum_exports_meilisearch_cloud as f64 / self.total_received as f64)
+        };
+
+        let avg_index_patterns = if self.total_received == 0 {
+            None
+        } else {
+            Some(self.sum_index_patterns as f64 / self.total_received as f64)
+        };
+
+        let avg_patterns_with_filter = if self.total_received == 0 {
+            None
+        } else {
+            Some(self.sum_patterns_with_filter as f64 / self.total_received as f64)
+        };
+
+        let avg_patterns_with_override_settings = if self.total_received == 0 {
+            None
+        } else {
+            Some(self.sum_patterns_with_override_settings as f64 / self.total_received as f64)
+        };
+
+        serde_json::json!({
+            "total_received": self.total_received,
+            "has_api_key": self.has_api_key,
+            "avg_exports_meilisearch_cloud": avg_exports_meilisearch_cloud,
+            "avg_index_patterns": avg_index_patterns,
+            "avg_patterns_with_filter": avg_patterns_with_filter,
+            "avg_patterns_with_override_settings": avg_patterns_with_override_settings,
+            "avg_payload_size": avg_payload_size,
+        })
+    }
+}

crates/meilisearch/src/routes/features.rs

@@ -54,6 +54,7 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
             get_task_documents_route: Some(false),
             composite_embedders: Some(false),
             chat_completions: Some(false),
+            multimodal: Some(false),
         })),
         (status = 401, description = "The authorization header is missing", body = ResponseError, content_type = "application/json", example = json!(
             {
@@ -100,6 +101,8 @@ pub struct RuntimeTogglableFeatures {
     pub composite_embedders: Option<bool>,
     #[deserr(default)]
     pub chat_completions: Option<bool>,
+    #[deserr(default)]
+    pub multimodal: Option<bool>,
 }
 
 impl From<meilisearch_types::features::RuntimeTogglableFeatures> for RuntimeTogglableFeatures {
@@ -113,6 +116,7 @@ impl From<meilisearch_types::features::RuntimeTogglableFeatures> for RuntimeTogg
             get_task_documents_route,
             composite_embedders,
             chat_completions,
+            multimodal,
         } = value;
 
         Self {
@@ -124,6 +128,7 @@ impl From<meilisearch_types::features::RuntimeTogglableFeatures> for RuntimeTogg
             get_task_documents_route: Some(get_task_documents_route),
             composite_embedders: Some(composite_embedders),
             chat_completions: Some(chat_completions),
+            multimodal: Some(multimodal),
         }
     }
 }
@@ -138,6 +143,7 @@ pub struct PatchExperimentalFeatureAnalytics {
     get_task_documents_route: bool,
     composite_embedders: bool,
     chat_completions: bool,
+    multimodal: bool,
 }
 
 impl Aggregate for PatchExperimentalFeatureAnalytics {
@@ -155,6 +161,7 @@ impl Aggregate for PatchExperimentalFeatureAnalytics {
             get_task_documents_route: new.get_task_documents_route,
             composite_embedders: new.composite_embedders,
             chat_completions: new.chat_completions,
+            multimodal: new.multimodal,
         })
     }
 
@@ -181,6 +188,7 @@ impl Aggregate for PatchExperimentalFeatureAnalytics {
             get_task_documents_route: Some(false),
             composite_embedders: Some(false),
             chat_completions: Some(false),
+            multimodal: Some(false),
          })),
         (status = 401, description = "The authorization header is missing", body = ResponseError, content_type = "application/json", example = json!(
             {
@@ -223,6 +231,7 @@ async fn patch_features(
             .composite_embedders
             .unwrap_or(old_features.composite_embedders),
         chat_completions: new_features.0.chat_completions.unwrap_or(old_features.chat_completions),
+        multimodal: new_features.0.multimodal.unwrap_or(old_features.multimodal),
     };
 
     // explicitly destructure for analytics rather than using the `Serialize` implementation, because
@@ -237,6 +246,7 @@ async fn patch_features(
         get_task_documents_route,
         composite_embedders,
         chat_completions,
+        multimodal,
     } = new_features;
 
     analytics.publish(
@@ -249,6 +259,7 @@ async fn patch_features(
             get_task_documents_route,
             composite_embedders,
             chat_completions,
+            multimodal,
         },
         &req,
     );

crates/meilisearch/src/routes/indexes/documents.rs

@@ -1445,7 +1445,6 @@ fn some_documents<'a, 't: 'a>(
 ) -> Result<impl Iterator<Item = Result<Document, ResponseError>> + 'a, ResponseError> {
     let fields_ids_map = index.fields_ids_map(rtxn)?;
     let all_fields: Vec<_> = fields_ids_map.iter().map(|(id, _)| id).collect();
-    let embedding_configs = index.embedding_configs(rtxn)?;
 
     Ok(index.iter_documents(rtxn, doc_ids)?.map(move |ret| {
         ret.map_err(ResponseError::from).and_then(|(key, document)| -> Result<_, ResponseError> {
@@ -1461,15 +1460,9 @@ fn some_documents<'a, 't: 'a>(
                         Some(Value::Object(map)) => map,
                         _ => Default::default(),
                     };
-                    for (name, vector) in index.embeddings(rtxn, key)? {
-                        let user_provided = embedding_configs
-                            .iter()
-                            .find(|conf| conf.name == name)
-                            .is_some_and(|conf| conf.user_provided.contains(key));
-                        let embeddings = ExplicitVectors {
-                            embeddings: Some(vector.into()),
-                            regenerate: !user_provided,
-                        };
+                    for (name, (vector, regenerate)) in index.embeddings(rtxn, key)? {
+                        let embeddings =
+                            ExplicitVectors { embeddings: Some(vector.into()), regenerate };
                         vectors.insert(
                             name,
                             serde_json::to_value(embeddings).map_err(MeilisearchHttpError::from)?,

crates/meilisearch/src/routes/indexes/facet_search.rs

@@ -56,6 +56,8 @@ pub struct FacetSearchQuery {
     pub q: Option<String>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchVector>)]
     pub vector: Option<Vec<f32>>,
+    #[deserr(default, error = DeserrJsonError<InvalidSearchMedia>)]
+    pub media: Option<Value>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchHybridQuery>)]
     pub hybrid: Option<HybridQuery>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchFilter>)]
@@ -94,6 +96,7 @@ impl FacetSearchAggregator {
             facet_name,
             vector,
             q,
+            media,
             filter,
             matching_strategy,
             attributes_to_search_on,
@@ -108,6 +111,7 @@ impl FacetSearchAggregator {
             facet_names: Some(facet_name.clone()).into_iter().collect(),
             additional_search_parameters_provided: q.is_some()
                 || vector.is_some()
+                || media.is_some()
                 || filter.is_some()
                 || *matching_strategy != MatchingStrategy::default()
                 || attributes_to_search_on.is_some()
@@ -291,6 +295,7 @@ impl From<FacetSearchQuery> for SearchQuery {
             facet_name: _,
             q,
             vector,
+            media,
             filter,
             matching_strategy,
             attributes_to_search_on,
@@ -312,6 +317,7 @@ impl From<FacetSearchQuery> for SearchQuery {
 
         SearchQuery {
             q,
+            media,
             offset: DEFAULT_SEARCH_OFFSET(),
             limit: DEFAULT_SEARCH_LIMIT(),
             page,

crates/meilisearch/src/routes/indexes/search.rs

@@ -205,6 +205,8 @@ impl TryFrom<SearchQueryGet> for SearchQuery {
 
         Ok(Self {
             q: other.q,
+            // `media` not supported for `GET`
+            media: None,
             vector: other.vector.map(CS::into_inner),
             offset: other.offset.0,
             limit: other.limit.0,
@@ -481,28 +483,30 @@ pub fn search_kind(
     index_uid: String,
     index: &milli::Index,
 ) -> Result<SearchKind, ResponseError> {
+    let is_placeholder_query =
+        if let Some(q) = query.q.as_deref() { q.trim().is_empty() } else { true };
+    let non_placeholder_query = !is_placeholder_query;
+    let is_media = query.media.is_some();
     // handle with care, the order of cases matters, the semantics is subtle
-    match (query.q.as_deref(), &query.hybrid, query.vector.as_deref()) {
-        // empty query, no vector => placeholder search
-        (Some(q), _, None) if q.trim().is_empty() => Ok(SearchKind::KeywordOnly),
-        // no query, no vector => placeholder search
-        (None, _, None) => Ok(SearchKind::KeywordOnly),
-        // hybrid.semantic_ratio == 1.0 => vector
-        (_, Some(HybridQuery { semantic_ratio, embedder }), v) if **semantic_ratio == 1.0 => {
-            SearchKind::semantic(index_scheduler, index_uid, index, embedder, v.map(|v| v.len()))
-        }
-        // hybrid.semantic_ratio == 0.0 => keyword
-        (_, Some(HybridQuery { semantic_ratio, embedder: _ }), _) if **semantic_ratio == 0.0 => {
+    match (is_media, non_placeholder_query, &query.hybrid, query.vector.as_deref()) {
+        // media + vector => error
+        (true, _, _, Some(_)) => Err(MeilisearchHttpError::MediaAndVector.into()),
+        // media + !hybrid => error
+        (true, _, None, _) => Err(MeilisearchHttpError::MissingSearchHybrid.into()),
+        // vector + !hybrid => error
+        (_, _, None, Some(_)) => Err(MeilisearchHttpError::MissingSearchHybrid.into()),
+        // hybrid S0 => keyword
+        (_, _, Some(HybridQuery { semantic_ratio, embedder: _ }), _) if **semantic_ratio == 0.0 => {
             Ok(SearchKind::KeywordOnly)
         }
-        // no query, hybrid, vector => semantic
-        (None, Some(HybridQuery { semantic_ratio: _, embedder }), Some(v)) => {
-            SearchKind::semantic(index_scheduler, index_uid, index, embedder, Some(v.len()))
+        // !q + !vector => placeholder search
+        (false, false, _, None) => Ok(SearchKind::KeywordOnly),
+        // hybrid S100 => semantic
+        (_, _, Some(HybridQuery { semantic_ratio, embedder }), v) if **semantic_ratio == 1.0 => {
+            SearchKind::semantic(index_scheduler, index_uid, index, embedder, v.map(|v| v.len()))
         }
-        // query, no hybrid, no vector => keyword
-        (Some(_), None, None) => Ok(SearchKind::KeywordOnly),
-        // query, hybrid, maybe vector => hybrid
-        (Some(_), Some(HybridQuery { semantic_ratio, embedder }), v) => SearchKind::hybrid(
+        // q + hybrid => hybrid
+        (_, true, Some(HybridQuery { semantic_ratio, embedder }), v) => SearchKind::hybrid(
             index_scheduler,
             index_uid,
             index,
@@ -510,7 +514,11 @@ pub fn search_kind(
             **semantic_ratio,
             v.map(|v| v.len()),
         ),
-
-        (_, None, Some(_)) => Err(MeilisearchHttpError::MissingSearchHybrid.into()),
+        // !q + hybrid => semantic
+        (_, false, Some(HybridQuery { semantic_ratio: _, embedder }), v) => {
+            SearchKind::semantic(index_scheduler, index_uid, index, embedder, v.map(|v| v.len()))
+        }
+        // q => keyword
+        (false, true, None, None) => Ok(SearchKind::KeywordOnly),
     }
 }

crates/meilisearch/src/routes/indexes/search_analytics.rs

@@ -61,6 +61,8 @@ pub struct SearchAggregator<Method: AggregateMethod> {
     semantic_ratio: bool,
     hybrid: bool,
     retrieve_vectors: bool,
+    // Number of requests containing `media`
+    total_media: usize,
 
     // every time a search is done, we increment the counter linked to the used settings
     matching_strategy: HashMap<String, usize>,
@@ -101,6 +103,7 @@ impl<Method: AggregateMethod> SearchAggregator<Method> {
         let SearchQuery {
             q,
             vector,
+            media,
             offset,
             limit,
             page,
@@ -175,6 +178,11 @@ impl<Method: AggregateMethod> SearchAggregator<Method> {
         if let Some(ref vector) = vector {
             ret.max_vector_size = vector.len();
         }
+
+        if media.is_some() {
+            ret.total_media = 1;
+        }
+
         ret.retrieve_vectors |= retrieve_vectors;
 
         if query.is_finite_pagination() {
@@ -277,6 +285,7 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
             show_ranking_score_details,
             semantic_ratio,
             hybrid,
+            total_media,
             total_degraded,
             total_used_negative_operator,
             ranking_score_threshold,
@@ -327,6 +336,7 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
         self.retrieve_vectors |= retrieve_vectors;
         self.semantic_ratio |= semantic_ratio;
         self.hybrid |= hybrid;
+        self.total_media += total_media;
 
         // pagination
         self.max_limit = self.max_limit.max(max_limit);
@@ -403,6 +413,7 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
             show_ranking_score_details,
             semantic_ratio,
             hybrid,
+            total_media,
             total_degraded,
             total_used_negative_operator,
             ranking_score_threshold,
@@ -450,6 +461,7 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
             "hybrid": {
                 "enabled": hybrid,
                 "semantic_ratio": semantic_ratio,
+                "total_media": total_media,
             },
             "pagination": {
                "max_limit": max_limit,

crates/meilisearch/src/routes/indexes/settings.rs

@@ -755,6 +755,14 @@ fn validate_settings(
             if matches!(embedder.indexing_embedder, Setting::Set(_)) {
                 features.check_composite_embedders("setting `indexingEmbedder`")?;
             }
+
+            if matches!(embedder.indexing_fragments, Setting::Set(_)) {
+                features.check_multimodal("setting `indexingFragments`")?;
+            }
+
+            if matches!(embedder.search_fragments, Setting::Set(_)) {
+                features.check_multimodal("setting `searchFragments`")?;
+            }
         }
     }
 

crates/meilisearch/src/routes/mod.rs

@@ -2,6 +2,7 @@ use std::collections::BTreeMap;
 
 use actix_web::web::Data;
 use actix_web::{web, HttpRequest, HttpResponse};
+use export::Export;
 use index_scheduler::IndexScheduler;
 use meilisearch_auth::AuthController;
 use meilisearch_types::batch_view::BatchView;
@@ -54,6 +55,8 @@ mod api_key;
 pub mod batches;
 pub mod chats;
 mod dump;
+mod export;
+mod export_analytics;
 pub mod features;
 pub mod indexes;
 mod logs;
@@ -84,6 +87,7 @@ mod tasks_test;
         (path = "/multi-search", api = multi_search::MultiSearchApi),
         (path = "/swap-indexes", api = swap_indexes::SwapIndexesApi),
         (path = "/experimental-features", api = features::ExperimentalFeaturesApi),
+        (path = "/export", api = export::ExportApi),
         (path = "/network", api = network::NetworkApi),
     ),
     paths(get_health, get_version, get_stats),
@@ -95,7 +99,7 @@ mod tasks_test;
         url = "/",
         description = "Local server",
     )),
-    components(schemas(PaginationView<KeyView>, PaginationView<IndexView>, IndexView, DocumentDeletionByFilter, AllBatches, BatchStats, ProgressStepView, ProgressView, BatchView, RuntimeTogglableFeatures, SwapIndexesPayload, DocumentEditionByFunction, MergeFacets, FederationOptions, SearchQueryWithIndex, Federation, FederatedSearch, FederatedSearchResult, SearchResults, SearchResultWithIndex, SimilarQuery, SimilarResult, PaginationView<serde_json::Value>, BrowseQuery, UpdateIndexRequest, IndexUid, IndexCreateRequest, KeyView, Action, CreateApiKey, UpdateStderrLogs, LogMode, GetLogs, IndexStats, Stats, HealthStatus, HealthResponse, VersionResponse, Code, ErrorType, AllTasks, TaskView, Status, DetailsView, ResponseError, Settings<Unchecked>, Settings<Checked>, TypoSettings, MinWordSizeTyposSetting, FacetingSettings, PaginationSettings, SummarizedTaskView, Kind, Network, Remote, FilterableAttributesRule, FilterableAttributesPatterns, AttributePatterns, FilterableAttributesFeatures, FilterFeatures))
+    components(schemas(PaginationView<KeyView>, PaginationView<IndexView>, IndexView, DocumentDeletionByFilter, AllBatches, BatchStats, ProgressStepView, ProgressView, BatchView, RuntimeTogglableFeatures, SwapIndexesPayload, DocumentEditionByFunction, MergeFacets, FederationOptions, SearchQueryWithIndex, Federation, FederatedSearch, FederatedSearchResult, SearchResults, SearchResultWithIndex, SimilarQuery, SimilarResult, PaginationView<serde_json::Value>, BrowseQuery, UpdateIndexRequest, IndexUid, IndexCreateRequest, KeyView, Action, CreateApiKey, UpdateStderrLogs, LogMode, GetLogs, IndexStats, Stats, HealthStatus, HealthResponse, VersionResponse, Code, ErrorType, AllTasks, TaskView, Status, DetailsView, ResponseError, Settings<Unchecked>, Settings<Checked>, TypoSettings, MinWordSizeTyposSetting, FacetingSettings, PaginationSettings, SummarizedTaskView, Kind, Network, Remote, FilterableAttributesRule, FilterableAttributesPatterns, AttributePatterns, FilterableAttributesFeatures, FilterFeatures, Export))
 )]
 pub struct MeilisearchApi;
 
@@ -115,6 +119,7 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
         .service(web::scope("/metrics").configure(metrics::configure))
         .service(web::scope("/experimental-features").configure(features::configure))
         .service(web::scope("/network").configure(network::configure))
+        .service(web::scope("/export").configure(export::configure))
         .service(web::scope("/chats").configure(chats::configure));
 
     #[cfg(feature = "swagger")]

crates/meilisearch/src/routes/multi_search_analytics.rs

@@ -42,6 +42,7 @@ impl MultiSearchAggregator {
             federation_options,
             q: _,
             vector: _,
+            media: _,
             offset: _,
             limit: _,
             page: _,

crates/meilisearch/src/routes/tasks_test.rs

@@ -228,7 +228,7 @@ mod tests {
             let err = deserr_query_params::<TaskDeletionOrCancelationQuery>(params).unwrap_err();
             snapshot!(meili_snap::json_string!(err), @r#"
             {
-              "message": "Invalid value in parameter `types`: `createIndex` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `upgradeDatabase`.",
+              "message": "Invalid value in parameter `types`: `createIndex` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `export`, `upgradeDatabase`.",
               "code": "invalid_task_types",
               "type": "invalid_request",
               "link": "https://docs.meilisearch.com/errors#invalid_task_types"

crates/meilisearch/src/search/mod.rs

@@ -64,6 +64,8 @@ pub struct SearchQuery {
     pub q: Option<String>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchVector>)]
     pub vector: Option<Vec<f32>>,
+    #[deserr(default, error = DeserrJsonError<InvalidSearchMedia>)]
+    pub media: Option<serde_json::Value>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchHybridQuery>)]
     pub hybrid: Option<HybridQuery>,
     #[deserr(default = DEFAULT_SEARCH_OFFSET(), error = DeserrJsonError<InvalidSearchOffset>)]
@@ -147,6 +149,7 @@ impl From<SearchParameters> for SearchQuery {
             ranking_score_threshold: ranking_score_threshold.map(RankingScoreThreshold::from),
             q: None,
             vector: None,
+            media: None,
             offset: DEFAULT_SEARCH_OFFSET(),
             page: None,
             hits_per_page: None,
@@ -220,6 +223,7 @@ impl fmt::Debug for SearchQuery {
         let Self {
             q,
             vector,
+            media,
             hybrid,
             offset,
             limit,
@@ -274,6 +278,9 @@ impl fmt::Debug for SearchQuery {
                 );
             }
         }
+        if let Some(media) = media {
+            debug.field("media", media);
+        }
         if let Some(hybrid) = hybrid {
             debug.field("hybrid", &hybrid);
         }
@@ -399,10 +406,10 @@ impl SearchKind {
         route: Route,
     ) -> Result<(String, Arc<Embedder>, bool), ResponseError> {
         let rtxn = index.read_txn()?;
-        let embedder_configs = index.embedding_configs(&rtxn)?;
+        let embedder_configs = index.embedding_configs().embedding_configs(&rtxn)?;
         let embedders = index_scheduler.embedders(index_uid, embedder_configs)?;
 
-        let (embedder, _, quantized) = embedders
+        let (embedder, quantized) = embedders
             .get(embedder_name)
             .ok_or(match route {
                 Route::Search | Route::MultiSearch => {
@@ -412,6 +419,7 @@ impl SearchKind {
                     milli::UserError::InvalidSimilarEmbedder(embedder_name.to_owned())
                 }
             })
+            .map(|runtime| (runtime.embedder.clone(), runtime.is_quantized))
             .map_err(milli::Error::from)?;
 
         if let Some(vector_len) = vector_len {
@@ -481,8 +489,10 @@ pub struct SearchQueryWithIndex {
     pub index_uid: IndexUid,
     #[deserr(default, error = DeserrJsonError<InvalidSearchQ>)]
     pub q: Option<String>,
-    #[deserr(default, error = DeserrJsonError<InvalidSearchQ>)]
+    #[deserr(default, error = DeserrJsonError<InvalidSearchVector>)]
     pub vector: Option<Vec<f32>>,
+    #[deserr(default, error = DeserrJsonError<InvalidSearchMedia>)]
+    pub media: Option<serde_json::Value>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchHybridQuery>)]
     pub hybrid: Option<HybridQuery>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchOffset>)]
@@ -563,6 +573,7 @@ impl SearchQueryWithIndex {
         let SearchQuery {
             q,
             vector,
+            media,
             hybrid,
             offset,
             limit,
@@ -593,6 +604,7 @@ impl SearchQueryWithIndex {
             index_uid,
             q,
             vector,
+            media,
             hybrid,
             offset: if offset == DEFAULT_SEARCH_OFFSET() { None } else { Some(offset) },
             limit: if limit == DEFAULT_SEARCH_LIMIT() { None } else { Some(limit) },
@@ -627,6 +639,7 @@ impl SearchQueryWithIndex {
             federation_options,
             q,
             vector,
+            media,
             offset,
             limit,
             page,
@@ -657,6 +670,7 @@ impl SearchQueryWithIndex {
             SearchQuery {
                 q,
                 vector,
+                media,
                 offset: offset.unwrap_or(DEFAULT_SEARCH_OFFSET()),
                 limit: limit.unwrap_or(DEFAULT_SEARCH_LIMIT()),
                 page,
@@ -958,6 +972,9 @@ pub fn prepare_search<'t>(
     time_budget: TimeBudget,
     features: RoFeatures,
 ) -> Result<(milli::Search<'t>, bool, usize, usize), ResponseError> {
+    if query.media.is_some() {
+        features.check_multimodal("passing `media` in a search query")?;
+    }
     let mut search = index.search(rtxn);
     search.time_budget(time_budget);
     if let Some(ranking_score_threshold) = query.ranking_score_threshold {
@@ -983,14 +1000,27 @@ pub fn prepare_search<'t>(
 
                     let deadline = std::time::Instant::now() + std::time::Duration::from_secs(10);
 
+                    let q = query.q.as_deref();
+                    let media = query.media.as_ref();
+
+                    let search_query = match (q, media) {
+                        (Some(text), None) => milli::vector::SearchQuery::Text(text),
+                        (q, media) => milli::vector::SearchQuery::Media { q, media },
+                    };
+
                     embedder
-                        .embed_search(query.q.as_ref().unwrap(), Some(deadline))
+                        .embed_search(search_query, Some(deadline))
                         .map_err(milli::vector::Error::from)
                         .map_err(milli::Error::from)?
                 }
             };
-
-            search.semantic(embedder_name.clone(), embedder.clone(), *quantized, Some(vector));
+            search.semantic(
+                embedder_name.clone(),
+                embedder.clone(),
+                *quantized,
+                Some(vector),
+                query.media.clone(),
+            );
         }
         SearchKind::Hybrid { embedder_name, embedder, quantized, semantic_ratio: _ } => {
             if let Some(q) = &query.q {
@@ -1002,6 +1032,7 @@ pub fn prepare_search<'t>(
                 embedder.clone(),
                 *quantized,
                 query.vector.clone(),
+                query.media.clone(),
             );
         }
     }
@@ -1126,6 +1157,7 @@ pub fn perform_search(
         locales,
         // already used in prepare_search
         vector: _,
+        media: _,
         hybrid: _,
         offset: _,
         ranking_score_threshold: _,
@@ -1328,7 +1360,6 @@ struct HitMaker<'a> {
     vectors_fid: Option<FieldId>,
     retrieve_vectors: RetrieveVectors,
     to_retrieve_ids: BTreeSet<FieldId>,
-    embedding_configs: Vec<index::IndexEmbeddingConfig>,
     formatter_builder: MatcherBuilder<'a>,
     formatted_options: BTreeMap<FieldId, FormatOptions>,
     show_ranking_score: bool,
@@ -1443,8 +1474,6 @@ impl<'a> HitMaker<'a> {
             &displayed_ids,
         );
 
-        let embedding_configs = index.embedding_configs(rtxn)?;
-
         Ok(Self {
             index,
             rtxn,
@@ -1453,7 +1482,6 @@ impl<'a> HitMaker<'a> {
             vectors_fid,
             retrieve_vectors,
             to_retrieve_ids,
-            embedding_configs,
             formatter_builder,
             formatted_options,
             show_ranking_score: format.show_ranking_score,
@@ -1499,14 +1527,8 @@ impl<'a> HitMaker<'a> {
                 Some(Value::Object(map)) => map,
                 _ => Default::default(),
             };
-            for (name, vector) in self.index.embeddings(self.rtxn, id)? {
-                let user_provided = self
-                    .embedding_configs
-                    .iter()
-                    .find(|conf| conf.name == name)
-                    .is_some_and(|conf| conf.user_provided.contains(id));
-                let embeddings =
-                    ExplicitVectors { embeddings: Some(vector.into()), regenerate: !user_provided };
+            for (name, (vector, regenerate)) in self.index.embeddings(self.rtxn, id)? {
+                let embeddings = ExplicitVectors { embeddings: Some(vector.into()), regenerate };
                 vectors.insert(
                     name,
                     serde_json::to_value(embeddings).map_err(InternalError::SerdeJson)?,

crates/meilisearch/tests/auth/api_keys.rs

@@ -419,14 +419,14 @@ async fn error_add_api_key_invalid_parameters_actions() {
     let (response, code) = server.add_api_key(content).await;
 
     meili_snap::snapshot!(code, @"400 Bad Request");
-    meili_snap::snapshot!(meili_snap::json_string!(response, { ".createdAt" => "[ignored]", ".updatedAt" => "[ignored]" }), @r###"
+    meili_snap::snapshot!(meili_snap::json_string!(response, { ".createdAt" => "[ignored]", ".updatedAt" => "[ignored]" }), @r#"
     {
-      "message": "Unknown value `doc.add` at `.actions[0]`: expected one of `*`, `search`, `documents.*`, `documents.add`, `documents.get`, `documents.delete`, `indexes.*`, `indexes.create`, `indexes.get`, `indexes.update`, `indexes.delete`, `indexes.swap`, `tasks.*`, `tasks.cancel`, `tasks.delete`, `tasks.get`, `settings.*`, `settings.get`, `settings.update`, `stats.*`, `stats.get`, `metrics.*`, `metrics.get`, `dumps.*`, `dumps.create`, `snapshots.*`, `snapshots.create`, `version`, `keys.create`, `keys.get`, `keys.update`, `keys.delete`, `experimental.get`, `experimental.update`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`",
+      "message": "Unknown value `doc.add` at `.actions[0]`: expected one of `*`, `*.get`, `search`, `documents.*`, `documents.add`, `documents.get`, `documents.delete`, `indexes.*`, `indexes.create`, `indexes.get`, `indexes.update`, `indexes.delete`, `indexes.swap`, `tasks.*`, `tasks.cancel`, `tasks.delete`, `tasks.get`, `settings.*`, `settings.get`, `settings.update`, `stats.*`, `stats.get`, `metrics.*`, `metrics.get`, `dumps.*`, `dumps.create`, `snapshots.*`, `snapshots.create`, `version`, `keys.create`, `keys.get`, `keys.update`, `keys.delete`, `experimental.get`, `experimental.update`, `export`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`",
       "code": "invalid_api_key_actions",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_api_key_actions"
     }
-    "###);
+    "#);
 }
 
 #[actix_rt::test]
@@ -790,7 +790,7 @@ async fn list_api_keys() {
     meili_snap::snapshot!(code, @"201 Created");
 
     let (response, code) = server.list_api_keys("").await;
-    meili_snap::snapshot!(meili_snap::json_string!(response, { ".results[].createdAt" => "[ignored]", ".results[].updatedAt" => "[ignored]", ".results[].uid" => "[ignored]", ".results[].key" => "[ignored]" }), @r###"
+    meili_snap::snapshot!(meili_snap::json_string!(response, { ".results[].createdAt" => "[ignored]", ".results[].updatedAt" => "[ignored]", ".results[].uid" => "[ignored]", ".results[].key" => "[ignored]" }), @r#"
     {
       "results": [
         {
@@ -850,6 +850,22 @@ async fn list_api_keys() {
           "createdAt": "[ignored]",
           "updatedAt": "[ignored]"
         },
+        {
+          "name": "Default Read-Only Admin API Key",
+          "description": "Use it to read information across the whole database. Caution! Do not expose this key on a public frontend",
+          "key": "[ignored]",
+          "uid": "[ignored]",
+          "actions": [
+            "*.get",
+            "keys.get"
+          ],
+          "indexes": [
+            "*"
+          ],
+          "expiresAt": null,
+          "createdAt": "[ignored]",
+          "updatedAt": "[ignored]"
+        },
         {
           "name": "Default Chat API Key",
           "description": "Use it to chat and search from the frontend",
@@ -869,9 +885,9 @@ async fn list_api_keys() {
       ],
       "offset": 0,
       "limit": 20,
-      "total": 4
+      "total": 5
     }
-    "###);
+    "#);
     meili_snap::snapshot!(code, @"200 OK");
 }
 

crates/meilisearch/tests/auth/errors.rs

@@ -91,14 +91,14 @@ async fn create_api_key_bad_actions() {
     // can't parse
     let (response, code) = server.add_api_key(json!({ "actions": ["doggo"] })).await;
     snapshot!(code, @"400 Bad Request");
-    snapshot!(json_string!(response), @r###"
+    snapshot!(json_string!(response), @r#"
     {
-      "message": "Unknown value `doggo` at `.actions[0]`: expected one of `*`, `search`, `documents.*`, `documents.add`, `documents.get`, `documents.delete`, `indexes.*`, `indexes.create`, `indexes.get`, `indexes.update`, `indexes.delete`, `indexes.swap`, `tasks.*`, `tasks.cancel`, `tasks.delete`, `tasks.get`, `settings.*`, `settings.get`, `settings.update`, `stats.*`, `stats.get`, `metrics.*`, `metrics.get`, `dumps.*`, `dumps.create`, `snapshots.*`, `snapshots.create`, `version`, `keys.create`, `keys.get`, `keys.update`, `keys.delete`, `experimental.get`, `experimental.update`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`",
+      "message": "Unknown value `doggo` at `.actions[0]`: expected one of `*`, `*.get`, `search`, `documents.*`, `documents.add`, `documents.get`, `documents.delete`, `indexes.*`, `indexes.create`, `indexes.get`, `indexes.update`, `indexes.delete`, `indexes.swap`, `tasks.*`, `tasks.cancel`, `tasks.delete`, `tasks.get`, `settings.*`, `settings.get`, `settings.update`, `stats.*`, `stats.get`, `metrics.*`, `metrics.get`, `dumps.*`, `dumps.create`, `snapshots.*`, `snapshots.create`, `version`, `keys.create`, `keys.get`, `keys.update`, `keys.delete`, `experimental.get`, `experimental.update`, `export`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`",
       "code": "invalid_api_key_actions",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_api_key_actions"
     }
-    "###);
+    "#);
 }
 
 #[actix_rt::test]

crates/meilisearch/tests/batches/errors.rs

@@ -42,7 +42,7 @@ async fn batch_bad_types() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(json_string!(response), @r#"
     {
-      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `upgradeDatabase`.",
+      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `export`, `upgradeDatabase`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"

crates/meilisearch/tests/common/server.rs

@@ -97,6 +97,7 @@ impl Server<Owned> {
         self.use_api_key(master_key);
         let (response, code) = self.list_api_keys("").await;
         assert_eq!(200, code, "{:?}", response);
+        // TODO: relying on the order of keys is not ideal, we should use the name instead
         let admin_key = &response["results"][1]["key"];
         self.use_api_key(admin_key.as_str().unwrap());
     }
@@ -464,6 +465,7 @@ pub fn default_settings(dir: impl AsRef<Path>) -> Opt {
             skip_index_budget: true,
             // Having 2 threads makes the tests way faster
             max_indexing_threads: MaxThreads::from_str("2").unwrap(),
+            experimental_no_edition_2024_for_settings: false,
         },
         experimental_enable_metrics: false,
         ..Parser::parse_from(None as Option<&str>)

crates/meilisearch/tests/dumps/mod.rs

@@ -2188,7 +2188,8 @@ async fn import_dump_v6_containing_experimental_features() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 
@@ -2314,7 +2315,8 @@ async fn import_dump_v6_containing_batches_and_enqueued_tasks() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 
@@ -2420,7 +2422,8 @@ async fn generate_and_import_dump_containing_vectors() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 

crates/meilisearch/tests/features/mod.rs

@@ -25,7 +25,8 @@ async fn experimental_features() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 
@@ -41,7 +42,8 @@ async fn experimental_features() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 
@@ -57,7 +59,8 @@ async fn experimental_features() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 
@@ -74,7 +77,8 @@ async fn experimental_features() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 
@@ -91,7 +95,8 @@ async fn experimental_features() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 }
@@ -115,7 +120,8 @@ async fn experimental_feature_metrics() {
       "network": false,
       "getTaskDocumentsRoute": false,
       "compositeEmbedders": false,
-      "chatCompletions": false
+      "chatCompletions": false,
+      "multimodal": false
     }
     "###);
 
@@ -162,7 +168,7 @@ async fn errors() {
     meili_snap::snapshot!(code, @"400 Bad Request");
     meili_snap::snapshot!(meili_snap::json_string!(response), @r###"
     {
-      "message": "Unknown field `NotAFeature`: expected one of `metrics`, `logsRoute`, `editDocumentsByFunction`, `containsFilter`, `network`, `getTaskDocumentsRoute`, `compositeEmbedders`, `chatCompletions`",
+      "message": "Unknown field `NotAFeature`: expected one of `metrics`, `logsRoute`, `editDocumentsByFunction`, `containsFilter`, `network`, `getTaskDocumentsRoute`, `compositeEmbedders`, `chatCompletions`, `multimodal`",
       "code": "bad_request",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#bad_request"

crates/meilisearch/tests/index/stats.rs

@@ -1,5 +1,4 @@
 use crate::common::{shared_does_not_exists_index, Server};
-
 use crate::json;
 
 #[actix_rt::test]

crates/meilisearch/tests/search/hybrid.rs

@@ -499,7 +499,7 @@ async fn query_combination() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Invalid request: missing `hybrid` parameter when `vector` is present.",
+      "message": "Invalid request: missing `hybrid` parameter when `vector` or `media` are present.",
       "code": "missing_search_hybrid",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#missing_search_hybrid"

crates/meilisearch/tests/settings/get_settings.rs

@@ -247,6 +247,20 @@ async fn get_settings() {
     assert_eq!(settings["prefixSearch"], json!("indexingTime"));
     assert_eq!(settings["facetSearch"], json!(true));
     assert_eq!(settings["embedders"], json!({}));
+    assert_eq!(settings["synonyms"], json!({}));
+    assert_eq!(
+        settings["typoTolerance"],
+        json!({
+            "enabled": true,
+            "minWordSizeForTypos": {
+                "oneTypo": 5,
+                "twoTypos": 9
+            },
+            "disableOnWords": [],
+            "disableOnAttributes": [],
+            "disableOnNumbers": false
+        })
+    );
 }
 
 #[actix_rt::test]
@@ -426,8 +440,15 @@ async fn reset_all_settings() {
     assert_eq!(code, 202);
     server.wait_task(response.uid()).await.succeeded();
 
-    let (update_task,_status_code) = index
-        .update_settings(json!({"displayedAttributes": ["name", "age"], "searchableAttributes": ["name"], "stopWords": ["the"], "filterableAttributes": ["age"], "synonyms": {"puppy": ["dog", "doggo", "potat"] }}))
+    let (update_task, _status_code) = index
+        .update_settings(json!({
+            "displayedAttributes": ["name", "age"],
+            "searchableAttributes": ["name"],
+            "stopWords": ["the"],
+            "filterableAttributes": ["age"],
+            "synonyms": {"puppy": ["dog", "doggo", "potat"] },
+            "typoTolerance": {"disableOnNumbers": true}
+        }))
         .await;
     server.wait_task(update_task.uid()).await.succeeded();
     let (response, code) = index.settings().await;
@@ -437,6 +458,19 @@ async fn reset_all_settings() {
     assert_eq!(response["stopWords"], json!(["the"]));
     assert_eq!(response["synonyms"], json!({"puppy": ["dog", "doggo", "potat"] }));
     assert_eq!(response["filterableAttributes"], json!(["age"]));
+    assert_eq!(
+        response["typoTolerance"],
+        json!({
+            "enabled": true,
+            "minWordSizeForTypos": {
+                "oneTypo": 5,
+                "twoTypos": 9
+            },
+            "disableOnWords": [],
+            "disableOnAttributes": [],
+            "disableOnNumbers": true
+        })
+    );
 
     let (delete_task, _status_code) = index.delete_settings().await;
     server.wait_task(delete_task.uid()).await.succeeded();
@@ -448,6 +482,19 @@ async fn reset_all_settings() {
     assert_eq!(response["stopWords"], json!([]));
     assert_eq!(response["filterableAttributes"], json!([]));
     assert_eq!(response["synonyms"], json!({}));
+    assert_eq!(
+        response["typoTolerance"],
+        json!({
+            "enabled": true,
+            "minWordSizeForTypos": {
+                "oneTypo": 5,
+                "twoTypos": 9
+            },
+            "disableOnWords": [],
+            "disableOnAttributes": [],
+            "disableOnNumbers": false
+        })
+    );
 
     let (response, code) = index.get_document(1, None).await;
     assert_eq!(code, 200);
@@ -645,3 +692,68 @@ async fn granular_filterable_attributes() {
     ]
     "###);
 }
+
+#[actix_rt::test]
+async fn test_searchable_attributes_order() {
+    let server = Server::new_shared();
+    let index = server.unique_index();
+
+    // 1) Create an index with settings "searchableAttributes": ["title", "overview"]
+    let (response, code) = index.create(None).await;
+    assert_eq!(code, 202, "{response}");
+    server.wait_task(response.uid()).await.succeeded();
+
+    let (task, code) = index
+        .update_settings(json!({
+            "searchableAttributes": ["title", "overview"]
+        }))
+        .await;
+    assert_eq!(code, 202, "{task}");
+    server.wait_task(task.uid()).await.succeeded();
+
+    // 2) Add documents in the index
+    let documents = json!([
+        {
+            "id": 1,
+            "title": "The Matrix",
+            "overview": "A computer hacker learns from mysterious rebels about the true nature of his reality."
+        },
+        {
+            "id": 2,
+            "title": "Inception",
+            "overview": "A thief who steals corporate secrets through dream-sharing technology."
+        }
+    ]);
+
+    let (response, code) = index.add_documents(documents, None).await;
+    assert_eq!(code, 202, "{response}");
+    server.wait_task(response.uid()).await.succeeded();
+
+    // 3) Modify the settings "searchableAttributes": ["overview", "title"] (overview is put first)
+    let (task, code) = index
+        .update_settings(json!({
+            "searchableAttributes": ["overview", "title"]
+        }))
+        .await;
+    assert_eq!(code, 202, "{task}");
+    server.wait_task(task.uid()).await.succeeded();
+
+    // 4) Check if it has been applied
+    let (response, code) = index.settings().await;
+    assert_eq!(code, 200, "{response}");
+    assert_eq!(response["searchableAttributes"], json!(["overview", "title"]));
+
+    // 5) Re-modify the settings "searchableAttributes": ["title", "overview"] (title is put first)
+    let (task, code) = index
+        .update_settings(json!({
+            "searchableAttributes": ["title", "overview"]
+        }))
+        .await;
+    assert_eq!(code, 202, "{task}");
+    server.wait_task(task.uid()).await.succeeded();
+
+    // 6) Check if it has been applied
+    let (response, code) = index.settings().await;
+    assert_eq!(code, 200, "{response}");
+    assert_eq!(response["searchableAttributes"], json!(["title", "overview"]));
+}

crates/meilisearch/tests/tasks/errors.rs

@@ -97,7 +97,7 @@ async fn task_bad_types() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(json_string!(response), @r#"
     {
-      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `upgradeDatabase`.",
+      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `export`, `upgradeDatabase`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"
@@ -108,7 +108,7 @@ async fn task_bad_types() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(json_string!(response), @r#"
     {
-      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `upgradeDatabase`.",
+      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `export`, `upgradeDatabase`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"
@@ -119,7 +119,7 @@ async fn task_bad_types() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(json_string!(response), @r#"
     {
-      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `upgradeDatabase`.",
+      "message": "Invalid value in parameter `types`: `doggo` is not a valid task type. Available types are `documentAdditionOrUpdate`, `documentEdition`, `documentDeletion`, `settingsUpdate`, `indexCreation`, `indexDeletion`, `indexUpdate`, `indexSwap`, `taskCancelation`, `taskDeletion`, `dumpCreation`, `snapshotCreation`, `export`, `upgradeDatabase`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"

crates/meilisearch/tests/upgrade/mod.rs

@@ -43,7 +43,7 @@ async fn version_too_old() {
     std::fs::write(db_path.join("VERSION"), "1.11.9999").unwrap();
     let options = Opt { experimental_dumpless_upgrade: true, ..default_settings };
     let err = Server::new_with_options(options).await.map(|_| ()).unwrap_err();
-    snapshot!(err, @"Database version 1.11.9999 is too old for the experimental dumpless upgrade feature. Please generate a dump using the v1.11.9999 and import it in the v1.15.2");
+    snapshot!(err, @"Database version 1.11.9999 is too old for the experimental dumpless upgrade feature. Please generate a dump using the v1.11.9999 and import it in the v1.16.0");
 }
 
 #[actix_rt::test]
@@ -58,7 +58,7 @@ async fn version_requires_downgrade() {
     std::fs::write(db_path.join("VERSION"), format!("{major}.{minor}.{patch}")).unwrap();
     let options = Opt { experimental_dumpless_upgrade: true, ..default_settings };
     let err = Server::new_with_options(options).await.map(|_| ()).unwrap_err();
-    snapshot!(err, @"Database version 1.15.3 is higher than the Meilisearch version 1.15.2. Downgrade is not supported");
+    snapshot!(err, @"Database version 1.16.1 is higher than the Meilisearch version 1.16.0. Downgrade is not supported");
 }
 
 #[actix_rt::test]

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_features/kefir_settings.snap

@@ -61,7 +61,16 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
   "pagination": {
     "maxTotalHits": 15
   },
-  "embedders": {},
+  "embedders": {
+    "doggo_embedder": {
+      "source": "huggingFace",
+      "model": "sentence-transformers/all-MiniLM-L6-v2",
+      "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+      "pooling": "forceMean",
+      "documentTemplate": "{{doc.description}}",
+      "documentTemplateMaxBytes": 400
+    }
+  },
   "searchCutoffMs": 8000,
   "localizedAttributes": [
     {

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_features/search_with_retrieve_vectors.snap

@@ -0,0 +1,40 @@
+---
+source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
+---
+[
+  {
+    "id": 1,
+    "name": "kefir",
+    "surname": [
+      "kef",
+      "kefkef",
+      "kefirounet",
+      "boubou"
+    ],
+    "age": 1.4,
+    "description": "kefir est un petit chien blanc très mignon",
+    "_vectors": {
+      "doggo_embedder": {
+        "embeddings": "[vector]",
+        "regenerate": true
+      }
+    }
+  },
+  {
+    "id": 2,
+    "name": "intel",
+    "surname": [
+      "untel",
+      "tétel",
+      "iouiou"
+    ],
+    "age": 11.5,
+    "description": "intel est un grand beagle très mignon",
+    "_vectors": {
+      "doggo_embedder": {
+        "embeddings": "[vector]",
+        "regenerate": false
+      }
+    }
+  }
+]

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/batches_filter_afterEnqueuedAt_equal_2025-01-16T16_47_41.snap

@@ -4,11 +4,11 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 24,
+      "uid": 30,
       "progress": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "stats": {
         "totalNbTasks": 1,
@@ -26,6 +26,155 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "finishedAt": "[date]",
       "batchStrategy": "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type."
     },
+    {
+      "uid": 29,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.067201S",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 28,
+      "progress": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "indexDeletion": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.012727S",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 27,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "failed": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.059920S",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 26,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.088879S",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 25,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.312911S",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 24,
+      "progress": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "settingsUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.247378S",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z",
+      "batchStrategy": "unspecified"
+    },
     {
       "uid": 23,
       "progress": null,
@@ -348,179 +497,10 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "startedAt": "2025-01-16T17:01:14.112756687Z",
       "finishedAt": "2025-01-16T17:01:14.120064527Z",
       "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 10,
-      "progress": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 99
-        },
-        "pagination": {
-          "maxTotalHits": 15
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007391353S",
-      "startedAt": "2025-01-16T17:00:29.201180268Z",
-      "finishedAt": "2025-01-16T17:00:29.208571621Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 9,
-      "progress": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 100
-        },
-        "pagination": {
-          "maxTotalHits": 1000
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007445825S",
-      "startedAt": "2025-01-16T17:00:15.77629445Z",
-      "finishedAt": "2025-01-16T17:00:15.783740275Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 8,
-      "progress": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          },
-          "disableOnWords": [
-            "kefir"
-          ],
-          "disableOnAttributes": [
-            "surname"
-          ]
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.012020083S",
-      "startedAt": "2025-01-16T16:59:42.744086671Z",
-      "finishedAt": "2025-01-16T16:59:42.756106754Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 7,
-      "progress": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          }
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007440092S",
-      "startedAt": "2025-01-16T16:58:41.2155771Z",
-      "finishedAt": "2025-01-16T16:58:41.223017192Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 6,
-      "progress": null,
-      "details": {
-        "synonyms": {
-          "boubou": [
-            "kefir"
-          ]
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007565161S",
-      "startedAt": "2025-01-16T16:54:51.940332781Z",
-      "finishedAt": "2025-01-16T16:54:51.947897942Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 5,
-      "progress": null,
-      "details": {
-        "stopWords": [
-          "le",
-          "un"
-        ]
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.016307263S",
-      "startedAt": "2025-01-16T16:53:19.913351957Z",
-      "finishedAt": "2025-01-16T16:53:19.92965922Z",
-      "batchStrategy": "unspecified"
     }
   ],
-  "total": 23,
+  "total": 29,
   "limit": 20,
-  "from": 24,
-  "next": 4
+  "from": 30,
+  "next": 10
 }

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/batches_filter_afterFinishedAt_equal_2025-01-16T16_47_41.snap

@@ -4,11 +4,11 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 24,
+      "uid": 30,
       "progress": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "stats": {
         "totalNbTasks": 1,
@@ -26,6 +26,155 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "finishedAt": "[date]",
       "batchStrategy": "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type."
     },
+    {
+      "uid": 29,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.067201S",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 28,
+      "progress": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "indexDeletion": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.012727S",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 27,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "failed": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.059920S",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 26,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.088879S",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 25,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.312911S",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 24,
+      "progress": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "settingsUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.247378S",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z",
+      "batchStrategy": "unspecified"
+    },
     {
       "uid": 23,
       "progress": null,
@@ -348,179 +497,10 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "startedAt": "2025-01-16T17:01:14.112756687Z",
       "finishedAt": "2025-01-16T17:01:14.120064527Z",
       "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 10,
-      "progress": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 99
-        },
-        "pagination": {
-          "maxTotalHits": 15
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007391353S",
-      "startedAt": "2025-01-16T17:00:29.201180268Z",
-      "finishedAt": "2025-01-16T17:00:29.208571621Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 9,
-      "progress": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 100
-        },
-        "pagination": {
-          "maxTotalHits": 1000
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007445825S",
-      "startedAt": "2025-01-16T17:00:15.77629445Z",
-      "finishedAt": "2025-01-16T17:00:15.783740275Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 8,
-      "progress": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          },
-          "disableOnWords": [
-            "kefir"
-          ],
-          "disableOnAttributes": [
-            "surname"
-          ]
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.012020083S",
-      "startedAt": "2025-01-16T16:59:42.744086671Z",
-      "finishedAt": "2025-01-16T16:59:42.756106754Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 7,
-      "progress": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          }
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007440092S",
-      "startedAt": "2025-01-16T16:58:41.2155771Z",
-      "finishedAt": "2025-01-16T16:58:41.223017192Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 6,
-      "progress": null,
-      "details": {
-        "synonyms": {
-          "boubou": [
-            "kefir"
-          ]
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007565161S",
-      "startedAt": "2025-01-16T16:54:51.940332781Z",
-      "finishedAt": "2025-01-16T16:54:51.947897942Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 5,
-      "progress": null,
-      "details": {
-        "stopWords": [
-          "le",
-          "un"
-        ]
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.016307263S",
-      "startedAt": "2025-01-16T16:53:19.913351957Z",
-      "finishedAt": "2025-01-16T16:53:19.92965922Z",
-      "batchStrategy": "unspecified"
     }
   ],
-  "total": 23,
+  "total": 29,
   "limit": 20,
-  "from": 24,
-  "next": 4
+  "from": 30,
+  "next": 10
 }

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/batches_filter_afterStartedAt_equal_2025-01-16T16_47_41.snap

@@ -4,11 +4,11 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 24,
+      "uid": 30,
       "progress": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "stats": {
         "totalNbTasks": 1,
@@ -26,6 +26,155 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "finishedAt": "[date]",
       "batchStrategy": "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type."
     },
+    {
+      "uid": 29,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.067201S",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 28,
+      "progress": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "indexDeletion": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.012727S",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 27,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "failed": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.059920S",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 26,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.088879S",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 25,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.312911S",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 24,
+      "progress": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "settingsUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.247378S",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z",
+      "batchStrategy": "unspecified"
+    },
     {
       "uid": 23,
       "progress": null,
@@ -348,179 +497,10 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "startedAt": "2025-01-16T17:01:14.112756687Z",
       "finishedAt": "2025-01-16T17:01:14.120064527Z",
       "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 10,
-      "progress": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 99
-        },
-        "pagination": {
-          "maxTotalHits": 15
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007391353S",
-      "startedAt": "2025-01-16T17:00:29.201180268Z",
-      "finishedAt": "2025-01-16T17:00:29.208571621Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 9,
-      "progress": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 100
-        },
-        "pagination": {
-          "maxTotalHits": 1000
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007445825S",
-      "startedAt": "2025-01-16T17:00:15.77629445Z",
-      "finishedAt": "2025-01-16T17:00:15.783740275Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 8,
-      "progress": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          },
-          "disableOnWords": [
-            "kefir"
-          ],
-          "disableOnAttributes": [
-            "surname"
-          ]
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.012020083S",
-      "startedAt": "2025-01-16T16:59:42.744086671Z",
-      "finishedAt": "2025-01-16T16:59:42.756106754Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 7,
-      "progress": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          }
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007440092S",
-      "startedAt": "2025-01-16T16:58:41.2155771Z",
-      "finishedAt": "2025-01-16T16:58:41.223017192Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 6,
-      "progress": null,
-      "details": {
-        "synonyms": {
-          "boubou": [
-            "kefir"
-          ]
-        }
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.007565161S",
-      "startedAt": "2025-01-16T16:54:51.940332781Z",
-      "finishedAt": "2025-01-16T16:54:51.947897942Z",
-      "batchStrategy": "unspecified"
-    },
-    {
-      "uid": 5,
-      "progress": null,
-      "details": {
-        "stopWords": [
-          "le",
-          "un"
-        ]
-      },
-      "stats": {
-        "totalNbTasks": 1,
-        "status": {
-          "succeeded": 1
-        },
-        "types": {
-          "settingsUpdate": 1
-        },
-        "indexUids": {
-          "kefir": 1
-        }
-      },
-      "duration": "PT0.016307263S",
-      "startedAt": "2025-01-16T16:53:19.913351957Z",
-      "finishedAt": "2025-01-16T16:53:19.92965922Z",
-      "batchStrategy": "unspecified"
     }
   ],
-  "total": 23,
+  "total": 29,
   "limit": 20,
-  "from": 24,
-  "next": 4
+  "from": 30,
+  "next": 10
 }

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/tasks_filter_afterEnqueuedAt_equal_2025-01-16T16_47_41.snap

@@ -4,15 +4,15 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 25,
-      "batchUid": 24,
+      "uid": 31,
+      "batchUid": 30,
       "indexUid": null,
       "status": "succeeded",
       "type": "upgradeDatabase",
       "canceledBy": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "error": null,
       "duration": "[duration]",
@@ -20,6 +20,118 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "startedAt": "[date]",
       "finishedAt": "[date]"
     },
+    {
+      "uid": 30,
+      "batchUid": 29,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.067201S",
+      "enqueuedAt": "2025-07-07T13:43:08.772432Z",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z"
+    },
+    {
+      "uid": 29,
+      "batchUid": 28,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "indexDeletion",
+      "canceledBy": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.012727S",
+      "enqueuedAt": "2025-07-07T13:42:50.744793Z",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z"
+    },
+    {
+      "uid": 28,
+      "batchUid": 27,
+      "indexUid": "kefir",
+      "status": "failed",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "error": {
+        "message": "Index `kefir`: Bad embedder configuration in the document with id: `2`. Could not parse `._vectors.doggo_embedder`: trailing characters at line 1 column 13",
+        "code": "invalid_vectors_type",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#invalid_vectors_type"
+      },
+      "duration": "PT0.059920S",
+      "enqueuedAt": "2025-07-07T13:42:15.624598Z",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z"
+    },
+    {
+      "uid": 27,
+      "batchUid": 26,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.088879S",
+      "enqueuedAt": "2025-07-07T13:40:01.46081Z",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z"
+    },
+    {
+      "uid": 26,
+      "batchUid": 25,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.312911S",
+      "enqueuedAt": "2025-07-07T13:32:46.13871Z",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z"
+    },
+    {
+      "uid": 25,
+      "batchUid": 24,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "settingsUpdate",
+      "canceledBy": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "error": null,
+      "duration": "PT0.247378S",
+      "enqueuedAt": "2025-07-07T13:28:27.390054Z",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z"
+    },
     {
       "uid": 24,
       "batchUid": 23,
@@ -264,134 +376,10 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "enqueuedAt": "2025-01-16T17:02:52.527382964Z",
       "startedAt": "2025-01-16T17:02:52.539749853Z",
       "finishedAt": "2025-01-16T17:02:52.547390016Z"
-    },
-    {
-      "uid": 11,
-      "batchUid": 11,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "searchCutoffMs": 8000
-      },
-      "error": null,
-      "duration": "PT0.007307840S",
-      "enqueuedAt": "2025-01-16T17:01:14.100316617Z",
-      "startedAt": "2025-01-16T17:01:14.112756687Z",
-      "finishedAt": "2025-01-16T17:01:14.120064527Z"
-    },
-    {
-      "uid": 10,
-      "batchUid": 10,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 99
-        },
-        "pagination": {
-          "maxTotalHits": 15
-        }
-      },
-      "error": null,
-      "duration": "PT0.007391353S",
-      "enqueuedAt": "2025-01-16T17:00:29.188815062Z",
-      "startedAt": "2025-01-16T17:00:29.201180268Z",
-      "finishedAt": "2025-01-16T17:00:29.208571621Z"
-    },
-    {
-      "uid": 9,
-      "batchUid": 9,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 100
-        },
-        "pagination": {
-          "maxTotalHits": 1000
-        }
-      },
-      "error": null,
-      "duration": "PT0.007445825S",
-      "enqueuedAt": "2025-01-16T17:00:15.759501709Z",
-      "startedAt": "2025-01-16T17:00:15.77629445Z",
-      "finishedAt": "2025-01-16T17:00:15.783740275Z"
-    },
-    {
-      "uid": 8,
-      "batchUid": 8,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          },
-          "disableOnWords": [
-            "kefir"
-          ],
-          "disableOnAttributes": [
-            "surname"
-          ]
-        }
-      },
-      "error": null,
-      "duration": "PT0.012020083S",
-      "enqueuedAt": "2025-01-16T16:59:42.727292501Z",
-      "startedAt": "2025-01-16T16:59:42.744086671Z",
-      "finishedAt": "2025-01-16T16:59:42.756106754Z"
-    },
-    {
-      "uid": 7,
-      "batchUid": 7,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          }
-        }
-      },
-      "error": null,
-      "duration": "PT0.007440092S",
-      "enqueuedAt": "2025-01-16T16:58:41.203145044Z",
-      "startedAt": "2025-01-16T16:58:41.2155771Z",
-      "finishedAt": "2025-01-16T16:58:41.223017192Z"
-    },
-    {
-      "uid": 6,
-      "batchUid": 6,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "synonyms": {
-          "boubou": [
-            "kefir"
-          ]
-        }
-      },
-      "error": null,
-      "duration": "PT0.007565161S",
-      "enqueuedAt": "2025-01-16T16:54:51.927866243Z",
-      "startedAt": "2025-01-16T16:54:51.940332781Z",
-      "finishedAt": "2025-01-16T16:54:51.947897942Z"
     }
   ],
-  "total": 24,
+  "total": 30,
   "limit": 20,
-  "from": 25,
-  "next": 5
+  "from": 31,
+  "next": 11
 }

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/tasks_filter_afterFinishedAt_equal_2025-01-16T16_47_41.snap

@@ -4,15 +4,15 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 25,
-      "batchUid": 24,
+      "uid": 31,
+      "batchUid": 30,
       "indexUid": null,
       "status": "succeeded",
       "type": "upgradeDatabase",
       "canceledBy": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "error": null,
       "duration": "[duration]",
@@ -20,6 +20,118 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "startedAt": "[date]",
       "finishedAt": "[date]"
     },
+    {
+      "uid": 30,
+      "batchUid": 29,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.067201S",
+      "enqueuedAt": "2025-07-07T13:43:08.772432Z",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z"
+    },
+    {
+      "uid": 29,
+      "batchUid": 28,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "indexDeletion",
+      "canceledBy": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.012727S",
+      "enqueuedAt": "2025-07-07T13:42:50.744793Z",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z"
+    },
+    {
+      "uid": 28,
+      "batchUid": 27,
+      "indexUid": "kefir",
+      "status": "failed",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "error": {
+        "message": "Index `kefir`: Bad embedder configuration in the document with id: `2`. Could not parse `._vectors.doggo_embedder`: trailing characters at line 1 column 13",
+        "code": "invalid_vectors_type",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#invalid_vectors_type"
+      },
+      "duration": "PT0.059920S",
+      "enqueuedAt": "2025-07-07T13:42:15.624598Z",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z"
+    },
+    {
+      "uid": 27,
+      "batchUid": 26,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.088879S",
+      "enqueuedAt": "2025-07-07T13:40:01.46081Z",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z"
+    },
+    {
+      "uid": 26,
+      "batchUid": 25,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.312911S",
+      "enqueuedAt": "2025-07-07T13:32:46.13871Z",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z"
+    },
+    {
+      "uid": 25,
+      "batchUid": 24,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "settingsUpdate",
+      "canceledBy": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "error": null,
+      "duration": "PT0.247378S",
+      "enqueuedAt": "2025-07-07T13:28:27.390054Z",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z"
+    },
     {
       "uid": 24,
       "batchUid": 23,
@@ -264,134 +376,10 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "enqueuedAt": "2025-01-16T17:02:52.527382964Z",
       "startedAt": "2025-01-16T17:02:52.539749853Z",
       "finishedAt": "2025-01-16T17:02:52.547390016Z"
-    },
-    {
-      "uid": 11,
-      "batchUid": 11,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "searchCutoffMs": 8000
-      },
-      "error": null,
-      "duration": "PT0.007307840S",
-      "enqueuedAt": "2025-01-16T17:01:14.100316617Z",
-      "startedAt": "2025-01-16T17:01:14.112756687Z",
-      "finishedAt": "2025-01-16T17:01:14.120064527Z"
-    },
-    {
-      "uid": 10,
-      "batchUid": 10,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 99
-        },
-        "pagination": {
-          "maxTotalHits": 15
-        }
-      },
-      "error": null,
-      "duration": "PT0.007391353S",
-      "enqueuedAt": "2025-01-16T17:00:29.188815062Z",
-      "startedAt": "2025-01-16T17:00:29.201180268Z",
-      "finishedAt": "2025-01-16T17:00:29.208571621Z"
-    },
-    {
-      "uid": 9,
-      "batchUid": 9,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 100
-        },
-        "pagination": {
-          "maxTotalHits": 1000
-        }
-      },
-      "error": null,
-      "duration": "PT0.007445825S",
-      "enqueuedAt": "2025-01-16T17:00:15.759501709Z",
-      "startedAt": "2025-01-16T17:00:15.77629445Z",
-      "finishedAt": "2025-01-16T17:00:15.783740275Z"
-    },
-    {
-      "uid": 8,
-      "batchUid": 8,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          },
-          "disableOnWords": [
-            "kefir"
-          ],
-          "disableOnAttributes": [
-            "surname"
-          ]
-        }
-      },
-      "error": null,
-      "duration": "PT0.012020083S",
-      "enqueuedAt": "2025-01-16T16:59:42.727292501Z",
-      "startedAt": "2025-01-16T16:59:42.744086671Z",
-      "finishedAt": "2025-01-16T16:59:42.756106754Z"
-    },
-    {
-      "uid": 7,
-      "batchUid": 7,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          }
-        }
-      },
-      "error": null,
-      "duration": "PT0.007440092S",
-      "enqueuedAt": "2025-01-16T16:58:41.203145044Z",
-      "startedAt": "2025-01-16T16:58:41.2155771Z",
-      "finishedAt": "2025-01-16T16:58:41.223017192Z"
-    },
-    {
-      "uid": 6,
-      "batchUid": 6,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "synonyms": {
-          "boubou": [
-            "kefir"
-          ]
-        }
-      },
-      "error": null,
-      "duration": "PT0.007565161S",
-      "enqueuedAt": "2025-01-16T16:54:51.927866243Z",
-      "startedAt": "2025-01-16T16:54:51.940332781Z",
-      "finishedAt": "2025-01-16T16:54:51.947897942Z"
     }
   ],
-  "total": 24,
+  "total": 30,
   "limit": 20,
-  "from": 25,
-  "next": 5
+  "from": 31,
+  "next": 11
 }

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/tasks_filter_afterStartedAt_equal_2025-01-16T16_47_41.snap

@@ -4,15 +4,15 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 25,
-      "batchUid": 24,
+      "uid": 31,
+      "batchUid": 30,
       "indexUid": null,
       "status": "succeeded",
       "type": "upgradeDatabase",
       "canceledBy": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "error": null,
       "duration": "[duration]",
@@ -20,6 +20,118 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "startedAt": "[date]",
       "finishedAt": "[date]"
     },
+    {
+      "uid": 30,
+      "batchUid": 29,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.067201S",
+      "enqueuedAt": "2025-07-07T13:43:08.772432Z",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z"
+    },
+    {
+      "uid": 29,
+      "batchUid": 28,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "indexDeletion",
+      "canceledBy": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.012727S",
+      "enqueuedAt": "2025-07-07T13:42:50.744793Z",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z"
+    },
+    {
+      "uid": 28,
+      "batchUid": 27,
+      "indexUid": "kefir",
+      "status": "failed",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "error": {
+        "message": "Index `kefir`: Bad embedder configuration in the document with id: `2`. Could not parse `._vectors.doggo_embedder`: trailing characters at line 1 column 13",
+        "code": "invalid_vectors_type",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#invalid_vectors_type"
+      },
+      "duration": "PT0.059920S",
+      "enqueuedAt": "2025-07-07T13:42:15.624598Z",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z"
+    },
+    {
+      "uid": 27,
+      "batchUid": 26,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.088879S",
+      "enqueuedAt": "2025-07-07T13:40:01.46081Z",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z"
+    },
+    {
+      "uid": 26,
+      "batchUid": 25,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.312911S",
+      "enqueuedAt": "2025-07-07T13:32:46.13871Z",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z"
+    },
+    {
+      "uid": 25,
+      "batchUid": 24,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "settingsUpdate",
+      "canceledBy": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "error": null,
+      "duration": "PT0.247378S",
+      "enqueuedAt": "2025-07-07T13:28:27.390054Z",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z"
+    },
     {
       "uid": 24,
       "batchUid": 23,
@@ -264,134 +376,10 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "enqueuedAt": "2025-01-16T17:02:52.527382964Z",
       "startedAt": "2025-01-16T17:02:52.539749853Z",
       "finishedAt": "2025-01-16T17:02:52.547390016Z"
-    },
-    {
-      "uid": 11,
-      "batchUid": 11,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "searchCutoffMs": 8000
-      },
-      "error": null,
-      "duration": "PT0.007307840S",
-      "enqueuedAt": "2025-01-16T17:01:14.100316617Z",
-      "startedAt": "2025-01-16T17:01:14.112756687Z",
-      "finishedAt": "2025-01-16T17:01:14.120064527Z"
-    },
-    {
-      "uid": 10,
-      "batchUid": 10,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 99
-        },
-        "pagination": {
-          "maxTotalHits": 15
-        }
-      },
-      "error": null,
-      "duration": "PT0.007391353S",
-      "enqueuedAt": "2025-01-16T17:00:29.188815062Z",
-      "startedAt": "2025-01-16T17:00:29.201180268Z",
-      "finishedAt": "2025-01-16T17:00:29.208571621Z"
-    },
-    {
-      "uid": 9,
-      "batchUid": 9,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "faceting": {
-          "maxValuesPerFacet": 100
-        },
-        "pagination": {
-          "maxTotalHits": 1000
-        }
-      },
-      "error": null,
-      "duration": "PT0.007445825S",
-      "enqueuedAt": "2025-01-16T17:00:15.759501709Z",
-      "startedAt": "2025-01-16T17:00:15.77629445Z",
-      "finishedAt": "2025-01-16T17:00:15.783740275Z"
-    },
-    {
-      "uid": 8,
-      "batchUid": 8,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          },
-          "disableOnWords": [
-            "kefir"
-          ],
-          "disableOnAttributes": [
-            "surname"
-          ]
-        }
-      },
-      "error": null,
-      "duration": "PT0.012020083S",
-      "enqueuedAt": "2025-01-16T16:59:42.727292501Z",
-      "startedAt": "2025-01-16T16:59:42.744086671Z",
-      "finishedAt": "2025-01-16T16:59:42.756106754Z"
-    },
-    {
-      "uid": 7,
-      "batchUid": 7,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "typoTolerance": {
-          "minWordSizeForTypos": {
-            "oneTypo": 4
-          }
-        }
-      },
-      "error": null,
-      "duration": "PT0.007440092S",
-      "enqueuedAt": "2025-01-16T16:58:41.203145044Z",
-      "startedAt": "2025-01-16T16:58:41.2155771Z",
-      "finishedAt": "2025-01-16T16:58:41.223017192Z"
-    },
-    {
-      "uid": 6,
-      "batchUid": 6,
-      "indexUid": "kefir",
-      "status": "succeeded",
-      "type": "settingsUpdate",
-      "canceledBy": null,
-      "details": {
-        "synonyms": {
-          "boubou": [
-            "kefir"
-          ]
-        }
-      },
-      "error": null,
-      "duration": "PT0.007565161S",
-      "enqueuedAt": "2025-01-16T16:54:51.927866243Z",
-      "startedAt": "2025-01-16T16:54:51.940332781Z",
-      "finishedAt": "2025-01-16T16:54:51.947897942Z"
     }
   ],
-  "total": 24,
+  "total": 30,
   "limit": 20,
-  "from": 25,
-  "next": 5
+  "from": 31,
+  "next": 11
 }

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/the_whole_batch_queue_once_everything_has_been_processed.snap

@@ -4,11 +4,11 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 24,
+      "uid": 30,
       "progress": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "stats": {
         "totalNbTasks": 1,
@@ -26,6 +26,155 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "finishedAt": "[date]",
       "batchStrategy": "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type."
     },
+    {
+      "uid": 29,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.067201S",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 28,
+      "progress": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "indexDeletion": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.012727S",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 27,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "failed": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.059920S",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 26,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "mieli": 1
+        }
+      },
+      "duration": "PT0.088879S",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 25,
+      "progress": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.312911S",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z",
+      "batchStrategy": "unspecified"
+    },
+    {
+      "uid": 24,
+      "progress": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "succeeded": 1
+        },
+        "types": {
+          "settingsUpdate": 1
+        },
+        "indexUids": {
+          "kefir": 1
+        }
+      },
+      "duration": "PT0.247378S",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z",
+      "batchStrategy": "unspecified"
+    },
     {
       "uid": 23,
       "progress": null,
@@ -642,8 +791,8 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "batchStrategy": "unspecified"
     }
   ],
-  "total": 25,
+  "total": 31,
   "limit": 1000,
-  "from": 24,
+  "from": 30,
   "next": null
 }

crates/meilisearch/tests/upgrade/v1_12/snapshots/v1_12_0.rs/check_the_index_scheduler/the_whole_task_queue_once_everything_has_been_processed.snap

@@ -4,15 +4,15 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
 {
   "results": [
     {
-      "uid": 25,
-      "batchUid": 24,
+      "uid": 31,
+      "batchUid": 30,
       "indexUid": null,
       "status": "succeeded",
       "type": "upgradeDatabase",
       "canceledBy": null,
       "details": {
         "upgradeFrom": "v1.12.0",
-        "upgradeTo": "v1.15.2"
+        "upgradeTo": "v1.16.0"
       },
       "error": null,
       "duration": "[duration]",
@@ -20,6 +20,118 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "startedAt": "[date]",
       "finishedAt": "[date]"
     },
+    {
+      "uid": 30,
+      "batchUid": 29,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.067201S",
+      "enqueuedAt": "2025-07-07T13:43:08.772432Z",
+      "startedAt": "2025-07-07T13:43:08.772854Z",
+      "finishedAt": "2025-07-07T13:43:08.840055Z"
+    },
+    {
+      "uid": 29,
+      "batchUid": 28,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "indexDeletion",
+      "canceledBy": null,
+      "details": {
+        "deletedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.012727S",
+      "enqueuedAt": "2025-07-07T13:42:50.744793Z",
+      "startedAt": "2025-07-07T13:42:50.745461Z",
+      "finishedAt": "2025-07-07T13:42:50.758188Z"
+    },
+    {
+      "uid": 28,
+      "batchUid": 27,
+      "indexUid": "kefir",
+      "status": "failed",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 0
+      },
+      "error": {
+        "message": "Index `kefir`: Bad embedder configuration in the document with id: `2`. Could not parse `._vectors.doggo_embedder`: trailing characters at line 1 column 13",
+        "code": "invalid_vectors_type",
+        "type": "invalid_request",
+        "link": "https://docs.meilisearch.com/errors#invalid_vectors_type"
+      },
+      "duration": "PT0.059920S",
+      "enqueuedAt": "2025-07-07T13:42:15.624598Z",
+      "startedAt": "2025-07-07T13:42:15.625413Z",
+      "finishedAt": "2025-07-07T13:42:15.685333Z"
+    },
+    {
+      "uid": 27,
+      "batchUid": 26,
+      "indexUid": "mieli",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.088879S",
+      "enqueuedAt": "2025-07-07T13:40:01.46081Z",
+      "startedAt": "2025-07-07T13:40:01.461741Z",
+      "finishedAt": "2025-07-07T13:40:01.55062Z"
+    },
+    {
+      "uid": 26,
+      "batchUid": 25,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 1,
+        "indexedDocuments": 1
+      },
+      "error": null,
+      "duration": "PT0.312911S",
+      "enqueuedAt": "2025-07-07T13:32:46.13871Z",
+      "startedAt": "2025-07-07T13:32:46.139785Z",
+      "finishedAt": "2025-07-07T13:32:46.452696Z"
+    },
+    {
+      "uid": 25,
+      "batchUid": 24,
+      "indexUid": "kefir",
+      "status": "succeeded",
+      "type": "settingsUpdate",
+      "canceledBy": null,
+      "details": {
+        "embedders": {
+          "doggo_embedder": {
+            "source": "huggingFace",
+            "model": "sentence-transformers/all-MiniLM-L6-v2",
+            "revision": "e4ce9877abf3edfe10b0d82785e83bdcb973e22e",
+            "documentTemplate": "{{doc.description}}"
+          }
+        }
+      },
+      "error": null,
+      "duration": "PT0.247378S",
+      "enqueuedAt": "2025-07-07T13:28:27.390054Z",
+      "startedAt": "2025-07-07T13:28:27.391344Z",
+      "finishedAt": "2025-07-07T13:28:27.638722Z"
+    },
     {
       "uid": 24,
       "batchUid": 23,
@@ -497,8 +609,8 @@ source: crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs
       "finishedAt": "2025-01-16T16:45:16.131303739Z"
     }
   ],
-  "total": 26,
+  "total": 32,
   "limit": 1000,
-  "from": 25,
+  "from": 31,
   "next": null
 }

crates/meilisearch/tests/upgrade/v1_12/v1_12_0.rs

@@ -114,13 +114,13 @@ async fn check_the_index_scheduler(server: &Server) {
 
     // All the indexes are still present
     let (indexes, _) = server.list_indexes(None, None).await;
-    snapshot!(indexes, @r#"
+    snapshot!(indexes, @r###"
     {
       "results": [
         {
           "uid": "kefir",
           "createdAt": "2025-01-16T16:45:16.020663157Z",
-          "updatedAt": "2025-01-23T11:36:22.634859166Z",
+          "updatedAt": "2025-07-07T13:43:08.835381Z",
           "primaryKey": "id"
         }
       ],
@@ -128,7 +128,7 @@ async fn check_the_index_scheduler(server: &Server) {
       "limit": 20,
       "total": 1
     }
-    "#);
+    "###);
     // And their metadata are still right
     let (stats, _) = server.stats().await;
     assert_json_snapshot!(stats, {
@@ -141,21 +141,21 @@ async fn check_the_index_scheduler(server: &Server) {
     {
       "databaseSize": "[bytes]",
       "usedDatabaseSize": "[bytes]",
-      "lastUpdate": "2025-01-23T11:36:22.634859166Z",
+      "lastUpdate": "2025-07-07T13:43:08.835381Z",
       "indexes": {
         "kefir": {
-          "numberOfDocuments": 1,
+          "numberOfDocuments": 2,
           "rawDocumentDbSize": "[bytes]",
           "avgDocumentSize": "[bytes]",
           "isIndexing": false,
-          "numberOfEmbeddings": 0,
-          "numberOfEmbeddedDocuments": 0,
+          "numberOfEmbeddings": 2,
+          "numberOfEmbeddedDocuments": 2,
           "fieldDistribution": {
-            "age": 1,
-            "description": 1,
-            "id": 1,
-            "name": 1,
-            "surname": 1
+            "age": 2,
+            "description": 2,
+            "id": 2,
+            "name": 2,
+            "surname": 2
           }
         }
       }
@@ -227,21 +227,21 @@ async fn check_the_index_scheduler(server: &Server) {
     {
       "databaseSize": "[bytes]",
       "usedDatabaseSize": "[bytes]",
-      "lastUpdate": "2025-01-23T11:36:22.634859166Z",
+      "lastUpdate": "2025-07-07T13:43:08.835381Z",
       "indexes": {
         "kefir": {
-          "numberOfDocuments": 1,
+          "numberOfDocuments": 2,
           "rawDocumentDbSize": "[bytes]",
           "avgDocumentSize": "[bytes]",
           "isIndexing": false,
-          "numberOfEmbeddings": 0,
-          "numberOfEmbeddedDocuments": 0,
+          "numberOfEmbeddings": 2,
+          "numberOfEmbeddedDocuments": 2,
           "fieldDistribution": {
-            "age": 1,
-            "description": 1,
-            "id": 1,
-            "name": 1,
-            "surname": 1
+            "age": 2,
+            "description": 2,
+            "id": 2,
+            "name": 2,
+            "surname": 2
           }
         }
       }
@@ -254,18 +254,18 @@ async fn check_the_index_scheduler(server: &Server) {
         ".avgDocumentSize" => "[bytes]",
     }), @r###"
     {
-      "numberOfDocuments": 1,
+      "numberOfDocuments": 2,
       "rawDocumentDbSize": "[bytes]",
       "avgDocumentSize": "[bytes]",
       "isIndexing": false,
-      "numberOfEmbeddings": 0,
-      "numberOfEmbeddedDocuments": 0,
+      "numberOfEmbeddings": 2,
+      "numberOfEmbeddedDocuments": 2,
       "fieldDistribution": {
-        "age": 1,
-        "description": 1,
-        "id": 1,
-        "name": 1,
-        "surname": 1
+        "age": 2,
+        "description": 2,
+        "id": 2,
+        "name": 2,
+        "surname": 2
       }
     }
     "###);
@@ -295,4 +295,8 @@ async fn check_the_index_features(server: &Server) {
     let (results, _status) =
         kefir.search_post(json!({ "sort": ["age:asc"], "filter": "surname = kefirounet" })).await;
     snapshot!(results, name: "search_with_sort_and_filter");
+
+    // ensuring we can get the vectors and their `regenerate` is still good.
+    let (results, _status) = kefir.search_post(json!({"retrieveVectors": true})).await;
+    snapshot!(json_string!(results["hits"], {"[]._vectors.doggo_embedder.embeddings" => "[vector]"}), name: "search_with_retrieve_vectors");
 }

crates/meilisearch/tests/vector/rest.rs

@@ -1,7 +1,10 @@
 use std::collections::BTreeMap;
+use std::sync::atomic::AtomicUsize;
+use std::time::Duration;
 
 use meili_snap::{json_string, snapshot};
 use reqwest::IntoUrl;
+use tokio::sync::mpsc;
 use wiremock::matchers::{method, path};
 use wiremock::{Mock, MockServer, Request, ResponseTemplate};
 
@@ -334,6 +337,41 @@ async fn create_mock_raw() -> (MockServer, Value) {
     (mock_server, embedder_settings)
 }
 
+async fn create_faulty_mock_raw(sender: mpsc::Sender<()>) -> (MockServer, Value) {
+    let mock_server = MockServer::start().await;
+    let count = AtomicUsize::new(0);
+
+    Mock::given(method("POST"))
+        .and(path("/"))
+        .respond_with(move |_req: &Request| {
+            let count = count.fetch_add(1, std::sync::atomic::Ordering::SeqCst);
+
+            if count >= 5 {
+                let _ = sender.try_send(());
+                ResponseTemplate::new(500)
+                    .set_delay(Duration::from_secs(u64::MAX)) // Make the response hang forever
+                    .set_body_string("Service Unavailable")
+            } else {
+                ResponseTemplate::new(500).set_body_string("Service Unavailable")
+            }
+        })
+        .mount(&mock_server)
+        .await;
+
+    let url = mock_server.uri();
+
+    let embedder_settings = json!({
+        "source": "rest",
+        "url": url,
+        "dimensions": 3,
+        "request": "{{text}}",
+        "response": "{{embedding}}",
+        "documentTemplate": "{{doc.name}}"
+    });
+
+    (mock_server, embedder_settings)
+}
+
 pub async fn post<T: IntoUrl>(url: T, text: &str) -> reqwest::Result<reqwest::Response> {
     reqwest::Client::builder().build()?.post(url).json(&json!(text)).send().await
 }
@@ -370,13 +408,13 @@ async fn bad_request() {
       .await;
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
-  {
-    "message": "Error while generating embeddings: user error: in `request`: \"{{text}}\" not found",
-    "code": "vector_embedding_error",
-    "type": "invalid_request",
-    "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
-  }
-  "###);
+    {
+      "message": "Error while generating embeddings: user error: in `request`: \"{{text}}\" not found\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
+      "code": "vector_embedding_error",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
+    }
+    "###);
 
     // A repeat string appears inside a repeated value
     let (response, code) = index
@@ -399,7 +437,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.input.input`: \"{{..}}\" appears nested inside of a value that is itself repeated",
+      "message": "Error while generating embeddings: user error: in `request.input.input`: \"{{..}}\" appears nested inside of a value that is itself repeated\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -422,7 +460,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.input.repeat`: \"{{..}}\" appears outside of an array",
+      "message": "Error while generating embeddings: user error: in `request.input.repeat`: \"{{..}}\" appears outside of an array\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -445,7 +483,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.input`: \"{{..}}\" expected at position #1, but found at position #0",
+      "message": "Error while generating embeddings: user error: in `request.input`: \"{{..}}\" expected at position #1, but found at position #0\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -468,7 +506,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.input`: \"{{..}}\" expected at position #1, but found at position #2",
+      "message": "Error while generating embeddings: user error: in `request.input`: \"{{..}}\" expected at position #1, but found at position #2\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -491,7 +529,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.input[0]`: Expected \"{{text}}\" inside of the repeated value",
+      "message": "Error while generating embeddings: user error: in `request.input[0]`: Expected \"{{text}}\" inside of the repeated value\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -518,7 +556,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.data`: Found \"{{..}}\", but it was already present in `request.input`",
+      "message": "Error while generating embeddings: user error: in `request.data`: Found \"{{..}}\", but it was already present in `request.input`\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -539,7 +577,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.data`: Found \"{{text}}\", but it was already present in `request.input`",
+      "message": "Error while generating embeddings: user error: in `request.data`: Found \"{{text}}\", but it was already present in `request.input`\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -560,7 +598,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.repeated.data[1]`: Found \"{{text}}\", but it was already present in `request.repeated.input`",
+      "message": "Error while generating embeddings: user error: in `request.repeated.data[1]`: Found \"{{text}}\", but it was already present in `request.repeated.input`\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -581,7 +619,7 @@ async fn bad_request() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request.data`: Found \"{{text}}\", but it was already present in `request.input[0]` (repeated)",
+      "message": "Error while generating embeddings: user error: in `request.data`: Found \"{{text}}\", but it was already present in `request.input[0]` (repeated)\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -882,7 +920,7 @@ async fn bad_settings() {
     snapshot!(code, @"400 Bad Request");
     snapshot!(response, @r###"
     {
-      "message": "Error while generating embeddings: user error: in `request`: \"{{text}}\" not found",
+      "message": "Error while generating embeddings: user error: in `request`: \"{{text}}\" not found\n  - Note: this template is using a document template, and so expects to contain the placeholder \"{{text}}\" rather than \"{{fragment}}\"",
       "code": "vector_embedding_error",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#vector_embedding_error"
@@ -2111,3 +2149,71 @@ async fn searchable_reindex() {
     }
     "###);
 }
+
+#[actix_rt::test]
+async fn last_error_stats() {
+    let (sender, mut receiver) = mpsc::channel(10);
+    let (_mock, setting) = create_faulty_mock_raw(sender).await;
+    let server = get_server_vector().await;
+    let index = server.index("doggo");
+
+    let (response, code) = index
+        .update_settings(json!({
+          "embedders": {
+              "rest": setting,
+          },
+        }))
+        .await;
+    snapshot!(code, @"202 Accepted");
+    let task = server.wait_task(response.uid()).await;
+    snapshot!(task["status"], @r###""succeeded""###);
+    let documents = json!([
+      {"id": 0, "name": "will_return_500"},
+      {"id": 1, "name": "will_error"},
+      {"id": 2, "name": "must_error"},
+    ]);
+    let (_value, code) = index.add_documents(documents, None).await;
+    snapshot!(code, @"202 Accepted");
+
+    // The task will eventually fail, so let's not wait for it.
+    // Let's just wait for the server's signal
+    receiver.recv().await;
+
+    let (response, _code) = index.filtered_batches(&[], &[], &[]).await;
+    snapshot!(json_string!(response["results"][0], {
+        ".progress" => "[ignored]",
+        ".stats.embedderRequests.total" => "[ignored]",
+        ".stats.embedderRequests.failed" => "[ignored]",
+        ".startedAt" => "[ignored]"
+    }), @r#"
+    {
+      "uid": 1,
+      "progress": "[ignored]",
+      "details": {
+        "receivedDocuments": 3,
+        "indexedDocuments": null
+      },
+      "stats": {
+        "totalNbTasks": 1,
+        "status": {
+          "processing": 1
+        },
+        "types": {
+          "documentAdditionOrUpdate": 1
+        },
+        "indexUids": {
+          "doggo": 1
+        },
+        "embedderRequests": {
+          "total": "[ignored]",
+          "failed": "[ignored]",
+          "lastError": "runtime error: received internal error HTTP 500 from embedding server\n  - server replied with `Service Unavailable`"
+        }
+      },
+      "duration": null,
+      "startedAt": "[ignored]",
+      "finishedAt": null,
+      "batchStrategy": "batched all enqueued tasks"
+    }
+    "#);
+}