feat(metrics): add personalization count to metrics endpoint

- Add MEILISEARCH_PERSONALIZED_SEARCH_REQUESTS metric to track personalized searches
- Increment metric directly in search analytics when personalization is used
- Metric automatically exposed in /metrics endpoint for monitoring

.github/dependabot.yml

@@ -7,6 +7,5 @@ updates:
     schedule:
       interval: "monthly"
     labels:
-      - 'skip changelog'
       - 'dependencies'
     rebase-strategy: disabled

.github/release-draft-template.yml

@@ -1,33 +0,0 @@
-name-template: 'v$RESOLVED_VERSION'
-tag-template: 'v$RESOLVED_VERSION'
-exclude-labels:
-  - 'skip changelog'
-version-resolver:
-  minor:
-    labels:
-      - 'enhancement'
-  default: patch
-categories:
-  - title: '⚠️ Breaking changes'
-    label: 'breaking-change'
-  - title: '🚀 Enhancements'
-    label: 'enhancement'
-  - title: '🐛 Bug Fixes'
-    label: 'bug'
-  - title: '🔒 Security'
-    label: 'security'
-  - title: '⚙️ Maintenance/misc'
-    label:
-      - 'maintenance'
-      - 'documentation'
-template: |
-  $CHANGES
-
-  ❤️  Huge thanks to our contributors: $CONTRIBUTORS.
-no-changes-template: 'Changes are coming soon 😎'
-sort-direction: 'ascending'
-replacers:
-  - search: '/(?:and )?@dependabot-preview(?:\[bot\])?,?/g'
-    replace: ''
-  - search: '/(?:and )?@dependabot(?:\[bot\])?,?/g'
-    replace: ''

.github/workflows/bench-manual.yml

@@ -18,7 +18,7 @@ jobs:
     timeout-minutes: 180 # 3h
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/bench-pr.yml

@@ -66,7 +66,7 @@ jobs:
           fetch-depth: 0 # fetch full history to be able to get main commit sha
           ref: ${{ steps.comment-branch.outputs.head_ref }}
 
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/bench-push-indexing.yml

@@ -12,7 +12,7 @@ jobs:
     timeout-minutes: 180 # 3h
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/benchmarks-manual.yml

@@ -18,7 +18,7 @@ jobs:
     timeout-minutes: 4320 # 72h
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/benchmarks-pr.yml

@@ -44,7 +44,7 @@ jobs:
             exit 1
           fi
 
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/benchmarks-push-indexing.yml

@@ -16,7 +16,7 @@ jobs:
     timeout-minutes: 4320 # 72h
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/benchmarks-push-search-geo.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: benchmarks
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/benchmarks-push-search-songs.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: benchmarks
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/benchmarks-push-search-wiki.yml

@@ -15,7 +15,7 @@ jobs:
     runs-on: benchmarks
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/flaky-tests.yml

@@ -17,7 +17,7 @@ jobs:
         run: |
           apt-get update && apt-get install -y curl
           apt-get install build-essential -y
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Install cargo-flaky
         run: cargo install cargo-flaky
       - name: Run cargo flaky in the dumps

.github/workflows/fuzzer-indexing.yml

@@ -12,7 +12,7 @@ jobs:
     timeout-minutes: 4320 # 72h
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
 

.github/workflows/publish-apt-brew-pkg.yml

@@ -25,7 +25,7 @@ jobs:
         run: |
           apt-get update && apt-get install -y curl
           apt-get install build-essential -y
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Install cargo-deb
         run: cargo install cargo-deb
       - uses: actions/checkout@v5

.github/workflows/publish-docker-images.yml

@@ -65,7 +65,7 @@ jobs:
         uses: docker/setup-buildx-action@v3
 
       - name: Install cosign
-        uses: sigstore/cosign-installer@d58896d6a1865668819e1d91763c7751a165e159 # tag=v3.9.2
+        uses: sigstore/cosign-installer@d7543c93d881b35a8faa02e8e3605f69b7a1ce62 # tag=v3.10.0
 
       - name: Login to Docker Hub
         uses: docker/login-action@v3

.github/workflows/publish-release-assets.yml

@@ -11,7 +11,7 @@ jobs:
   check-version:
     name: Check the version validity
     runs-on: ubuntu-latest
-    # No need to check the version for dry run (cron)
+    # No need to check the version for dry run (cron or workflow_dispatch)
     steps:
       - uses: actions/checkout@v5
       # Check if the tag has the v<nmumber>.<number>.<number> format.
@@ -45,10 +45,10 @@ jobs:
         run: |
           apt-get update && apt-get install -y curl
           apt-get install build-essential -y
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Build
         run: cargo build --release --locked
-      # No need to upload binaries for dry run (cron)
+      # No need to upload binaries for dry run (cron or workflow_dispatch)
       - name: Upload binaries to release
         if: github.event_name == 'release'
         uses: svenstaro/upload-release-action@2.11.2
@@ -75,10 +75,10 @@ jobs:
             asset_name: meilisearch-windows-amd64.exe
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Build
         run: cargo build --release --locked
-      # No need to upload binaries for dry run (cron)
+      # No need to upload binaries for dry run (cron or workflow_dispatch)
       - name: Upload binaries to release
         if: github.event_name == 'release'
         uses: svenstaro/upload-release-action@2.11.2
@@ -101,7 +101,7 @@ jobs:
       - name: Checkout repository
         uses: actions/checkout@v5
       - name: Installing Rust toolchain
-        uses: dtolnay/rust-toolchain@1.85
+        uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
           target: ${{ matrix.target }}
@@ -111,7 +111,7 @@ jobs:
           command: build
           args: --release --target ${{ matrix.target }}
       - name: Upload the binary to release
-        # No need to upload binaries for dry run (cron)
+        # No need to upload binaries for dry run (cron or workflow_dispatch)
         if: github.event_name == 'release'
         uses: svenstaro/upload-release-action@2.11.2
         with:
@@ -148,7 +148,7 @@ jobs:
           add-apt-repository "deb [arch=$(dpkg --print-architecture)] https://download.docker.com/linux/ubuntu $(lsb_release -cs) stable"
           apt-get update -y && apt-get install -y docker-ce
       - name: Installing Rust toolchain
-        uses: dtolnay/rust-toolchain@1.85
+        uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
           target: ${{ matrix.target }}
@@ -176,7 +176,7 @@ jobs:
       - name: List target output files
         run: ls -lR ./target
       - name: Upload the binary to release
-        # No need to upload binaries for dry run (cron)
+        # No need to upload binaries for dry run (cron or workflow_dispatch)
         if: github.event_name == 'release'
         uses: svenstaro/upload-release-action@2.11.2
         with:
@@ -187,6 +187,7 @@ jobs:
 
   publish-openapi-file:
     name: Publish OpenAPI file
+    needs: check-version
     runs-on: ubuntu-latest
     steps:
       - name: Checkout code
@@ -201,7 +202,7 @@ jobs:
           cd crates/openapi-generator
           cargo run --release -- --pretty --output ../../meilisearch.json
       - name: Upload OpenAPI to Release
-        # No need to upload for dry run (cron)
+        # No need to upload for dry run (cron or workflow_dispatch)
         if: github.event_name == 'release'
         uses: svenstaro/upload-release-action@2.11.2
         with:

.github/workflows/release-drafter.yml

@@ -1,20 +0,0 @@
-name: Release Drafter
-
-permissions:
-  contents: read
-  pull-requests: write
-
-on:
-  push:
-    branches:
-      - main
-
-jobs:
-  update_release_draft:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: release-drafter/release-drafter@v6
-        with:
-          config-name: release-draft-template.yml
-        env:
-          GITHUB_TOKEN: ${{ secrets.RELEASE_DRAFTER_TOKEN }}

.github/workflows/sdks-tests.yml

@@ -50,7 +50,7 @@ jobs:
         with:
           repository: meilisearch/meilisearch-dotnet
       - name: Setup .NET Core
-        uses: actions/setup-dotnet@v4
+        uses: actions/setup-dotnet@v5
         with:
           dotnet-version: "8.0.x"
       - name: Install dependencies
@@ -100,7 +100,7 @@ jobs:
           - '7700:7700'
     steps:
       - name: Set up Go
-        uses: actions/setup-go@v5
+        uses: actions/setup-go@v6
         with:
           go-version: stable
       - uses: actions/checkout@v5
@@ -135,13 +135,13 @@ jobs:
       - name: Set up Java
         uses: actions/setup-java@v5
         with:
-          java-version: 8
-          distribution: 'zulu'
+          java-version: 17
+          distribution: 'temurin'
           cache: gradle
       - name: Grant execute permission for gradlew
         run: chmod +x gradlew
       - name: Build and run unit and integration tests
-        run: ./gradlew build integrationTest
+        run: ./gradlew build integrationTest --info
 
   meilisearch-js-tests:
     needs: define-docker-image
@@ -160,7 +160,7 @@ jobs:
         with:
           repository: meilisearch/meilisearch-js
       - name: Setup node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           cache: 'yarn'
       - name: Install dependencies
@@ -224,7 +224,7 @@ jobs:
         with:
           repository: meilisearch/meilisearch-python
       - name: Set up Python
-        uses: actions/setup-python@v5
+        uses: actions/setup-python@v6
       - name: Install pipenv
         uses: dschep/install-pipenv-action@v1
       - name: Install dependencies
@@ -318,7 +318,7 @@ jobs:
         with:
           repository: meilisearch/meilisearch-js-plugins
       - name: Setup node
-        uses: actions/setup-node@v4
+        uses: actions/setup-node@v5
         with:
           cache: yarn
       - name: Install dependencies

.github/workflows/test-suite.yml

@@ -27,7 +27,7 @@ jobs:
           apt-get update && apt-get install -y curl
           apt-get install build-essential -y
       - name: Setup test with Rust stable
-        uses: dtolnay/rust-toolchain@1.85
+        uses: dtolnay/rust-toolchain@1.89
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2.8.0
       - name: Run cargo check without any default features
@@ -52,7 +52,7 @@ jobs:
       - uses: actions/checkout@v5
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2.8.0
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Run cargo check without any default features
         uses: actions-rs/cargo@v1
         with:
@@ -77,7 +77,7 @@ jobs:
         run: |
           apt-get update
           apt-get install --assume-yes build-essential curl
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Run cargo build with almost all features
         run: |
           cargo build --workspace --locked --release --features "$(cargo xtask list-features --exclude-feature cuda,test-ollama)"
@@ -129,7 +129,7 @@ jobs:
         run: |
           apt-get update
           apt-get install --assume-yes build-essential curl
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Run cargo tree without default features and check lindera is not present
         run: |
           if cargo tree -f '{p} {f}' -e normal --no-default-features | grep -qz lindera; then
@@ -153,7 +153,7 @@ jobs:
         run: |
           apt-get update && apt-get install -y curl
           apt-get install build-essential -y
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
       - name: Cache dependencies
         uses: Swatinem/rust-cache@v2.8.0
       - name: Run tests in debug
@@ -167,7 +167,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
           components: clippy
@@ -184,7 +184,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
           toolchain: nightly-2024-07-09

.github/workflows/update-cargo-toml-version.yml

@@ -18,7 +18,7 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v5
-      - uses: dtolnay/rust-toolchain@1.85
+      - uses: dtolnay/rust-toolchain@1.89
         with:
           profile: minimal
       - name: Install sd

Cargo.toml

@@ -23,7 +23,7 @@ members = [
 ]
 
 [workspace.package]
-version = "1.21.0"
+version = "1.23.0"
 authors = [
     "Quentin de Quelen <quentin@dequelen.me>",
     "Clément Renault <clement@meilisearch.com>",

Dockerfile

@@ -1,5 +1,5 @@
 # Compile
-FROM    rust:1.85-alpine3.20 AS compiler
+FROM    rust:1.89-alpine3.20 AS compiler
 
 RUN     apk add -q --no-cache build-base openssl-dev
 

LICENSE

@@ -1,29 +1,9 @@
-MIT License
+# License
 
 Copyright (c) 2019-2025 Meili SAS
 
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
+Part of this work fall under the Meilisearch Enterprise Edition (EE) and are licensed under the Business Source License 1.1, please refer to [LICENSE-EE](./LICENSE-EE) for details.
 
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
+The other parts of this work are licensed under the [MIT license](./LICENSE-MIT).
 
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
----
-
-🔒 Meilisearch Enterprise Edition (EE)
-
-Certain parts of this codebase are not licensed under the MIT license and governed by the Business Source License 1.1.
-
-See the LICENSE-EE file for details.
+`SPDX-License-Identifier: MIT AND BUSL-1.1`

LICENSE-MIT

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019-2025 Meili SAS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -121,7 +121,7 @@ If you want to know more about the kind of data we collect and what we use it fo
 
 Meilisearch is a search engine created by [Meili](https://www.meilisearch.com/careers), a software development company headquartered in France and with team members all over the world. Want to know more about us? [Check out our blog!](https://blog.meilisearch.com/?utm_campaign=oss&utm_source=github&utm_medium=meilisearch&utm_content=contact)
 
-🗞 [Subscribe to our newsletter](https://meilisearch.us2.list-manage.com/subscribe?u=27870f7b71c908a8b359599fb&id=79582d828e) if you don't want to miss any updates! We promise we won't clutter your mailbox: we only send one edition every two months.
+🗞 [Subscribe to our newsletter](https://share-eu1.hsforms.com/1LN5N0x_GQgq7ss7tXmSykwfg3aq) if you don't want to miss any updates! We promise we won't clutter your mailbox: we only send one edition every two months.
 
 💌 Want to make a suggestion or give feedback? Here are some of the channels where you can reach us:
 

crates/dump/src/lib.rs

@@ -158,6 +158,9 @@ pub enum KindDump {
     UpgradeDatabase {
         from: (u32, u32, u32),
     },
+    IndexCompaction {
+        index_uid: String,
+    },
 }
 
 impl From<Task> for TaskDump {
@@ -240,6 +243,9 @@ impl From<KindWithContent> for KindDump {
             KindWithContent::UpgradeDatabase { from: version } => {
                 KindDump::UpgradeDatabase { from: version }
             }
+            KindWithContent::IndexCompaction { index_uid } => {
+                KindDump::IndexCompaction { index_uid }
+            }
         }
     }
 }

crates/dump/src/reader/compat/v2_to_v3.rs

@@ -97,6 +97,7 @@ impl CompatV2ToV3 {
     }
 }
 
+#[allow(clippy::large_enum_variant)]
 pub enum CompatIndexV2ToV3 {
     V2(v2::V2IndexReader),
     Compat(Box<CompatIndexV1ToV2>),

crates/filter-parser/src/condition.rs

@@ -7,23 +7,14 @@
 
 use nom::branch::alt;
 use nom::bytes::complete::tag;
-use nom::character::complete::char;
-use nom::character::complete::multispace0;
-use nom::character::complete::multispace1;
-use nom::combinator::cut;
-use nom::combinator::map;
-use nom::combinator::value;
-use nom::sequence::preceded;
-use nom::sequence::{terminated, tuple};
+use nom::character::complete::{char, multispace0, multispace1};
+use nom::combinator::{cut, map, value};
+use nom::sequence::{preceded, terminated, tuple};
 use Condition::*;
 
 use crate::error::IResultExt;
-use crate::value::parse_vector_value;
-use crate::value::parse_vector_value_cut;
-use crate::Error;
-use crate::ErrorKind;
-use crate::VectorFilter;
-use crate::{parse_value, FilterCondition, IResult, Span, Token};
+use crate::value::{parse_vector_value, parse_vector_value_cut};
+use crate::{parse_value, Error, ErrorKind, FilterCondition, IResult, Span, Token, VectorFilter};
 
 #[derive(Debug, Clone, PartialEq, Eq)]
 pub enum Condition<'a> {
@@ -124,7 +115,7 @@ pub fn parse_not_exists(input: Span) -> IResult<FilterCondition> {
     Ok((input, FilterCondition::Not(Box::new(FilterCondition::Condition { fid: key, op: Exists }))))
 }
 
-fn parse_vectors(input: Span) -> IResult<(Token, Option<Token>, VectorFilter<'_>)> {
+fn parse_vectors(input: Span) -> IResult<(Token, Option<Token>, VectorFilter)> {
     let (input, _) = multispace0(input)?;
     let (input, fid) = tag("_vectors")(input)?;
 

crates/filter-parser/src/error.rs

@@ -75,7 +75,11 @@ pub enum ExpectedValueKind {
 pub enum ErrorKind<'a> {
     ReservedGeo(&'a str),
     GeoRadius,
+    GeoRadiusArgumentCount(usize),
     GeoBoundingBox,
+    GeoPolygon,
+    GeoPolygonNotEnoughPoints(usize),
+    GeoCoordinatesNotPair(usize),
     MisusedGeoRadius,
     MisusedGeoBoundingBox,
     VectorFilterLeftover,
@@ -189,7 +193,7 @@ impl Display for Error<'_> {
             }
             ErrorKind::InvalidPrimary => {
                 let text = if input.trim().is_empty() { "but instead got nothing.".to_string() } else { format!("at `{}`.", escaped_input) };
-                writeln!(f, "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` {}", text)?
+                writeln!(f, "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` {text}")?
             }
             ErrorKind::InvalidEscapedNumber => {
                 writeln!(f, "Found an invalid escaped sequence number: `{}`.", escaped_input)?
@@ -198,11 +202,23 @@ impl Display for Error<'_> {
                 writeln!(f, "Found unexpected characters at the end of the filter: `{}`. You probably forgot an `OR` or an `AND` rule.", escaped_input)?
             }
             ErrorKind::GeoRadius => {
-                writeln!(f, "The `_geoRadius` filter expects three arguments: `_geoRadius(latitude, longitude, radius)`.")?
+                writeln!(f, "The `_geoRadius` filter must be in the form: `_geoRadius(latitude, longitude, radius, optionalResolution)`.")?
+            }
+            ErrorKind::GeoRadiusArgumentCount(count) => {
+                writeln!(f, "Was expecting 3 or 4 arguments for `_geoRadius`, but instead found {count}.")?
             }
             ErrorKind::GeoBoundingBox => {
                 writeln!(f, "The `_geoBoundingBox` filter expects two pairs of arguments: `_geoBoundingBox([latitude, longitude], [latitude, longitude])`.")?
             }
+            ErrorKind::GeoPolygon => {
+                writeln!(f, "The `_geoPolygon` filter doesn't match the expected format: `_geoPolygon([latitude, longitude], [latitude, longitude])`.")?
+            }
+            ErrorKind::GeoPolygonNotEnoughPoints(n) => {
+                writeln!(f, "The `_geoPolygon` filter expects at least 3 points but only {n} were specified")?;
+            }
+            ErrorKind::GeoCoordinatesNotPair(number) => {
+                writeln!(f, "Was expecting 2 coordinates but instead found {number}.")?
+            }
             ErrorKind::ReservedGeo(name) => {
                 writeln!(f, "`{}` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.", name.escape_debug())?
             }

crates/filter-parser/src/lib.rs

@@ -19,6 +19,7 @@
 //! word           = (alphanumeric | _ | - | .)+
 //! geoRadius      = "_geoRadius(" WS* float WS* "," WS* float WS* "," float WS* ")"
 //! geoBoundingBox = "_geoBoundingBox([" WS * float WS* "," WS* float WS* "], [" WS* float WS* "," WS* float WS* "]")
+//! geoPolygon     = "_geoPolygon([[" WS* float WS* "," WS* float WS* "],+])"
 //! ```
 //!
 //! Other BNF grammar used to handle some specific errors:
@@ -116,7 +117,7 @@ impl<'a> Token<'a> {
         self.span
     }
 
-    pub fn parse_finite_float(&self) -> Result<f64, Error> {
+    pub fn parse_finite_float(&self) -> Result<f64, Error<'a>> {
         let value: f64 = self.value().parse().map_err(|e| self.as_external_error(e))?;
         if value.is_finite() {
             Ok(value)
@@ -156,8 +157,9 @@ pub enum FilterCondition<'a> {
     Or(Vec<Self>),
     And(Vec<Self>),
     VectorExists { fid: Token<'a>, embedder: Option<Token<'a>>, filter: VectorFilter<'a> },
-    GeoLowerThan { point: [Token<'a>; 2], radius: Token<'a> },
+    GeoLowerThan { point: [Token<'a>; 2], radius: Token<'a>, resolution: Option<Token<'a>> },
     GeoBoundingBox { top_right_point: [Token<'a>; 2], bottom_left_point: [Token<'a>; 2] },
+    GeoPolygon { points: Vec<[Token<'a>; 2]> },
 }
 
 pub enum TraversedElement<'a> {
@@ -166,7 +168,7 @@ pub enum TraversedElement<'a> {
 }
 
 impl<'a> FilterCondition<'a> {
-    pub fn use_contains_operator(&self) -> Option<&Token> {
+    pub fn use_contains_operator(&self) -> Option<&Token<'a>> {
         match self {
             FilterCondition::Condition { fid: _, op } => match op {
                 Condition::GreaterThan(_)
@@ -189,11 +191,12 @@ impl<'a> FilterCondition<'a> {
             FilterCondition::VectorExists { .. }
             | FilterCondition::GeoLowerThan { .. }
             | FilterCondition::GeoBoundingBox { .. }
+            | FilterCondition::GeoPolygon { .. }
             | FilterCondition::In { .. } => None,
         }
     }
 
-    pub fn use_vector_filter(&self) -> Option<&Token> {
+    pub fn use_vector_filter(&self) -> Option<&Token<'a>> {
         match self {
             FilterCondition::Condition { .. } => None,
             FilterCondition::Not(this) => this.use_vector_filter(),
@@ -202,12 +205,13 @@ impl<'a> FilterCondition<'a> {
             }
             FilterCondition::GeoLowerThan { .. }
             | FilterCondition::GeoBoundingBox { .. }
+            | FilterCondition::GeoPolygon { .. }
             | FilterCondition::In { .. } => None,
             FilterCondition::VectorExists { fid, .. } => Some(fid),
         }
     }
 
-    pub fn fids(&self, depth: usize) -> Box<dyn Iterator<Item = &Token> + '_> {
+    pub fn fids(&self, depth: usize) -> Box<dyn Iterator<Item = &Token<'a>> + '_> {
         if depth == 0 {
             return Box::new(std::iter::empty());
         }
@@ -228,7 +232,7 @@ impl<'a> FilterCondition<'a> {
     }
 
     /// Returns the first token found at the specified depth, `None` if no token at this depth.
-    pub fn token_at_depth(&self, depth: usize) -> Option<&Token> {
+    pub fn token_at_depth(&self, depth: usize) -> Option<&Token<'a>> {
         match self {
             FilterCondition::Condition { fid, .. } if depth == 0 => Some(fid),
             FilterCondition::Or(subfilters) => {
@@ -396,23 +400,27 @@ fn parse_not(input: Span, depth: usize) -> IResult<FilterCondition> {
 /// If we parse `_geoRadius` we MUST parse the rest of the expression.
 fn parse_geo_radius(input: Span) -> IResult<FilterCondition> {
     // we want to allow space BEFORE the _geoRadius but not after
-    let parsed = preceded(
-        tuple((multispace0, word_exact("_geoRadius"))),
-        // if we were able to parse `_geoRadius` and can't parse the rest of the input we return a failure
-        cut(delimited(char('('), separated_list1(tag(","), ws(recognize_float)), char(')'))),
-    )(input)
-    .map_err(|e| e.map(|_| Error::new_from_kind(input, ErrorKind::GeoRadius)));
+
+    let (input, _) = tuple((multispace0, word_exact("_geoRadius")))(input)?;
+
+    // if we were able to parse `_geoRadius` and can't parse the rest of the input we return a failure
+
+    let parsed =
+        delimited(char('('), separated_list1(tag(","), ws(recognize_float)), char(')'))(input)
+            .map_cut(ErrorKind::GeoRadius);
 
     let (input, args) = parsed?;
 
-    if args.len() != 3 {
-        return Err(nom::Err::Failure(Error::new_from_kind(input, ErrorKind::GeoRadius)));
+    if !(3..=4).contains(&args.len()) {
+        return Err(Error::failure_from_kind(input, ErrorKind::GeoRadiusArgumentCount(args.len())));
     }
 
     let res = FilterCondition::GeoLowerThan {
         point: [args[0].into(), args[1].into()],
         radius: args[2].into(),
+        resolution: args.get(3).cloned().map(Token::from),
     };
+
     Ok((input, res))
 }
 
@@ -420,26 +428,33 @@ fn parse_geo_radius(input: Span) -> IResult<FilterCondition> {
 /// If we parse `_geoBoundingBox` we MUST parse the rest of the expression.
 fn parse_geo_bounding_box(input: Span) -> IResult<FilterCondition> {
     // we want to allow space BEFORE the _geoBoundingBox but not after
-    let parsed = preceded(
-        tuple((multispace0, word_exact("_geoBoundingBox"))),
-        // if we were able to parse `_geoBoundingBox` and can't parse the rest of the input we return a failure
-        cut(delimited(
-            char('('),
-            separated_list1(
-                tag(","),
-                ws(delimited(char('['), separated_list1(tag(","), ws(recognize_float)), char(']'))),
-            ),
-            char(')'),
-        )),
+
+    let (input, _) = tuple((multispace0, word_exact("_geoBoundingBox")))(input)?;
+
+    // if we were able to parse `_geoBoundingBox` and can't parse the rest of the input we return a failure
+
+    let (input, args) = delimited(
+        char('('),
+        separated_list1(
+            tag(","),
+            ws(delimited(char('['), separated_list1(tag(","), ws(recognize_float)), char(']'))),
+        ),
+        char(')'),
     )(input)
-    .map_err(|e| e.map(|_| Error::new_from_kind(input, ErrorKind::GeoBoundingBox)));
+    .map_cut(ErrorKind::GeoBoundingBox)?;
 
-    let (input, args) = parsed?;
-
-    if args.len() != 2 || args[0].len() != 2 || args[1].len() != 2 {
+    if args.len() != 2 {
         return Err(Error::failure_from_kind(input, ErrorKind::GeoBoundingBox));
     }
 
+    if let Some(offending) = args.iter().find(|a| a.len() != 2) {
+        let context = offending.first().unwrap_or(&input);
+        return Err(Error::failure_from_kind(
+            *context,
+            ErrorKind::GeoCoordinatesNotPair(offending.len()),
+        ));
+    }
+
     let res = FilterCondition::GeoBoundingBox {
         top_right_point: [args[0][0].into(), args[0][1].into()],
         bottom_left_point: [args[1][0].into(), args[1][1].into()],
@@ -447,6 +462,47 @@ fn parse_geo_bounding_box(input: Span) -> IResult<FilterCondition> {
     Ok((input, res))
 }
 
+/// geoPolygon     = "_geoPolygon([[" WS* float WS* "," WS* float WS* "],+])"
+/// If we parse `_geoPolygon` we MUST parse the rest of the expression.
+fn parse_geo_polygon(input: Span) -> IResult<FilterCondition> {
+    // we want to allow space BEFORE the _geoPolygon but not after
+
+    let (input, _) = tuple((multispace0, word_exact("_geoPolygon")))(input)?;
+
+    // if we were able to parse `_geoPolygon` and can't parse the rest of the input we return a failure
+
+    let (input, args): (_, Vec<Vec<LocatedSpan<_, _>>>) = delimited(
+        char('('),
+        separated_list1(
+            tag(","),
+            ws(delimited(char('['), separated_list1(tag(","), ws(recognize_float)), char(']'))),
+        ),
+        preceded(opt(ws(char(','))), char(')')), // Tolerate trailing comma
+    )(input)
+    .map_cut(ErrorKind::GeoPolygon)?;
+
+    if args.len() < 3 {
+        let context = args.last().and_then(|a| a.last()).unwrap_or(&input);
+        return Err(Error::failure_from_kind(
+            *context,
+            ErrorKind::GeoPolygonNotEnoughPoints(args.len()),
+        ));
+    }
+
+    if let Some(offending) = args.iter().find(|a| a.len() != 2) {
+        let context = offending.first().unwrap_or(&input);
+        return Err(Error::failure_from_kind(
+            *context,
+            ErrorKind::GeoCoordinatesNotPair(offending.len()),
+        ));
+    }
+
+    let res = FilterCondition::GeoPolygon {
+        points: args.into_iter().map(|a| [a[0].into(), a[1].into()]).collect(),
+    };
+    Ok((input, res))
+}
+
 /// geoPoint      = WS* "_geoPoint(float WS* "," WS* float WS* "," WS* float)
 fn parse_geo_point(input: Span) -> IResult<FilterCondition> {
     // we want to forbid space BEFORE the _geoPoint but not after
@@ -516,8 +572,8 @@ fn parse_primary(input: Span, depth: usize) -> IResult<FilterCondition> {
                 Error::new_from_kind(input, ErrorKind::MissingClosingDelimiter(c.char()))
             }),
         ),
-        parse_geo_radius,
-        parse_geo_bounding_box,
+        // Made a random block of functions because we reached the maximum number of elements per alt
+        alt((parse_geo_radius, parse_geo_bounding_box, parse_geo_polygon)),
         parse_in,
         parse_not_in,
         parse_condition,
@@ -597,9 +653,12 @@ impl std::fmt::Display for FilterCondition<'_> {
                 }
                 write!(f, " EXISTS")
             }
-            FilterCondition::GeoLowerThan { point, radius } => {
+            FilterCondition::GeoLowerThan { point, radius, resolution: None } => {
                 write!(f, "_geoRadius({}, {}, {})", point[0], point[1], radius)
             }
+            FilterCondition::GeoLowerThan { point, radius, resolution: Some(resolution) } => {
+                write!(f, "_geoRadius({}, {}, {}, {})", point[0], point[1], radius, resolution)
+            }
             FilterCondition::GeoBoundingBox {
                 top_right_point: top_left_point,
                 bottom_left_point: bottom_right_point,
@@ -613,6 +672,13 @@ impl std::fmt::Display for FilterCondition<'_> {
                     bottom_right_point[1]
                 )
             }
+            FilterCondition::GeoPolygon { points } => {
+                write!(f, "_geoPolygon([")?;
+                for point in points {
+                    write!(f, "[{}, {}], ", point[0], point[1])?;
+                }
+                write!(f, "])")
+            }
         }
     }
 }
@@ -651,7 +717,7 @@ pub mod tests {
     /// Create a raw [Token]. You must specify the string that appear BEFORE your element followed by your element
     pub fn rtok<'a>(before: &'a str, value: &'a str) -> Token<'a> {
         // if the string is empty we still need to return 1 for the line number
-        let lines = before.is_empty().then_some(1).unwrap_or_else(|| before.lines().count());
+        let lines = if before.is_empty() { 1 } else { before.lines().count() };
         let offset = before.chars().count();
         // the extra field is not checked in the tests so we can set it to nothing
         unsafe { Span::new_from_raw_offset(offset, lines as u32, value, "") }.into()
@@ -776,12 +842,17 @@ pub mod tests {
         insta::assert_snapshot!(p("_geoRadius(12, 13, 14)"), @"_geoRadius({12}, {13}, {14})");
         insta::assert_snapshot!(p("NOT _geoRadius(12, 13, 14)"), @"NOT (_geoRadius({12}, {13}, {14}))");
         insta::assert_snapshot!(p("_geoRadius(12,13,14)"), @"_geoRadius({12}, {13}, {14})");
+        insta::assert_snapshot!(p("_geoRadius(12,13,14,1000)"), @"_geoRadius({12}, {13}, {14}, {1000})");
 
         // Test geo bounding box
         insta::assert_snapshot!(p("_geoBoundingBox([12, 13], [14, 15])"), @"_geoBoundingBox([{12}, {13}], [{14}, {15}])");
         insta::assert_snapshot!(p("NOT _geoBoundingBox([12, 13], [14, 15])"), @"NOT (_geoBoundingBox([{12}, {13}], [{14}, {15}]))");
         insta::assert_snapshot!(p("_geoBoundingBox([12,13],[14,15])"), @"_geoBoundingBox([{12}, {13}], [{14}, {15}])");
 
+        // Test geo polygon
+        insta::assert_snapshot!(p("_geoPolygon([12, 13], [14, 15], [16, 17])"), @"_geoPolygon([[{12}, {13}], [{14}, {15}], [{16}, {17}], ])");
+        insta::assert_snapshot!(p("_geoPolygon([12, 13], [14, 15], [-1.2,2939.2], [1,1])"), @"_geoPolygon([[{12}, {13}], [{14}, {15}], [{-1.2}, {2939.2}], [{1}, {1}], ])");
+
         // Test OR + AND
         insta::assert_snapshot!(p("channel = ponce AND 'dog race' != 'bernese mountain'"), @"AND[{channel} = {ponce}, {dog race} != {bernese mountain}, ]");
         insta::assert_snapshot!(p("channel = ponce OR 'dog race' != 'bernese mountain'"), @"OR[{channel} = {ponce}, {dog race} != {bernese mountain}, ]");
@@ -838,50 +909,80 @@ pub mod tests {
         11:12 channel = 🐻 AND followers < 100
         "###);
 
-        insta::assert_snapshot!(p("'OR'"), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `\'OR\'`.
+        insta::assert_snapshot!(p("'OR'"), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `\'OR\'`.
         1:5 'OR'
-        "###);
+        ");
 
         insta::assert_snapshot!(p("OR"), @r###"
         Was expecting a value but instead got `OR`, which is a reserved keyword. To use `OR` as a field name or a value, surround it by quotes.
         1:3 OR
         "###);
 
-        insta::assert_snapshot!(p("channel Ponce"), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `channel Ponce`.
+        insta::assert_snapshot!(p("channel Ponce"), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `channel Ponce`.
         1:14 channel Ponce
-        "###);
+        ");
 
-        insta::assert_snapshot!(p("channel = Ponce OR"), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` but instead got nothing.
+        insta::assert_snapshot!(p("channel = Ponce OR"), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` but instead got nothing.
         19:19 channel = Ponce OR
-        "###);
+        ");
 
-        insta::assert_snapshot!(p("_geoRadius"), @r###"
-        The `_geoRadius` filter expects three arguments: `_geoRadius(latitude, longitude, radius)`.
-        1:11 _geoRadius
-        "###);
+        insta::assert_snapshot!(p("_geoRadius"), @r"
+        The `_geoRadius` filter must be in the form: `_geoRadius(latitude, longitude, radius, optionalResolution)`.
+        11:11 _geoRadius
+        ");
 
-        insta::assert_snapshot!(p("_geoRadius = 12"), @r###"
-        The `_geoRadius` filter expects three arguments: `_geoRadius(latitude, longitude, radius)`.
-        1:16 _geoRadius = 12
-        "###);
+        insta::assert_snapshot!(p("_geoRadius = 12"), @r"
+        The `_geoRadius` filter must be in the form: `_geoRadius(latitude, longitude, radius, optionalResolution)`.
+        11:16 _geoRadius = 12
+        ");
 
-        insta::assert_snapshot!(p("_geoBoundingBox"), @r###"
+        insta::assert_snapshot!(p("_geoBoundingBox"), @r"
         The `_geoBoundingBox` filter expects two pairs of arguments: `_geoBoundingBox([latitude, longitude], [latitude, longitude])`.
-        1:16 _geoBoundingBox
-        "###);
+        16:16 _geoBoundingBox
+        ");
 
-        insta::assert_snapshot!(p("_geoBoundingBox = 12"), @r###"
+        insta::assert_snapshot!(p("_geoBoundingBox = 12"), @r"
         The `_geoBoundingBox` filter expects two pairs of arguments: `_geoBoundingBox([latitude, longitude], [latitude, longitude])`.
-        1:21 _geoBoundingBox = 12
-        "###);
+        16:21 _geoBoundingBox = 12
+        ");
 
-        insta::assert_snapshot!(p("_geoBoundingBox(1.0, 1.0)"), @r###"
+        insta::assert_snapshot!(p("_geoBoundingBox(1.0, 1.0)"), @r"
         The `_geoBoundingBox` filter expects two pairs of arguments: `_geoBoundingBox([latitude, longitude], [latitude, longitude])`.
-        1:26 _geoBoundingBox(1.0, 1.0)
-        "###);
+        17:26 _geoBoundingBox(1.0, 1.0)
+        ");
+
+        insta::assert_snapshot!(p("_geoPolygon([1,2,3])"), @r"
+        The `_geoPolygon` filter expects at least 3 points but only 1 were specified
+        18:19 _geoPolygon([1,2,3])
+        ");
+
+        insta::assert_snapshot!(p("_geoPolygon(1,2,3)"), @r"
+        The `_geoPolygon` filter doesn't match the expected format: `_geoPolygon([latitude, longitude], [latitude, longitude])`.
+        13:19 _geoPolygon(1,2,3)
+        ");
+
+        insta::assert_snapshot!(p("_geoPolygon([1,2],[1,2],[1,2,3])"), @r"
+        Was expecting 2 coordinates but instead found 3.
+        26:27 _geoPolygon([1,2],[1,2],[1,2,3])
+        ");
+
+        insta::assert_snapshot!(p("_geoPolygon([1,2],[1,2,3])"), @r"
+        The `_geoPolygon` filter expects at least 3 points but only 2 were specified
+        24:25 _geoPolygon([1,2],[1,2,3])
+        ");
+
+        insta::assert_snapshot!(p("_geoPolygon(1)"), @r"
+        The `_geoPolygon` filter doesn't match the expected format: `_geoPolygon([latitude, longitude], [latitude, longitude])`.
+        13:15 _geoPolygon(1)
+        ");
+
+        insta::assert_snapshot!(p("_geoPolygon([1,2)"), @r"
+        The `_geoPolygon` filter doesn't match the expected format: `_geoPolygon([latitude, longitude], [latitude, longitude])`.
+        17:18 _geoPolygon([1,2)
+        ");
 
         insta::assert_snapshot!(p("_geoPoint(12, 13, 14)"), @r###"
         `_geoPoint` is a reserved keyword and thus can't be used as a filter expression. Use the `_geoRadius(latitude, longitude, distance)` or `_geoBoundingBox([latitude, longitude], [latitude, longitude])` built-in rules to filter on `_geo` coordinates.
@@ -938,15 +1039,15 @@ pub mod tests {
         34:35 channel = mv OR followers >= 1000)
         "###);
 
-        insta::assert_snapshot!(p("colour NOT EXIST"), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `colour NOT EXIST`.
+        insta::assert_snapshot!(p("colour NOT EXIST"), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `colour NOT EXIST`.
         1:17 colour NOT EXIST
-        "###);
+        ");
 
-        insta::assert_snapshot!(p("subscribers 100 TO1000"), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `subscribers 100 TO1000`.
+        insta::assert_snapshot!(p("subscribers 100 TO1000"), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `subscribers 100 TO1000`.
         1:23 subscribers 100 TO1000
-        "###);
+        ");
 
         insta::assert_snapshot!(p("channel = ponce ORdog != 'bernese mountain'"), @r###"
         Found unexpected characters at the end of the filter: `ORdog != \'bernese mountain\'`. You probably forgot an `OR` or an `AND` rule.
@@ -1071,38 +1172,38 @@ pub mod tests {
         5:7 NOT OR EXISTS AND EXISTS NOT EXISTS
         "###);
 
-        insta::assert_snapshot!(p(r#"value NULL"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value NULL`.
+        insta::assert_snapshot!(p(r#"value NULL"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value NULL`.
         1:11 value NULL
-        "###);
-        insta::assert_snapshot!(p(r#"value NOT NULL"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value NOT NULL`.
+        ");
+        insta::assert_snapshot!(p(r#"value NOT NULL"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value NOT NULL`.
         1:15 value NOT NULL
-        "###);
-        insta::assert_snapshot!(p(r#"value EMPTY"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value EMPTY`.
+        ");
+        insta::assert_snapshot!(p(r#"value EMPTY"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value EMPTY`.
         1:12 value EMPTY
-        "###);
-        insta::assert_snapshot!(p(r#"value NOT EMPTY"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value NOT EMPTY`.
+        ");
+        insta::assert_snapshot!(p(r#"value NOT EMPTY"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value NOT EMPTY`.
         1:16 value NOT EMPTY
-        "###);
-        insta::assert_snapshot!(p(r#"value IS"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value IS`.
+        ");
+        insta::assert_snapshot!(p(r#"value IS"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value IS`.
         1:9 value IS
-        "###);
-        insta::assert_snapshot!(p(r#"value IS NOT"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value IS NOT`.
+        ");
+        insta::assert_snapshot!(p(r#"value IS NOT"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value IS NOT`.
         1:13 value IS NOT
-        "###);
-        insta::assert_snapshot!(p(r#"value IS EXISTS"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value IS EXISTS`.
+        ");
+        insta::assert_snapshot!(p(r#"value IS EXISTS"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value IS EXISTS`.
         1:16 value IS EXISTS
-        "###);
-        insta::assert_snapshot!(p(r#"value IS NOT EXISTS"#), @r###"
-        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `value IS NOT EXISTS`.
+        ");
+        insta::assert_snapshot!(p(r#"value IS NOT EXISTS"#), @r"
+        Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `value IS NOT EXISTS`.
         1:20 value IS NOT EXISTS
-        "###);
+        ");
     }
 
     #[test]

crates/index-scheduler/src/dump.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 use std::collections::HashMap;
 use std::io;
 
@@ -232,6 +234,9 @@ impl<'a> Dump<'a> {
                     }
                 }
                 KindDump::UpgradeDatabase { from } => KindWithContent::UpgradeDatabase { from },
+                KindDump::IndexCompaction { index_uid } => {
+                    KindWithContent::IndexCompaction { index_uid }
+                }
             },
         };
 

crates/index-scheduler/src/features.rs

@@ -25,6 +25,7 @@ pub(crate) struct FeatureData {
     persisted: Database<Str, SerdeJson<RuntimeTogglableFeatures>>,
     runtime: Arc<RwLock<RuntimeTogglableFeatures>>,
     network: Arc<RwLock<Network>>,
+    experimental_personalization_api_key: Option<String>,
 }
 
 #[derive(Debug, Clone, Copy)]
@@ -188,7 +189,12 @@ impl FeatureData {
 
         let persisted_features: RuntimeTogglableFeatures =
             runtime_features_db.get(wtxn, db_keys::EXPERIMENTAL_FEATURES)?.unwrap_or_default();
-        let InstanceTogglableFeatures { metrics, logs_route, contains_filter } = instance_features;
+        let InstanceTogglableFeatures {
+            metrics,
+            logs_route,
+            contains_filter,
+            experimental_personalization_api_key,
+        } = instance_features;
         let runtime = Arc::new(RwLock::new(RuntimeTogglableFeatures {
             metrics: metrics || persisted_features.metrics,
             logs_route: logs_route || persisted_features.logs_route,
@@ -204,6 +210,7 @@ impl FeatureData {
             persisted: runtime_features_db,
             runtime,
             network: Arc::new(RwLock::new(network)),
+            experimental_personalization_api_key,
         })
     }
 
@@ -234,6 +241,10 @@ impl FeatureData {
         RoFeatures::new(self)
     }
 
+    pub fn experimental_personalization_api_key(&self) -> Option<&String> {
+        self.experimental_personalization_api_key.as_ref()
+    }
+
     pub fn put_network(&self, mut wtxn: RwTxn, new_network: Network) -> Result<()> {
         self.persisted.remap_data_type::<SerdeJson<Network>>().put(
             &mut wtxn,

crates/index-scheduler/src/index_mapper/mod.rs

@@ -341,6 +341,26 @@ impl IndexMapper {
         Ok(())
     }
 
+    /// Closes the specified index.
+    ///
+    /// This operation involves closing the underlying environment and so can take a long time to complete.
+    ///
+    /// # Panics
+    ///
+    /// - If the Index corresponding to the passed name is concurrently being deleted/resized or cannot be found in the
+    ///   in memory hash map.
+    pub fn close_index(&self, rtxn: &RoTxn, name: &str) -> Result<()> {
+        let uuid = self
+            .index_mapping
+            .get(rtxn, name)?
+            .ok_or_else(|| Error::IndexNotFound(name.to_string()))?;
+
+        // We remove the index from the in-memory index map.
+        self.index_map.write().unwrap().close_for_resize(&uuid, self.enable_mdb_writemap, 0);
+
+        Ok(())
+    }
+
     /// Return an index, may open it if it wasn't already opened.
     pub fn index(&self, rtxn: &RoTxn, name: &str) -> Result<Index> {
         if let Some((current_name, current_index)) =

crates/index-scheduler/src/insta_snapshot.rs

@@ -317,6 +317,9 @@ fn snapshot_details(d: &Details) -> String {
         Details::UpgradeDatabase { from, to } => {
             format!("{{ from: {from:?}, to: {to:?} }}")
         }
+        Details::IndexCompaction { index_uid, pre_compaction_size, post_compaction_size } => {
+            format!("{{ index_uid: {index_uid:?}, pre_compaction_size: {pre_compaction_size:?}, post_compaction_size: {post_compaction_size:?} }}")
+        }
     }
 }
 

crates/index-scheduler/src/lib.rs

@@ -1,3 +1,6 @@
+// The main Error type is large and boxing the large variant make the pattern matching fails
+#![allow(clippy::result_large_err)]
+
 /*!
 This crate defines the index scheduler, which is responsible for:
 1. Keeping references to meilisearch's indexes and mapping them to their
@@ -300,7 +303,8 @@ impl IndexScheduler {
 
         let mut wtxn = env.write_txn()?;
 
-        let features = features::FeatureData::new(&env, &mut wtxn, options.instance_features)?;
+        let features =
+            features::FeatureData::new(&env, &mut wtxn, options.instance_features.clone())?;
         let queue = Queue::new(&env, &mut wtxn, &options)?;
         let index_mapper = IndexMapper::new(&env, &mut wtxn, &options, budget)?;
         let chat_settings = env.create_database(&mut wtxn, Some(db_name::CHAT_SETTINGS))?;
@@ -344,7 +348,7 @@ impl IndexScheduler {
         Ok(this)
     }
 
-    fn read_txn(&self) -> Result<RoTxn<WithoutTls>> {
+    fn read_txn(&self) -> Result<RoTxn<'_, WithoutTls>> {
         self.env.read_txn().map_err(|e| e.into())
     }
 
@@ -757,7 +761,7 @@ impl IndexScheduler {
 
     /// Register a new task coming from a dump in the scheduler.
     /// By taking a mutable ref we're pretty sure no one will ever import a dump while actix is running.
-    pub fn register_dumped_task(&mut self) -> Result<Dump> {
+    pub fn register_dumped_task(&mut self) -> Result<Dump<'_>> {
         Dump::new(self)
     }
 
@@ -806,10 +810,8 @@ impl IndexScheduler {
                                 .queue
                                 .tasks
                                 .get_task(self.rtxn, task_id)
-                                .map_err(|err| io::Error::new(io::ErrorKind::Other, err))?
-                                .ok_or_else(|| {
-                                    io::Error::new(io::ErrorKind::Other, Error::CorruptedTaskQueue)
-                                })?;
+                                .map_err(io::Error::other)?
+                                .ok_or_else(|| io::Error::other(Error::CorruptedTaskQueue))?;
 
                             serde_json::to_writer(&mut self.buffer, &TaskView::from_task(&task))?;
                             self.buffer.push(b'\n');
@@ -885,6 +887,10 @@ impl IndexScheduler {
         self.features.features()
     }
 
+    pub fn experimental_personalization_api_key(&self) -> Option<&String> {
+        self.features.experimental_personalization_api_key()
+    }
+
     pub fn put_runtime_features(&self, features: RuntimeTogglableFeatures) -> Result<()> {
         let wtxn = self.env.write_txn().map_err(Error::HeedTransaction)?;
         self.features.put_runtime_features(wtxn, features)?;

crates/index-scheduler/src/processing.rs

@@ -138,6 +138,17 @@ make_enum_progress! {
     }
 }
 
+make_enum_progress! {
+    pub enum IndexCompaction {
+        RetrieveTheIndex,
+        CreateTemporaryFile,
+        CopyAndCompactTheIndex,
+        PersistTheCompactedIndex,
+        CloseTheIndex,
+        ReopenTheIndex,
+    }
+}
+
 make_enum_progress! {
     pub enum InnerSwappingTwoIndexes {
         RetrieveTheTasks,

crates/index-scheduler/src/queue/mod.rs

@@ -310,7 +310,8 @@ impl Queue {
             | self.tasks.status.get(wtxn, &Status::Failed)?.unwrap_or_default()
             | self.tasks.status.get(wtxn, &Status::Canceled)?.unwrap_or_default();
 
-        let to_delete = RoaringBitmap::from_iter(finished.into_iter().rev().take(100_000));
+        let to_delete =
+            RoaringBitmap::from_sorted_iter(finished.into_iter().take(100_000)).unwrap();
 
         // /!\ the len must be at least 2 or else we might enter an infinite loop where we only delete
         //     the deletion tasks we enqueued ourselves.
@@ -326,7 +327,7 @@ impl Queue {
         );
 
         // it's safe to unwrap here because we checked the len above
-        let newest_task_id = to_delete.iter().last().unwrap();
+        let newest_task_id = to_delete.iter().next_back().unwrap();
         let last_task_to_delete =
             self.tasks.get_task(wtxn, newest_task_id)?.ok_or(Error::CorruptedTaskQueue)?;
 

crates/index-scheduler/src/scheduler/autobatcher.rs

@@ -25,6 +25,7 @@ enum AutobatchKind {
     IndexDeletion,
     IndexUpdate,
     IndexSwap,
+    IndexCompaction,
 }
 
 impl AutobatchKind {
@@ -68,6 +69,7 @@ impl From<KindWithContent> for AutobatchKind {
             KindWithContent::IndexCreation { .. } => AutobatchKind::IndexCreation,
             KindWithContent::IndexUpdate { .. } => AutobatchKind::IndexUpdate,
             KindWithContent::IndexSwap { .. } => AutobatchKind::IndexSwap,
+            KindWithContent::IndexCompaction { .. } => AutobatchKind::IndexCompaction,
             KindWithContent::TaskCancelation { .. }
             | KindWithContent::TaskDeletion { .. }
             | KindWithContent::DumpCreation { .. }
@@ -118,6 +120,9 @@ pub enum BatchKind {
     IndexSwap {
         id: TaskId,
     },
+    IndexCompaction {
+        id: TaskId,
+    },
 }
 
 impl BatchKind {
@@ -183,6 +188,13 @@ impl BatchKind {
                 )),
                 false,
             ),
+            K::IndexCompaction => (
+                Break((
+                    BatchKind::IndexCompaction { id: task_id },
+                    BatchStopReason::TaskCannotBeBatched { kind, id: task_id },
+                )),
+                false,
+            ),
             K::DocumentClear => (Continue(BatchKind::DocumentClear { ids: vec![task_id] }), false),
             K::DocumentImport { allow_index_creation, primary_key: pk }
                 if primary_key.is_none() || pk.is_none() || primary_key == pk.as_deref() =>
@@ -287,8 +299,10 @@ impl BatchKind {
         };
 
         match (self, autobatch_kind) {
-            // We don't batch any of these operations  
-            (this, K::IndexCreation | K::IndexUpdate | K::IndexSwap | K::DocumentEdition) => Break((this, BatchStopReason::TaskCannotBeBatched { kind, id })),
+            // We don't batch any of these operations
+            (this, K::IndexCreation | K::IndexUpdate | K::IndexSwap | K::DocumentEdition | K::IndexCompaction) => {
+                Break((this, BatchStopReason::TaskCannotBeBatched { kind, id }))
+            },
             // We must not batch tasks that don't have the same index creation rights if the index doesn't already exists.
             (this, kind) if !index_already_exists && this.allow_index_creation() == Some(false) && kind.allow_index_creation() == Some(true) => {
                 Break((this, BatchStopReason::IndexCreationMismatch { id }))
@@ -483,6 +497,7 @@ impl BatchKind {
                 | BatchKind::IndexDeletion { .. }
                 | BatchKind::IndexUpdate { .. }
                 | BatchKind::IndexSwap { .. }
+                | BatchKind::IndexCompaction { .. }
                 | BatchKind::DocumentEdition { .. },
                 _,
             ) => {

crates/index-scheduler/src/scheduler/create_batch.rs

@@ -55,6 +55,10 @@ pub(crate) enum Batch {
     UpgradeDatabase {
         tasks: Vec<Task>,
     },
+    IndexCompaction {
+        index_uid: String,
+        task: Task,
+    },
 }
 
 #[derive(Debug)]
@@ -66,6 +70,7 @@ pub(crate) enum DocumentOperation {
 
 /// A [batch](Batch) that combines multiple tasks operating on an index.
 #[derive(Debug)]
+#[allow(clippy::large_enum_variant)]
 pub(crate) enum IndexOperation {
     DocumentOperation {
         index_uid: String,
@@ -109,7 +114,8 @@ impl Batch {
             | Batch::Dump(task)
             | Batch::IndexCreation { task, .. }
             | Batch::Export { task }
-            | Batch::IndexUpdate { task, .. } => {
+            | Batch::IndexUpdate { task, .. }
+            | Batch::IndexCompaction { task, .. } => {
                 RoaringBitmap::from_sorted_iter(std::iter::once(task.uid)).unwrap()
             }
             Batch::SnapshotCreation(tasks)
@@ -154,7 +160,8 @@ impl Batch {
             IndexOperation { op, .. } => Some(op.index_uid()),
             IndexCreation { index_uid, .. }
             | IndexUpdate { index_uid, .. }
-            | IndexDeletion { index_uid, .. } => Some(index_uid),
+            | IndexDeletion { index_uid, .. }
+            | IndexCompaction { index_uid, .. } => Some(index_uid),
         }
     }
 }
@@ -174,6 +181,7 @@ impl fmt::Display for Batch {
             Batch::IndexUpdate { .. } => f.write_str("IndexUpdate")?,
             Batch::IndexDeletion { .. } => f.write_str("IndexDeletion")?,
             Batch::IndexSwap { .. } => f.write_str("IndexSwap")?,
+            Batch::IndexCompaction { .. } => f.write_str("IndexCompaction")?,
             Batch::Export { .. } => f.write_str("Export")?,
             Batch::UpgradeDatabase { .. } => f.write_str("UpgradeDatabase")?,
         };
@@ -429,6 +437,12 @@ impl IndexScheduler {
                 current_batch.processing(Some(&mut task));
                 Ok(Some(Batch::IndexSwap { task }))
             }
+            BatchKind::IndexCompaction { id } => {
+                let mut task =
+                    self.queue.tasks.get_task(rtxn, id)?.ok_or(Error::CorruptedTaskQueue)?;
+                current_batch.processing(Some(&mut task));
+                Ok(Some(Batch::IndexCompaction { index_uid, task }))
+            }
         }
     }
 

crates/index-scheduler/src/scheduler/process_batch.rs

@@ -1,22 +1,26 @@
 use std::collections::{BTreeSet, HashMap, HashSet};
+use std::io::{Seek, SeekFrom};
 use std::panic::{catch_unwind, AssertUnwindSafe};
 use std::sync::atomic::Ordering;
 
+use byte_unit::Byte;
 use meilisearch_types::batches::{BatchEnqueuedAt, BatchId};
 use meilisearch_types::heed::{RoTxn, RwTxn};
+use meilisearch_types::milli::heed::CompactionOption;
 use meilisearch_types::milli::progress::{Progress, VariableNameStep};
 use meilisearch_types::milli::{self, ChannelCongestion};
 use meilisearch_types::tasks::{Details, IndexSwap, Kind, KindWithContent, Status, Task};
 use meilisearch_types::versioning::{VERSION_MAJOR, VERSION_MINOR, VERSION_PATCH};
 use milli::update::Settings as MilliSettings;
 use roaring::RoaringBitmap;
+use tempfile::PersistError;
 use time::OffsetDateTime;
 
 use super::create_batch::Batch;
 use crate::processing::{
     AtomicBatchStep, AtomicTaskStep, CreateIndexProgress, DeleteIndexProgress, FinalizingIndexStep,
-    InnerSwappingTwoIndexes, SwappingTheIndexes, TaskCancelationProgress, TaskDeletionProgress,
-    UpdateIndexProgress,
+    IndexCompaction, InnerSwappingTwoIndexes, SwappingTheIndexes, TaskCancelationProgress,
+    TaskDeletionProgress, UpdateIndexProgress,
 };
 use crate::utils::{
     self, remove_n_tasks_datetime_earlier_than, remove_task_datetime, swap_index_uid_in_task,
@@ -418,6 +422,47 @@ impl IndexScheduler {
                 task.status = Status::Succeeded;
                 Ok((vec![task], ProcessBatchInfo::default()))
             }
+            Batch::IndexCompaction { index_uid: _, mut task } => {
+                let KindWithContent::IndexCompaction { index_uid } = &task.kind else {
+                    unreachable!()
+                };
+
+                let rtxn = self.env.read_txn()?;
+                let ret = catch_unwind(AssertUnwindSafe(|| {
+                    self.apply_compaction(&rtxn, &progress, index_uid)
+                }));
+
+                let (pre_size, post_size) = match ret {
+                    Ok(Ok(stats)) => stats,
+                    Ok(Err(Error::AbortedTask)) => return Err(Error::AbortedTask),
+                    Ok(Err(e)) => return Err(e),
+                    Err(e) => {
+                        let msg = match e.downcast_ref::<&'static str>() {
+                            Some(s) => *s,
+                            None => match e.downcast_ref::<String>() {
+                                Some(s) => &s[..],
+                                None => "Box<dyn Any>",
+                            },
+                        };
+                        return Err(Error::Export(Box::new(Error::ProcessBatchPanicked(
+                            msg.to_string(),
+                        ))));
+                    }
+                };
+
+                task.status = Status::Succeeded;
+                if let Some(Details::IndexCompaction {
+                    index_uid: _,
+                    pre_compaction_size,
+                    post_compaction_size,
+                }) = task.details.as_mut()
+                {
+                    *pre_compaction_size = Some(Byte::from_u64(pre_size));
+                    *post_compaction_size = Some(Byte::from_u64(post_size));
+                }
+
+                Ok((vec![task], ProcessBatchInfo::default()))
+            }
             Batch::Export { mut task } => {
                 let KindWithContent::Export { url, api_key, payload_size, indexes } = &task.kind
                 else {
@@ -493,6 +538,91 @@ impl IndexScheduler {
         }
     }
 
+    fn apply_compaction(
+        &self,
+        rtxn: &RoTxn,
+        progress: &Progress,
+        index_uid: &str,
+    ) -> Result<(u64, u64)> {
+        // 1. Verify that the index exists
+        if !self.index_mapper.index_exists(rtxn, index_uid)? {
+            return Err(Error::IndexNotFound(index_uid.to_owned()));
+        }
+
+        // 2. We retrieve the index and create a temporary file in the index directory
+        progress.update_progress(IndexCompaction::RetrieveTheIndex);
+        let index = self.index_mapper.index(rtxn, index_uid)?;
+
+        // the index operation can take a long time, so save this handle to make it available to the search for the duration of the tick
+        self.index_mapper
+            .set_currently_updating_index(Some((index_uid.to_string(), index.clone())));
+
+        progress.update_progress(IndexCompaction::CreateTemporaryFile);
+        let pre_size = std::fs::metadata(index.path().join("data.mdb"))?.len();
+        let mut file = tempfile::Builder::new()
+            .suffix("data.")
+            .prefix(".mdb.cpy")
+            .tempfile_in(index.path())?;
+
+        // 3. We copy the index data to the temporary file
+        progress.update_progress(IndexCompaction::CopyAndCompactTheIndex);
+        index
+            .copy_to_file(file.as_file_mut(), CompactionOption::Enabled)
+            .map_err(|error| Error::Milli { error, index_uid: Some(index_uid.to_string()) })?;
+        // ...and reset the file position as specified in the documentation
+        file.seek(SeekFrom::Start(0))?;
+
+        // 4. We replace the index data file with the temporary file
+        progress.update_progress(IndexCompaction::PersistTheCompactedIndex);
+        match file.persist(index.path().join("data.mdb")) {
+            Ok(file) => file.sync_all()?,
+            // TODO see if we have a _resource busy_ error and probably handle this by:
+            //      1. closing the index, 2. replacing and 3. reopening it
+            Err(PersistError { error, file: _ }) => return Err(Error::IoError(error)),
+        };
+
+        // 5. Prepare to close the index
+        progress.update_progress(IndexCompaction::CloseTheIndex);
+
+        // unmark that the index is the processing one so we don't keep a handle to it, preventing its closing
+        self.index_mapper.set_currently_updating_index(None);
+
+        self.index_mapper.close_index(rtxn, index_uid)?;
+        drop(index);
+
+        progress.update_progress(IndexCompaction::ReopenTheIndex);
+        // 6. Reopen the index
+        // The index will use the compacted data file when being reopened
+        let index = self.index_mapper.index(rtxn, index_uid)?;
+
+        // if the update processed successfully, we're going to store the new
+        // stats of the index. Since the tasks have already been processed and
+        // this is a non-critical operation. If it fails, we should not fail
+        // the entire batch.
+        let res = || -> Result<_> {
+            let mut wtxn = self.env.write_txn()?;
+            let index_rtxn = index.read_txn()?;
+            let stats = crate::index_mapper::IndexStats::new(&index, &index_rtxn)
+                .map_err(|e| Error::from_milli(e, Some(index_uid.to_string())))?;
+            self.index_mapper.store_stats_of(&mut wtxn, index_uid, &stats)?;
+            wtxn.commit()?;
+            Ok(stats.database_size)
+        }();
+
+        let post_size = match res {
+            Ok(post_size) => post_size,
+            Err(e) => {
+                tracing::error!(
+                    error = &e as &dyn std::error::Error,
+                    "Could not write the stats of the index"
+                );
+                0
+            }
+        };
+
+        Ok((pre_size, post_size))
+    }
+
     /// Swap the index `lhs` with the index `rhs`.
     fn apply_index_swap(
         &self,

crates/index-scheduler/src/scheduler/process_export.rs

@@ -370,7 +370,7 @@ fn ureq_error_into_error(error: ureq::Error) -> Error {
             }
             Err(e) => e.into(),
         },
-        ureq::Error::Transport(transport) => io::Error::new(io::ErrorKind::Other, transport).into(),
+        ureq::Error::Transport(transport) => io::Error::other(transport).into(),
     }
 }
 

crates/index-scheduler/src/scheduler/snapshots/test_failure.rs/upgrade_failure/after_processing_everything.snap

@@ -6,7 +6,7 @@ source: crates/index-scheduler/src/scheduler/test_failure.rs
 []
 ----------------------------------------------------------------------
 ### All Tasks:
-0 {uid: 0, batch_uid: 0, status: succeeded, details: { from: (1, 12, 0), to: (1, 21, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
+0 {uid: 0, batch_uid: 0, status: succeeded, details: { from: (1, 12, 0), to: (1, 23, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
 1 {uid: 1, batch_uid: 1, status: succeeded, details: { primary_key: Some("mouse"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "catto", primary_key: Some("mouse") }}
 2 {uid: 2, batch_uid: 2, status: succeeded, details: { primary_key: Some("bone"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "doggo", primary_key: Some("bone") }}
 3 {uid: 3, batch_uid: 3, status: failed, error: ResponseError { code: 200, message: "Index `doggo` already exists.", error_code: "index_already_exists", error_type: "invalid_request", error_link: "https://docs.meilisearch.com/errors#index_already_exists" }, details: { primary_key: Some("bone"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "doggo", primary_key: Some("bone") }}
@@ -57,7 +57,7 @@ girafo: { number_of_documents: 0, field_distribution: {} }
 [timestamp] [4,]
 ----------------------------------------------------------------------
 ### All Batches:
-0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.21.0"}, stats: {"totalNbTasks":1,"status":{"succeeded":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
+0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.23.0"}, stats: {"totalNbTasks":1,"status":{"succeeded":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
 1 {uid: 1, details: {"primaryKey":"mouse"}, stats: {"totalNbTasks":1,"status":{"succeeded":1},"types":{"indexCreation":1},"indexUids":{"catto":1}}, stop reason: "created batch containing only task with id 1 of type `indexCreation` that cannot be batched with any other task.", }
 2 {uid: 2, details: {"primaryKey":"bone"}, stats: {"totalNbTasks":1,"status":{"succeeded":1},"types":{"indexCreation":1},"indexUids":{"doggo":1}}, stop reason: "created batch containing only task with id 2 of type `indexCreation` that cannot be batched with any other task.", }
 3 {uid: 3, details: {"primaryKey":"bone"}, stats: {"totalNbTasks":1,"status":{"failed":1},"types":{"indexCreation":1},"indexUids":{"doggo":1}}, stop reason: "created batch containing only task with id 3 of type `indexCreation` that cannot be batched with any other task.", }

crates/index-scheduler/src/scheduler/snapshots/test_failure.rs/upgrade_failure/register_automatic_upgrade_task.snap

@@ -6,7 +6,7 @@ source: crates/index-scheduler/src/scheduler/test_failure.rs
 []
 ----------------------------------------------------------------------
 ### All Tasks:
-0 {uid: 0, status: enqueued, details: { from: (1, 12, 0), to: (1, 21, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
+0 {uid: 0, status: enqueued, details: { from: (1, 12, 0), to: (1, 23, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
 ----------------------------------------------------------------------
 ### Status:
 enqueued [0,]

crates/index-scheduler/src/scheduler/snapshots/test_failure.rs/upgrade_failure/registered_a_task_while_the_upgrade_task_is_enqueued.snap

@@ -6,7 +6,7 @@ source: crates/index-scheduler/src/scheduler/test_failure.rs
 []
 ----------------------------------------------------------------------
 ### All Tasks:
-0 {uid: 0, status: enqueued, details: { from: (1, 12, 0), to: (1, 21, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
+0 {uid: 0, status: enqueued, details: { from: (1, 12, 0), to: (1, 23, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
 1 {uid: 1, status: enqueued, details: { primary_key: Some("mouse"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "catto", primary_key: Some("mouse") }}
 ----------------------------------------------------------------------
 ### Status:

crates/index-scheduler/src/scheduler/snapshots/test_failure.rs/upgrade_failure/upgrade_task_failed.snap

@@ -6,7 +6,7 @@ source: crates/index-scheduler/src/scheduler/test_failure.rs
 []
 ----------------------------------------------------------------------
 ### All Tasks:
-0 {uid: 0, batch_uid: 0, status: failed, error: ResponseError { code: 200, message: "Planned failure for tests.", error_code: "internal", error_type: "internal", error_link: "https://docs.meilisearch.com/errors#internal" }, details: { from: (1, 12, 0), to: (1, 21, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
+0 {uid: 0, batch_uid: 0, status: failed, error: ResponseError { code: 200, message: "Planned failure for tests.", error_code: "internal", error_type: "internal", error_link: "https://docs.meilisearch.com/errors#internal" }, details: { from: (1, 12, 0), to: (1, 23, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
 1 {uid: 1, status: enqueued, details: { primary_key: Some("mouse"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "catto", primary_key: Some("mouse") }}
 ----------------------------------------------------------------------
 ### Status:
@@ -37,7 +37,7 @@ catto [1,]
 [timestamp] [0,]
 ----------------------------------------------------------------------
 ### All Batches:
-0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.21.0"}, stats: {"totalNbTasks":1,"status":{"failed":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
+0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.23.0"}, stats: {"totalNbTasks":1,"status":{"failed":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
 ----------------------------------------------------------------------
 ### Batch to tasks mapping:
 0 [0,]

crates/index-scheduler/src/scheduler/snapshots/test_failure.rs/upgrade_failure/upgrade_task_failed_again.snap

@@ -6,7 +6,7 @@ source: crates/index-scheduler/src/scheduler/test_failure.rs
 []
 ----------------------------------------------------------------------
 ### All Tasks:
-0 {uid: 0, batch_uid: 0, status: failed, error: ResponseError { code: 200, message: "Planned failure for tests.", error_code: "internal", error_type: "internal", error_link: "https://docs.meilisearch.com/errors#internal" }, details: { from: (1, 12, 0), to: (1, 21, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
+0 {uid: 0, batch_uid: 0, status: failed, error: ResponseError { code: 200, message: "Planned failure for tests.", error_code: "internal", error_type: "internal", error_link: "https://docs.meilisearch.com/errors#internal" }, details: { from: (1, 12, 0), to: (1, 23, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
 1 {uid: 1, status: enqueued, details: { primary_key: Some("mouse"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "catto", primary_key: Some("mouse") }}
 2 {uid: 2, status: enqueued, details: { primary_key: Some("bone"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "doggo", primary_key: Some("bone") }}
 ----------------------------------------------------------------------
@@ -40,7 +40,7 @@ doggo [2,]
 [timestamp] [0,]
 ----------------------------------------------------------------------
 ### All Batches:
-0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.21.0"}, stats: {"totalNbTasks":1,"status":{"failed":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
+0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.23.0"}, stats: {"totalNbTasks":1,"status":{"failed":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
 ----------------------------------------------------------------------
 ### Batch to tasks mapping:
 0 [0,]

crates/index-scheduler/src/scheduler/snapshots/test_failure.rs/upgrade_failure/upgrade_task_succeeded.snap

@@ -6,7 +6,7 @@ source: crates/index-scheduler/src/scheduler/test_failure.rs
 []
 ----------------------------------------------------------------------
 ### All Tasks:
-0 {uid: 0, batch_uid: 0, status: succeeded, details: { from: (1, 12, 0), to: (1, 21, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
+0 {uid: 0, batch_uid: 0, status: succeeded, details: { from: (1, 12, 0), to: (1, 23, 0) }, kind: UpgradeDatabase { from: (1, 12, 0) }}
 1 {uid: 1, status: enqueued, details: { primary_key: Some("mouse"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "catto", primary_key: Some("mouse") }}
 2 {uid: 2, status: enqueued, details: { primary_key: Some("bone"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "doggo", primary_key: Some("bone") }}
 3 {uid: 3, status: enqueued, details: { primary_key: Some("bone"), old_new_uid: None, new_index_uid: None }, kind: IndexCreation { index_uid: "doggo", primary_key: Some("bone") }}
@@ -43,7 +43,7 @@ doggo [2,3,]
 [timestamp] [0,]
 ----------------------------------------------------------------------
 ### All Batches:
-0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.21.0"}, stats: {"totalNbTasks":1,"status":{"succeeded":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
+0 {uid: 0, details: {"upgradeFrom":"v1.12.0","upgradeTo":"v1.23.0"}, stats: {"totalNbTasks":1,"status":{"succeeded":1},"types":{"upgradeDatabase":1},"indexUids":{}}, stop reason: "stopped after the last task of type `upgradeDatabase` because they cannot be batched with tasks of any other type.", }
 ----------------------------------------------------------------------
 ### Batch to tasks mapping:
 0 [0,]

crates/index-scheduler/src/scheduler/test.rs

@@ -722,7 +722,7 @@ fn basic_get_stats() {
     let kind = index_creation_task("whalo", "fish");
     let _task = index_scheduler.register(kind, None, false).unwrap();
 
-    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r#"
+    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r###"
     {
       "indexes": {
         "catto": 1,
@@ -742,6 +742,7 @@ fn basic_get_stats() {
         "documentEdition": 0,
         "dumpCreation": 0,
         "export": 0,
+        "indexCompaction": 0,
         "indexCreation": 3,
         "indexDeletion": 0,
         "indexSwap": 0,
@@ -753,10 +754,10 @@ fn basic_get_stats() {
         "upgradeDatabase": 0
       }
     }
-    "#);
+    "###);
 
     handle.advance_till([Start, BatchCreated]);
-    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r#"
+    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r###"
     {
       "indexes": {
         "catto": 1,
@@ -776,6 +777,7 @@ fn basic_get_stats() {
         "documentEdition": 0,
         "dumpCreation": 0,
         "export": 0,
+        "indexCompaction": 0,
         "indexCreation": 3,
         "indexDeletion": 0,
         "indexSwap": 0,
@@ -787,7 +789,7 @@ fn basic_get_stats() {
         "upgradeDatabase": 0
       }
     }
-    "#);
+    "###);
 
     handle.advance_till([
         InsideProcessBatch,
@@ -797,7 +799,7 @@ fn basic_get_stats() {
         Start,
         BatchCreated,
     ]);
-    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r#"
+    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r###"
     {
       "indexes": {
         "catto": 1,
@@ -817,6 +819,7 @@ fn basic_get_stats() {
         "documentEdition": 0,
         "dumpCreation": 0,
         "export": 0,
+        "indexCompaction": 0,
         "indexCreation": 3,
         "indexDeletion": 0,
         "indexSwap": 0,
@@ -828,7 +831,7 @@ fn basic_get_stats() {
         "upgradeDatabase": 0
       }
     }
-    "#);
+    "###);
 
     // now we make one more batch, the started_at field of the new tasks will be past `second_start_time`
     handle.advance_till([
@@ -839,7 +842,7 @@ fn basic_get_stats() {
         Start,
         BatchCreated,
     ]);
-    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r#"
+    snapshot!(json_string!(index_scheduler.get_stats().unwrap()), @r###"
     {
       "indexes": {
         "catto": 1,
@@ -859,6 +862,7 @@ fn basic_get_stats() {
         "documentEdition": 0,
         "dumpCreation": 0,
         "export": 0,
+        "indexCompaction": 0,
         "indexCreation": 3,
         "indexDeletion": 0,
         "indexSwap": 0,
@@ -870,7 +874,7 @@ fn basic_get_stats() {
         "upgradeDatabase": 0
       }
     }
-    "#);
+    "###);
 }
 
 #[test]

crates/index-scheduler/src/upgrade/mod.rs

@@ -45,6 +45,8 @@ pub fn upgrade_index_scheduler(
         (1, 19, _) => 0,
         (1, 20, _) => 0,
         (1, 21, _) => 0,
+        (1, 22, _) => 0,
+        (1, 23, _) => 0,
         (major, minor, patch) => {
             if major > current_major
                 || (major == current_major && minor > current_minor)

crates/index-scheduler/src/utils.rs

@@ -256,14 +256,15 @@ pub fn swap_index_uid_in_task(task: &mut Task, swap: (&str, &str)) {
     use KindWithContent as K;
     let mut index_uids = vec![];
     match &mut task.kind {
-        K::DocumentAdditionOrUpdate { index_uid, .. } => index_uids.push(index_uid),
-        K::DocumentEdition { index_uid, .. } => index_uids.push(index_uid),
-        K::DocumentDeletion { index_uid, .. } => index_uids.push(index_uid),
-        K::DocumentDeletionByFilter { index_uid, .. } => index_uids.push(index_uid),
-        K::DocumentClear { index_uid } => index_uids.push(index_uid),
-        K::SettingsUpdate { index_uid, .. } => index_uids.push(index_uid),
-        K::IndexDeletion { index_uid } => index_uids.push(index_uid),
-        K::IndexCreation { index_uid, .. } => index_uids.push(index_uid),
+        K::DocumentAdditionOrUpdate { index_uid, .. }
+        | K::DocumentEdition { index_uid, .. }
+        | K::DocumentDeletion { index_uid, .. }
+        | K::DocumentDeletionByFilter { index_uid, .. }
+        | K::DocumentClear { index_uid }
+        | K::SettingsUpdate { index_uid, .. }
+        | K::IndexDeletion { index_uid }
+        | K::IndexCreation { index_uid, .. }
+        | K::IndexCompaction { index_uid, .. } => index_uids.push(index_uid),
         K::IndexUpdate { index_uid, new_index_uid, .. } => {
             index_uids.push(index_uid);
             if let Some(new_uid) = new_index_uid {
@@ -618,6 +619,13 @@ impl crate::IndexScheduler {
                     Details::UpgradeDatabase { from: _, to: _ } => {
                         assert_eq!(kind.as_kind(), Kind::UpgradeDatabase);
                     }
+                    Details::IndexCompaction {
+                        index_uid: _,
+                        pre_compaction_size: _,
+                        post_compaction_size: _,
+                    } => {
+                        assert_eq!(kind.as_kind(), Kind::IndexCompaction);
+                    }
                 }
             }
 

crates/index-scheduler/src/uuid_codec.rs

@@ -17,7 +17,7 @@ impl<'a> BytesDecode<'a> for UuidCodec {
 impl BytesEncode<'_> for UuidCodec {
     type EItem = Uuid;
 
-    fn bytes_encode(item: &Self::EItem) -> Result<Cow<[u8]>, BoxedError> {
+    fn bytes_encode(item: &Self::EItem) -> Result<Cow<'_, [u8]>, BoxedError> {
         Ok(Cow::Borrowed(item.as_bytes()))
     }
 }

crates/meili-snap/src/lib.rs

@@ -271,9 +271,10 @@ macro_rules! json_string {
 
 #[cfg(test)]
 mod tests {
+    use uuid::Uuid;
+
     use crate as meili_snap;
     use crate::UUID_IN_MESSAGE_RE;
-    use uuid::Uuid;
 
     #[test]
     fn snap() {

crates/meilisearch-auth/src/store.rs

@@ -109,6 +109,7 @@ impl HeedAuthStore {
                             Action::IndexesGet,
                             Action::IndexesUpdate,
                             Action::IndexesSwap,
+                            Action::IndexesCompact,
                         ]
                         .iter(),
                     );
@@ -315,7 +316,9 @@ impl<'a> heed::BytesDecode<'a> for KeyIdActionCodec {
 impl<'a> heed::BytesEncode<'a> for KeyIdActionCodec {
     type EItem = (&'a KeyId, &'a Action, Option<&'a [u8]>);
 
-    fn bytes_encode((key_id, action, index): &Self::EItem) -> StdResult<Cow<[u8]>, BoxedError> {
+    fn bytes_encode(
+        (key_id, action, index): &'_ Self::EItem,
+    ) -> StdResult<Cow<'_, [u8]>, BoxedError> {
         let mut bytes = Vec::new();
 
         bytes.extend_from_slice(key_id.as_bytes());

crates/meilisearch-types/src/error.rs

@@ -5,6 +5,7 @@ use actix_web::{self as aweb, HttpResponseBuilder};
 use aweb::http::header;
 use aweb::rt::task::JoinError;
 use convert_case::Casing;
+use milli::cellulite;
 use milli::heed::{Error as HeedError, MdbError};
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
@@ -239,6 +240,7 @@ InconsistentDocumentChangeHeaders              , InvalidRequest       , BAD_REQU
 InvalidDocumentFilter                          , InvalidRequest       , BAD_REQUEST ;
 InvalidDocumentSort                            , InvalidRequest       , BAD_REQUEST ;
 InvalidDocumentGeoField                        , InvalidRequest       , BAD_REQUEST ;
+InvalidDocumentGeojsonField                    , InvalidRequest       , BAD_REQUEST ;
 InvalidHeaderValue                             , InvalidRequest       , BAD_REQUEST ;
 InvalidVectorDimensions                        , InvalidRequest       , BAD_REQUEST ;
 InvalidVectorsType                             , InvalidRequest       , BAD_REQUEST ;
@@ -313,6 +315,8 @@ InvalidSearchShowRankingScoreDetails           , InvalidRequest       , BAD_REQU
 InvalidSimilarShowRankingScoreDetails          , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchSort                              , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchDistinct                          , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchPersonalize                        , InvalidRequest       , BAD_REQUEST ;
+InvalidSearchPersonalizeUserContext             , InvalidRequest       , BAD_REQUEST ;
 InvalidSearchMediaAndVector                    , InvalidRequest       , BAD_REQUEST ;
 InvalidSettingsDisplayedAttributes             , InvalidRequest       , BAD_REQUEST ;
 InvalidSettingsDistinctAttribute               , InvalidRequest       , BAD_REQUEST ;
@@ -501,7 +505,9 @@ impl ErrorCode for milli::Error {
                         Code::InvalidFacetSearchFacetName
                     }
                     UserError::CriterionError(_) => Code::InvalidSettingsRankingRules,
-                    UserError::InvalidGeoField { .. } => Code::InvalidDocumentGeoField,
+                    UserError::InvalidGeoField { .. } | UserError::GeoJsonError(_) => {
+                        Code::InvalidDocumentGeoField
+                    }
                     UserError::InvalidVectorDimensions { .. }
                     | UserError::InvalidIndexingVectorDimensions { .. } => {
                         Code::InvalidVectorDimensions
@@ -525,6 +531,17 @@ impl ErrorCode for milli::Error {
                     | UserError::DocumentEditionCompilationError(_) => {
                         Code::EditDocumentsByFunctionError
                     }
+                    UserError::CelluliteError(err) => match err {
+                        cellulite::Error::BuildCanceled
+                        | cellulite::Error::VersionMismatchOnBuild(_)
+                        | cellulite::Error::DatabaseDoesntExists
+                        | cellulite::Error::Heed(_)
+                        | cellulite::Error::InvalidGeometry(_)
+                        | cellulite::Error::InternalDocIdMissing(_, _)
+                        | cellulite::Error::CannotConvertLineToCell(_, _, _) => Code::Internal,
+                        cellulite::Error::InvalidGeoJson(_) => Code::InvalidDocumentGeojsonField,
+                    },
+                    UserError::MalformedGeojson(_) => Code::InvalidDocumentGeojsonField,
                 }
             }
         }
@@ -664,6 +681,18 @@ impl fmt::Display for deserr_codes::InvalidNetworkSearchApiKey {
     }
 }
 
+impl fmt::Display for deserr_codes::InvalidSearchPersonalize {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "the value of `personalize` is invalid, expected a JSON object with optional `userContext` string.")
+    }
+}
+
+impl fmt::Display for deserr_codes::InvalidSearchPersonalizeUserContext {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "the value of `userContext` is invalid, expected a string.")
+    }
+}
+
 #[macro_export]
 macro_rules! internal_error {
     ($target:ty : $($other:path), *) => {

crates/meilisearch-types/src/features.rs

@@ -24,11 +24,12 @@ pub struct RuntimeTogglableFeatures {
     pub vector_store_setting: bool,
 }
 
-#[derive(Default, Debug, Clone, Copy)]
+#[derive(Default, Debug, Clone)]
 pub struct InstanceTogglableFeatures {
     pub metrics: bool,
     pub logs_route: bool,
     pub contains_filter: bool,
+    pub experimental_personalization_api_key: Option<String>,
 }
 
 #[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, Default)]

crates/meilisearch-types/src/keys.rs

@@ -380,6 +380,9 @@ pub enum Action {
     #[serde(rename = "webhooks.*")]
     #[deserr(rename = "webhooks.*")]
     WebhooksAll,
+    #[serde(rename = "indexes.compact")]
+    #[deserr(rename = "indexes.compact")]
+    IndexesCompact,
 }
 
 impl Action {
@@ -398,6 +401,7 @@ impl Action {
             INDEXES_UPDATE => Some(Self::IndexesUpdate),
             INDEXES_DELETE => Some(Self::IndexesDelete),
             INDEXES_SWAP => Some(Self::IndexesSwap),
+            INDEXES_COMPACT => Some(Self::IndexesCompact),
             TASKS_ALL => Some(Self::TasksAll),
             TASKS_CANCEL => Some(Self::TasksCancel),
             TASKS_DELETE => Some(Self::TasksDelete),
@@ -462,6 +466,7 @@ impl Action {
             IndexesUpdate => false,
             IndexesDelete => false,
             IndexesSwap => false,
+            IndexesCompact => false,
             TasksCancel => false,
             TasksDelete => false,
             TasksGet => true,
@@ -513,6 +518,7 @@ pub mod actions {
     pub const INDEXES_UPDATE: u8 = IndexesUpdate.repr();
     pub const INDEXES_DELETE: u8 = IndexesDelete.repr();
     pub const INDEXES_SWAP: u8 = IndexesSwap.repr();
+    pub const INDEXES_COMPACT: u8 = IndexesCompact.repr();
     pub const TASKS_ALL: u8 = TasksAll.repr();
     pub const TASKS_CANCEL: u8 = TasksCancel.repr();
     pub const TASKS_DELETE: u8 = TasksDelete.repr();
@@ -614,6 +620,7 @@ pub(crate) mod test {
         assert!(WebhooksDelete.repr() == 47 && WEBHOOKS_DELETE == 47);
         assert!(WebhooksCreate.repr() == 48 && WEBHOOKS_CREATE == 48);
         assert!(WebhooksAll.repr() == 49 && WEBHOOKS_ALL == 49);
+        assert!(IndexesCompact.repr() == 50 && INDEXES_COMPACT == 50);
     }
 
     #[test]

crates/meilisearch-types/src/lib.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::result_large_err)]
+
 pub mod batch_view;
 pub mod batches;
 pub mod compression;

crates/meilisearch-types/src/task_view.rs

@@ -142,6 +142,11 @@ pub struct DetailsView {
     pub old_index_uid: Option<String>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub new_index_uid: Option<String>,
+    // index compaction
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub pre_compaction_size: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub post_compaction_size: Option<String>,
 }
 
 impl DetailsView {
@@ -314,6 +319,24 @@ impl DetailsView {
                 // We should never be able to batch multiple renames at the same time.
                 (Some(left), Some(_right)) => Some(left),
             },
+            pre_compaction_size: match (
+                self.pre_compaction_size.clone(),
+                other.pre_compaction_size.clone(),
+            ) {
+                (None, None) => None,
+                (None, Some(size)) | (Some(size), None) => Some(size),
+                // We should never be able to batch multiple compactions at the same time.
+                (Some(left), Some(_right)) => Some(left),
+            },
+            post_compaction_size: match (
+                self.post_compaction_size.clone(),
+                other.post_compaction_size.clone(),
+            ) {
+                (None, None) => None,
+                (None, Some(size)) | (Some(size), None) => Some(size),
+                // We should never be able to batch multiple compactions at the same time.
+                (Some(left), Some(_right)) => Some(left),
+            },
         }
     }
 }
@@ -415,6 +438,15 @@ impl From<Details> for DetailsView {
                 upgrade_to: Some(format!("v{}.{}.{}", to.0, to.1, to.2)),
                 ..Default::default()
             },
+            Details::IndexCompaction { pre_compaction_size, post_compaction_size, .. } => {
+                DetailsView {
+                    pre_compaction_size: pre_compaction_size
+                        .map(|size| size.get_appropriate_unit(UnitType::Both).to_string()),
+                    post_compaction_size: post_compaction_size
+                        .map(|size| size.get_appropriate_unit(UnitType::Both).to_string()),
+                    ..Default::default()
+                }
+            }
         }
     }
 }

crates/meilisearch-types/src/tasks.rs

@@ -67,7 +67,8 @@ impl Task {
             | SettingsUpdate { index_uid, .. }
             | IndexCreation { index_uid, .. }
             | IndexUpdate { index_uid, .. }
-            | IndexDeletion { index_uid } => Some(index_uid),
+            | IndexDeletion { index_uid }
+            | IndexCompaction { index_uid } => Some(index_uid),
         }
     }
 
@@ -94,7 +95,8 @@ impl Task {
             | KindWithContent::DumpCreation { .. }
             | KindWithContent::SnapshotCreation
             | KindWithContent::Export { .. }
-            | KindWithContent::UpgradeDatabase { .. } => None,
+            | KindWithContent::UpgradeDatabase { .. }
+            | KindWithContent::IndexCompaction { .. } => None,
         }
     }
 }
@@ -170,6 +172,9 @@ pub enum KindWithContent {
     UpgradeDatabase {
         from: (u32, u32, u32),
     },
+    IndexCompaction {
+        index_uid: String,
+    },
 }
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize, ToSchema)]
@@ -206,6 +211,7 @@ impl KindWithContent {
             KindWithContent::SnapshotCreation => Kind::SnapshotCreation,
             KindWithContent::Export { .. } => Kind::Export,
             KindWithContent::UpgradeDatabase { .. } => Kind::UpgradeDatabase,
+            KindWithContent::IndexCompaction { .. } => Kind::IndexCompaction,
         }
     }
 
@@ -226,7 +232,8 @@ impl KindWithContent {
             | DocumentClear { index_uid }
             | SettingsUpdate { index_uid, .. }
             | IndexCreation { index_uid, .. }
-            | IndexDeletion { index_uid } => vec![index_uid],
+            | IndexDeletion { index_uid }
+            | IndexCompaction { index_uid } => vec![index_uid],
             IndexUpdate { index_uid, new_index_uid, .. } => {
                 let mut indexes = vec![index_uid.as_str()];
                 if let Some(new_uid) = new_index_uid {
@@ -325,6 +332,11 @@ impl KindWithContent {
                     versioning::VERSION_PATCH,
                 ),
             }),
+            KindWithContent::IndexCompaction { index_uid } => Some(Details::IndexCompaction {
+                index_uid: index_uid.clone(),
+                pre_compaction_size: None,
+                post_compaction_size: None,
+            }),
         }
     }
 
@@ -407,6 +419,11 @@ impl KindWithContent {
                     versioning::VERSION_PATCH,
                 ),
             }),
+            KindWithContent::IndexCompaction { index_uid } => Some(Details::IndexCompaction {
+                index_uid: index_uid.clone(),
+                pre_compaction_size: None,
+                post_compaction_size: None,
+            }),
         }
     }
 }
@@ -469,6 +486,11 @@ impl From<&KindWithContent> for Option<Details> {
                     versioning::VERSION_PATCH,
                 ),
             }),
+            KindWithContent::IndexCompaction { index_uid } => Some(Details::IndexCompaction {
+                index_uid: index_uid.clone(),
+                pre_compaction_size: None,
+                post_compaction_size: None,
+            }),
         }
     }
 }
@@ -579,6 +601,7 @@ pub enum Kind {
     SnapshotCreation,
     Export,
     UpgradeDatabase,
+    IndexCompaction,
 }
 
 impl Kind {
@@ -590,7 +613,8 @@ impl Kind {
             | Kind::SettingsUpdate
             | Kind::IndexCreation
             | Kind::IndexDeletion
-            | Kind::IndexUpdate => true,
+            | Kind::IndexUpdate
+            | Kind::IndexCompaction => true,
             Kind::IndexSwap
             | Kind::TaskCancelation
             | Kind::TaskDeletion
@@ -618,6 +642,7 @@ impl Display for Kind {
             Kind::SnapshotCreation => write!(f, "snapshotCreation"),
             Kind::Export => write!(f, "export"),
             Kind::UpgradeDatabase => write!(f, "upgradeDatabase"),
+            Kind::IndexCompaction => write!(f, "indexCompaction"),
         }
     }
 }
@@ -653,6 +678,8 @@ impl FromStr for Kind {
             Ok(Kind::Export)
         } else if kind.eq_ignore_ascii_case("upgradeDatabase") {
             Ok(Kind::UpgradeDatabase)
+        } else if kind.eq_ignore_ascii_case("indexCompaction") {
+            Ok(Kind::IndexCompaction)
         } else {
             Err(ParseTaskKindError(kind.to_owned()))
         }
@@ -738,6 +765,11 @@ pub enum Details {
         from: (u32, u32, u32),
         to: (u32, u32, u32),
     },
+    IndexCompaction {
+        index_uid: String,
+        pre_compaction_size: Option<Byte>,
+        post_compaction_size: Option<Byte>,
+    },
 }
 
 #[derive(Debug, PartialEq, Clone, Serialize, Deserialize, ToSchema)]
@@ -800,6 +832,10 @@ impl Details {
             Self::ClearAll { deleted_documents } => *deleted_documents = Some(0),
             Self::TaskCancelation { canceled_tasks, .. } => *canceled_tasks = Some(0),
             Self::TaskDeletion { deleted_tasks, .. } => *deleted_tasks = Some(0),
+            Self::IndexCompaction { pre_compaction_size, post_compaction_size, .. } => {
+                *pre_compaction_size = None;
+                *post_compaction_size = None;
+            }
             Self::SettingsUpdate { .. }
             | Self::IndexInfo { .. }
             | Self::Dump { .. }

crates/meilisearch/Cargo.toml

@@ -91,10 +91,11 @@ time = { version = "0.3.41", features = [
 ] }
 tokio = { version = "1.45.1", features = ["full"] }
 toml = "0.8.23"
-uuid = { version = "1.17.0", features = ["serde", "v4"] }
+uuid = { version = "1.18.0", features = ["serde", "v4", "v7"] }
 serde_urlencoded = "0.7.1"
 termcolor = "1.4.1"
 url = { version = "2.5.4", features = ["serde"] }
+cohere-rust = "0.6.0"
 tracing = "0.1.41"
 tracing-subscriber = { version = "0.3.20", features = ["json"] }
 tracing-trace = { version = "0.1.0", path = "../tracing-trace" }

crates/meilisearch/src/analytics/segment_analytics.rs

@@ -205,6 +205,8 @@ struct Infos {
     experimental_no_snapshot_compaction: bool,
     experimental_no_edition_2024_for_dumps: bool,
     experimental_no_edition_2024_for_settings: bool,
+    experimental_no_edition_2024_for_prefix_post_processing: bool,
+    experimental_no_edition_2024_for_facet_post_processing: bool,
     experimental_vector_store_setting: bool,
     gpu_enabled: bool,
     db_path: bool,
@@ -283,6 +285,7 @@ impl Infos {
             indexer_options,
             config_file_path,
             no_analytics: _,
+            experimental_personalization_api_key: _,
         } = options;
 
         let schedule_snapshot = match schedule_snapshot {
@@ -296,6 +299,8 @@ impl Infos {
             skip_index_budget: _,
             experimental_no_edition_2024_for_settings,
             experimental_no_edition_2024_for_dumps,
+            experimental_no_edition_2024_for_prefix_post_processing,
+            experimental_no_edition_2024_for_facet_post_processing,
         } = indexer_options;
 
         let RuntimeTogglableFeatures {
@@ -365,6 +370,8 @@ impl Infos {
             ssl_resumption,
             ssl_tickets,
             experimental_no_edition_2024_for_settings,
+            experimental_no_edition_2024_for_prefix_post_processing,
+            experimental_no_edition_2024_for_facet_post_processing,
         }
     }
 }

crates/meilisearch/src/error.rs

@@ -12,6 +12,7 @@ use tokio::task::JoinError;
 use crate::routes::indexes::{PROXY_ORIGIN_REMOTE_HEADER, PROXY_ORIGIN_TASK_UID_HEADER};
 
 #[derive(Debug, thiserror::Error)]
+#[allow(clippy::large_enum_variant)]
 pub enum MeilisearchHttpError {
     #[error("A Content-Type header is missing. Accepted values for the Content-Type header are: {}",
             .0.iter().map(|s| format!("`{}`", s)).collect::<Vec<_>>().join(", "))]

crates/meilisearch/src/lib.rs

@@ -1,4 +1,6 @@
+#![allow(clippy::result_large_err)]
 #![allow(rustdoc::private_intra_doc_links)]
+
 #[macro_use]
 pub mod error;
 pub mod analytics;
@@ -9,6 +11,7 @@ pub mod middleware;
 pub mod option;
 #[cfg(test)]
 mod option_test;
+pub mod personalization;
 pub mod routes;
 pub mod search;
 pub mod search_queue;
@@ -682,12 +685,19 @@ pub fn configure_data(
     (logs_route, logs_stderr): (LogRouteHandle, LogStderrHandle),
     analytics: Data<Analytics>,
 ) {
+    // Create personalization service with API key from options
+    let personalization_service = index_scheduler
+        .experimental_personalization_api_key()
+        .cloned()
+        .map(personalization::PersonalizationService::cohere)
+        .unwrap_or_else(personalization::PersonalizationService::uninitialized);
     let http_payload_size_limit = opt.http_payload_size_limit.as_u64() as usize;
     config
         .app_data(index_scheduler)
         .app_data(auth)
         .app_data(search_queue)
         .app_data(analytics)
+        .app_data(web::Data::new(personalization_service))
         .app_data(web::Data::new(logs_route))
         .app_data(web::Data::new(logs_stderr))
         .app_data(web::Data::new(opt.clone()))

crates/meilisearch/src/metrics.rs

@@ -114,4 +114,9 @@ lazy_static! {
             "Meilisearch Task Queue Size Until Stop Registering",
         ))
         .expect("Can't create a metric");
+    pub static ref MEILISEARCH_PERSONALIZED_SEARCH_REQUESTS: IntGauge = register_int_gauge!(opts!(
+        "meilisearch_personalized_search_requests",
+        "Meilisearch number of search requests with personalization"
+    ))
+    .expect("Can't create a metric");
 }

crates/meilisearch/src/option.rs

@@ -55,6 +55,10 @@ const MEILI_EXPERIMENTAL_ENABLE_LOGS_ROUTE: &str = "MEILI_EXPERIMENTAL_ENABLE_LO
 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_NO_EDITION_2024_FOR_FACET_POST_PROCESSING: &str =
+    "MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_FACET_POST_PROCESSING";
+const MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_PREFIX_POST_PROCESSING: &str =
+    "MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_PREFIX_POST_PROCESSING";
 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";
@@ -70,6 +74,8 @@ const MEILI_EXPERIMENTAL_EMBEDDING_CACHE_ENTRIES: &str =
 const MEILI_EXPERIMENTAL_NO_SNAPSHOT_COMPACTION: &str = "MEILI_EXPERIMENTAL_NO_SNAPSHOT_COMPACTION";
 const MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_DUMPS: &str =
     "MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_DUMPS";
+const MEILI_EXPERIMENTAL_PERSONALIZATION_API_KEY: &str =
+    "MEILI_EXPERIMENTAL_PERSONALIZATION_API_KEY";
 const DEFAULT_CONFIG_FILE_PATH: &str = "./config.toml";
 const DEFAULT_DB_PATH: &str = "./data.ms";
 const DEFAULT_HTTP_ADDR: &str = "localhost:7700";
@@ -471,6 +477,12 @@ pub struct Opt {
     #[serde(default)]
     pub experimental_no_snapshot_compaction: bool,
 
+    /// Experimental personalization API key feature.
+    ///
+    /// Sets the API key for personalization features.
+    #[clap(long, env = MEILI_EXPERIMENTAL_PERSONALIZATION_API_KEY)]
+    pub experimental_personalization_api_key: Option<String>,
+
     #[serde(flatten)]
     #[clap(flatten)]
     pub indexer_options: IndexerOpts,
@@ -576,6 +588,7 @@ impl Opt {
             experimental_limit_batched_tasks_total_size,
             experimental_embedding_cache_entries,
             experimental_no_snapshot_compaction,
+            experimental_personalization_api_key,
         } = self;
         export_to_env_if_not_present(MEILI_DB_PATH, db_path);
         export_to_env_if_not_present(MEILI_HTTP_ADDR, http_addr);
@@ -676,6 +689,12 @@ impl Opt {
             MEILI_EXPERIMENTAL_NO_SNAPSHOT_COMPACTION,
             experimental_no_snapshot_compaction.to_string(),
         );
+        if let Some(experimental_personalization_api_key) = experimental_personalization_api_key {
+            export_to_env_if_not_present(
+                MEILI_EXPERIMENTAL_PERSONALIZATION_API_KEY,
+                experimental_personalization_api_key,
+            );
+        }
         indexer_options.export_to_env();
     }
 
@@ -728,6 +747,7 @@ impl Opt {
             metrics: self.experimental_enable_metrics,
             logs_route: self.experimental_enable_logs_route,
             contains_filter: self.experimental_contains_filter,
+            experimental_personalization_api_key: self.experimental_personalization_api_key.clone(),
         }
     }
 }
@@ -772,6 +792,22 @@ pub struct IndexerOpts {
     #[clap(long, env = MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_DUMPS)]
     #[serde(default)]
     pub experimental_no_edition_2024_for_dumps: bool,
+
+    /// Experimental no edition 2024 to compute prefixes. For more information,
+    /// see: <https://github.com/orgs/meilisearch/discussions/862>
+    ///
+    /// Enables the experimental no edition 2024 to compute prefixes.
+    #[clap(long, env = MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_PREFIX_POST_PROCESSING)]
+    #[serde(default)]
+    pub experimental_no_edition_2024_for_prefix_post_processing: bool,
+
+    /// Experimental no edition 2024 to compute facets. For more information,
+    /// see: <https://github.com/orgs/meilisearch/discussions/862>
+    ///
+    /// Enables the experimental no edition 2024 to compute facets.
+    #[clap(long, env = MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_FACET_POST_PROCESSING)]
+    #[serde(default)]
+    pub experimental_no_edition_2024_for_facet_post_processing: bool,
 }
 
 impl IndexerOpts {
@@ -783,6 +819,8 @@ impl IndexerOpts {
             skip_index_budget: _,
             experimental_no_edition_2024_for_settings,
             experimental_no_edition_2024_for_dumps,
+            experimental_no_edition_2024_for_prefix_post_processing,
+            experimental_no_edition_2024_for_facet_post_processing,
         } = self;
         if let Some(max_indexing_memory) = max_indexing_memory.0 {
             export_to_env_if_not_present(
@@ -808,6 +846,18 @@ impl IndexerOpts {
                 experimental_no_edition_2024_for_dumps.to_string(),
             );
         }
+        if experimental_no_edition_2024_for_prefix_post_processing {
+            export_to_env_if_not_present(
+                MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_PREFIX_POST_PROCESSING,
+                experimental_no_edition_2024_for_prefix_post_processing.to_string(),
+            );
+        }
+        if experimental_no_edition_2024_for_facet_post_processing {
+            export_to_env_if_not_present(
+                MEILI_EXPERIMENTAL_NO_EDITION_2024_FOR_FACET_POST_PROCESSING,
+                experimental_no_edition_2024_for_facet_post_processing.to_string(),
+            );
+        }
     }
 }
 
@@ -833,6 +883,10 @@ impl TryFrom<&IndexerOpts> for IndexerConfig {
             chunk_compression_level: Default::default(),
             documents_chunk_size: Default::default(),
             max_nb_chunks: Default::default(),
+            experimental_no_edition_2024_for_prefix_post_processing: other
+                .experimental_no_edition_2024_for_prefix_post_processing,
+            experimental_no_edition_2024_for_facet_post_processing: other
+                .experimental_no_edition_2024_for_facet_post_processing,
         })
     }
 }

crates/meilisearch/src/personalization/mod.rs

@@ -0,0 +1,244 @@
+use crate::search::{Personalize, SearchResult};
+use cohere_rust::{
+    api::rerank::{ReRankModel, ReRankRequest},
+    Cohere,
+};
+use meilisearch_types::error::ResponseError;
+use tracing::{debug, error, info};
+
+pub struct CohereService {
+    cohere: Cohere,
+}
+
+impl CohereService {
+    pub fn new(api_key: String) -> Self {
+        info!("Personalization service initialized with Cohere API");
+        Self { cohere: Cohere::new("https://api.cohere.ai", api_key) }
+    }
+
+    pub async fn rerank_search_results(
+        &self,
+        search_result: SearchResult,
+        personalize: Option<&Personalize>,
+        query: Option<&str>,
+    ) -> Result<SearchResult, ResponseError> {
+        // Extract user context from personalization
+        let Some(user_context) = personalize.and_then(|p| p.user_context.as_deref()) else {
+            return Ok(search_result);
+        };
+
+        // Build the prompt by merging query and user context
+        let prompt = match query {
+            Some(q) => format!("User Context: {user_context}\nQuery: {q}"),
+            None => format!("User Context: {user_context}"),
+        };
+
+        // Extract documents for reranking
+        let documents: Vec<String> = search_result
+            .hits
+            .iter()
+            .map(|hit| {
+                // Convert the document to a string representation for reranking
+                serde_json::to_string(&hit.document).unwrap_or_else(|_| "{}".to_string())
+            })
+            .collect();
+
+        if documents.is_empty() {
+            return Ok(search_result);
+        }
+
+        // Prepare the rerank request
+        let rerank_request = ReRankRequest {
+            query: &prompt,
+            documents: &documents,
+            model: ReRankModel::EnglishV3, // Use the default and more recent model
+            top_n: None,
+            max_chunks_per_doc: None,
+        };
+
+        // Call Cohere's rerank API
+        match self.cohere.rerank(&rerank_request).await {
+            Ok(rerank_response) => {
+                debug!("Cohere rerank successful, reordering {} results", search_result.hits.len());
+
+                // Create a mapping from original index to new rank
+                let reranked_indices: Vec<usize> =
+                    rerank_response.iter().map(|result| result.index as usize).collect();
+
+                // Reorder the hits based on Cohere's reranking
+                let mut reranked_hits = Vec::new();
+                for index in reranked_indices.iter() {
+                    reranked_hits.push(search_result.hits[*index].clone());
+                }
+
+                Ok(SearchResult { hits: reranked_hits, ..search_result })
+            }
+            Err(e) => {
+                error!("Cohere rerank failed with model EnglishV3: {}", e);
+                // Return original results on error
+                Ok(search_result)
+            }
+        }
+    }
+}
+
+pub enum PersonalizationService {
+    Cohere(CohereService),
+    Uninitialized,
+}
+
+impl PersonalizationService {
+    pub fn cohere(api_key: String) -> Self {
+        Self::Cohere(CohereService::new(api_key))
+    }
+
+    pub fn uninitialized() -> Self {
+        debug!("Personalization service uninitialized");
+        Self::Uninitialized
+    }
+
+    pub async fn rerank_search_results(
+        &self,
+        search_result: SearchResult,
+        personalize: Option<&Personalize>,
+        query: Option<&str>,
+    ) -> Result<SearchResult, ResponseError> {
+        match self {
+            Self::Cohere(cohere_service) => {
+                cohere_service.rerank_search_results(search_result, personalize, query).await
+            }
+            Self::Uninitialized => Ok(search_result),
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::search::{HitsInfo, SearchHit};
+
+    #[tokio::test]
+    async fn test_personalization_service_without_api_key() {
+        let service = PersonalizationService::uninitialized();
+        let personalize = Personalize { user_context: Some("test user".to_string()) };
+
+        let search_result = SearchResult {
+            hits: vec![SearchHit {
+                document: serde_json::Map::new(),
+                formatted: serde_json::Map::new(),
+                matches_position: None,
+                ranking_score: Some(1.0),
+                ranking_score_details: None,
+            }],
+            query: "test".to_string(),
+            processing_time_ms: 10,
+            hits_info: HitsInfo::OffsetLimit { limit: 1, offset: 0, estimated_total_hits: 1 },
+            facet_distribution: None,
+            facet_stats: None,
+            semantic_hit_count: None,
+            degraded: false,
+            used_negative_operator: false,
+        };
+
+        let result = service
+            .rerank_search_results(search_result.clone(), Some(&personalize), Some("test"))
+            .await;
+        assert!(result.is_ok());
+
+        // Should return original results when no API key is provided
+        let reranked_result = result.unwrap();
+        assert_eq!(reranked_result.hits.len(), search_result.hits.len());
+    }
+
+    #[tokio::test]
+    async fn test_personalization_service_with_user_context_only() {
+        let service = PersonalizationService::cohere("fake_key".to_string());
+        let personalize = Personalize { user_context: Some("test user".to_string()) };
+
+        let search_result = SearchResult {
+            hits: vec![SearchHit {
+                document: serde_json::Map::new(),
+                formatted: serde_json::Map::new(),
+                matches_position: None,
+                ranking_score: Some(1.0),
+                ranking_score_details: None,
+            }],
+            query: "test".to_string(),
+            processing_time_ms: 10,
+            hits_info: HitsInfo::OffsetLimit { limit: 1, offset: 0, estimated_total_hits: 1 },
+            facet_distribution: None,
+            facet_stats: None,
+            semantic_hit_count: None,
+            degraded: false,
+            used_negative_operator: false,
+        };
+
+        let result =
+            service.rerank_search_results(search_result.clone(), Some(&personalize), None).await;
+        assert!(result.is_ok());
+
+        // Should attempt reranking with user context only
+        let reranked_result = result.unwrap();
+        assert_eq!(reranked_result.hits.len(), search_result.hits.len());
+    }
+
+    #[tokio::test]
+    async fn test_personalization_service_with_query_only() {
+        let service = PersonalizationService::cohere("fake_key".to_string());
+
+        let search_result = SearchResult {
+            hits: vec![SearchHit {
+                document: serde_json::Map::new(),
+                formatted: serde_json::Map::new(),
+                matches_position: None,
+                ranking_score: Some(1.0),
+                ranking_score_details: None,
+            }],
+            query: "test".to_string(),
+            processing_time_ms: 10,
+            hits_info: HitsInfo::OffsetLimit { limit: 1, offset: 0, estimated_total_hits: 1 },
+            facet_distribution: None,
+            facet_stats: None,
+            semantic_hit_count: None,
+            degraded: false,
+            used_negative_operator: false,
+        };
+
+        let result = service.rerank_search_results(search_result.clone(), None, Some("test")).await;
+        assert!(result.is_ok());
+
+        // Should attempt reranking with query only
+        let reranked_result = result.unwrap();
+        assert_eq!(reranked_result.hits.len(), search_result.hits.len());
+    }
+
+    #[tokio::test]
+    async fn test_personalization_service_both_none() {
+        let service = PersonalizationService::cohere("fake_key".to_string());
+
+        let search_result = SearchResult {
+            hits: vec![SearchHit {
+                document: serde_json::Map::new(),
+                formatted: serde_json::Map::new(),
+                matches_position: None,
+                ranking_score: Some(1.0),
+                ranking_score_details: None,
+            }],
+            query: "test".to_string(),
+            processing_time_ms: 10,
+            hits_info: HitsInfo::OffsetLimit { limit: 1, offset: 0, estimated_total_hits: 1 },
+            facet_distribution: None,
+            facet_stats: None,
+            semantic_hit_count: None,
+            degraded: false,
+            used_negative_operator: false,
+        };
+
+        let result = service.rerank_search_results(search_result.clone(), None, None).await;
+        assert!(result.is_ok());
+
+        // Should return original results when both query and user_context are None
+        let reranked_result = result.unwrap();
+        assert_eq!(reranked_result.hits.len(), search_result.hits.len());
+    }
+}

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

@@ -0,0 +1,84 @@
+use actix_web::web::{self, Data};
+use actix_web::{HttpRequest, HttpResponse};
+use index_scheduler::IndexScheduler;
+use meilisearch_types::error::ResponseError;
+use meilisearch_types::index_uid::IndexUid;
+use meilisearch_types::keys::actions;
+use meilisearch_types::tasks::KindWithContent;
+use tracing::debug;
+use utoipa::OpenApi;
+
+use super::ActionPolicy;
+use crate::analytics::Analytics;
+use crate::extractors::authentication::GuardedData;
+use crate::extractors::sequential_extractor::SeqHandler;
+use crate::routes::SummarizedTaskView;
+
+#[derive(OpenApi)]
+#[openapi(
+    paths(compact),
+    tags(
+        (
+            name = "Compact an index",
+            description = "The /compact route uses compacts the database to reorganize and make it smaller and more efficient.",
+            external_docs(url = "https://www.meilisearch.com/docs/reference/api/compact"),
+        ),
+    ),
+)]
+pub struct CompactApi;
+
+pub fn configure(cfg: &mut web::ServiceConfig) {
+    cfg.service(web::resource("").route(web::post().to(SeqHandler(compact))));
+}
+
+/// Compact an index
+#[utoipa::path(
+    post,
+    path = "{indexUid}/compact",
+    tag = "Compact an index",
+    security(("Bearer" = ["search", "*"])),
+    params(("indexUid" = String, Path, example = "movies", description = "Index Unique Identifier", nullable = false)),
+    responses(
+        (status = ACCEPTED, description = "Task successfully enqueued", body = SummarizedTaskView, content_type = "application/json", example = json!(
+            {
+                "taskUid": 147,
+                "indexUid": null,
+                "status": "enqueued",
+                "type": "documentDeletion",
+                "enqueuedAt": "2024-08-08T17:05:55.791772Z"
+            }
+        )),
+        (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"
+            }
+        )),
+    )
+)]
+pub async fn compact(
+    index_scheduler: GuardedData<ActionPolicy<{ actions::INDEXES_COMPACT }>, Data<IndexScheduler>>,
+    index_uid: web::Path<String>,
+    req: HttpRequest,
+    analytics: web::Data<Analytics>,
+) -> Result<HttpResponse, ResponseError> {
+    let index_uid = IndexUid::try_from(index_uid.into_inner())?;
+
+    analytics.publish(IndexCompacted::default(), &req);
+
+    let task = KindWithContent::IndexCompaction { index_uid: index_uid.to_string() };
+    let task =
+        match tokio::task::spawn_blocking(move || index_scheduler.register(task, None, false))
+            .await?
+        {
+            Ok(task) => task,
+            Err(e) => return Err(e.into()),
+        };
+
+    debug!(returns = ?task, "Compact the {index_uid} index");
+    Ok(HttpResponse::Accepted().json(SummarizedTaskView::from(task)))
+}
+
+crate::empty_analytics!(IndexCompacted, "Index Compacted");

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

@@ -343,6 +343,7 @@ impl From<FacetSearchQuery> for SearchQuery {
             hybrid,
             ranking_score_threshold,
             locales,
+            personalize: None,
         }
     }
 }

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

@@ -28,6 +28,7 @@ use crate::extractors::sequential_extractor::SeqHandler;
 use crate::routes::is_dry_run;
 use crate::Opt;
 
+pub mod compact;
 pub mod documents;
 mod enterprise_edition;
 pub mod facet_search;
@@ -49,8 +50,9 @@ pub use enterprise_edition::proxy::{PROXY_ORIGIN_REMOTE_HEADER, PROXY_ORIGIN_TAS
         (path = "/", api = facet_search::FacetSearchApi),
         (path = "/", api = similar::SimilarApi),
         (path = "/", api = settings::SettingsApi),
+        (path = "/", api = compact::CompactApi),
     ),
-    paths(list_indexes, create_index, get_index, update_index, delete_index, get_index_stats),
+    paths(list_indexes, create_index, get_index, update_index, delete_index, get_index_stats, compact::compact),
     tags(
         (
             name = "Indexes",
@@ -80,7 +82,8 @@ pub fn configure(cfg: &mut web::ServiceConfig) {
             .service(web::scope("/search").configure(search::configure))
             .service(web::scope("/facet-search").configure(facet_search::configure))
             .service(web::scope("/similar").configure(similar::configure))
-            .service(web::scope("/settings").configure(settings::configure)),
+            .service(web::scope("/settings").configure(settings::configure))
+            .service(web::scope("/compact").configure(compact::configure)),
     );
 }
 

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

@@ -13,6 +13,7 @@ use meilisearch_types::serde_cs::vec::CS;
 use serde_json::Value;
 use tracing::debug;
 use utoipa::{IntoParams, OpenApi};
+use uuid::Uuid;
 
 use crate::analytics::Analytics;
 use crate::error::MeilisearchHttpError;
@@ -21,11 +22,12 @@ use crate::extractors::authentication::GuardedData;
 use crate::extractors::sequential_extractor::SeqHandler;
 use crate::metrics::MEILISEARCH_DEGRADED_SEARCH_REQUESTS;
 use crate::routes::indexes::search_analytics::{SearchAggregator, SearchGET, SearchPOST};
+use crate::routes::parse_include_metadata_header;
 use crate::search::{
-    add_search_rules, perform_search, HybridQuery, MatchingStrategy, RankingScoreThreshold,
-    RetrieveVectors, SearchKind, SearchQuery, SearchResult, SemanticRatio, DEFAULT_CROP_LENGTH,
-    DEFAULT_CROP_MARKER, DEFAULT_HIGHLIGHT_POST_TAG, DEFAULT_HIGHLIGHT_PRE_TAG,
-    DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_OFFSET, DEFAULT_SEMANTIC_RATIO,
+    add_search_rules, perform_search, HybridQuery, MatchingStrategy, Personalize,
+    RankingScoreThreshold, RetrieveVectors, SearchKind, SearchParams, SearchQuery, SearchResult,
+    SemanticRatio, DEFAULT_CROP_LENGTH, DEFAULT_CROP_MARKER, DEFAULT_HIGHLIGHT_POST_TAG,
+    DEFAULT_HIGHLIGHT_PRE_TAG, DEFAULT_SEARCH_LIMIT, DEFAULT_SEARCH_OFFSET, DEFAULT_SEMANTIC_RATIO,
 };
 use crate::search_queue::SearchQueue;
 
@@ -132,6 +134,8 @@ pub struct SearchQueryGet {
     #[deserr(default, error = DeserrQueryParamError<InvalidSearchLocales>)]
     #[param(value_type = Vec<Locale>, explode = false)]
     pub locales: Option<CS<Locale>>,
+    #[deserr(default, error = DeserrQueryParamError<InvalidSearchPersonalizeUserContext>)]
+    pub personalize_user_context: Option<String>,
 }
 
 #[derive(Debug, Clone, Copy, PartialEq, deserr::Deserr)]
@@ -203,6 +207,10 @@ impl TryFrom<SearchQueryGet> for SearchQuery {
             ));
         }
 
+        let personalize = other
+            .personalize_user_context
+            .map(|user_context| Personalize { user_context: Some(user_context) });
+
         Ok(Self {
             q: other.q,
             // `media` not supported for `GET`
@@ -232,6 +240,7 @@ impl TryFrom<SearchQueryGet> for SearchQuery {
             hybrid,
             ranking_score_threshold: other.ranking_score_threshold.map(|o| o.0),
             locales: other.locales.map(|o| o.into_iter().collect()),
+            personalize,
         })
     }
 }
@@ -320,12 +329,14 @@ pub fn fix_sort_query_parameters(sort_query: &str) -> Vec<String> {
 pub async fn search_with_url_query(
     index_scheduler: GuardedData<ActionPolicy<{ actions::SEARCH }>, Data<IndexScheduler>>,
     search_queue: web::Data<SearchQueue>,
+    personalization_service: web::Data<crate::personalization::PersonalizationService>,
     index_uid: web::Path<String>,
     params: AwebQueryParameter<SearchQueryGet, DeserrQueryParamError>,
     req: HttpRequest,
     analytics: web::Data<Analytics>,
 ) -> Result<HttpResponse, ResponseError> {
-    debug!(parameters = ?params, "Search get");
+    let request_uid = Uuid::now_v7();
+    debug!(request_uid = ?request_uid, parameters = ?params, "Search get");
     let index_uid = IndexUid::try_from(index_uid.into_inner())?;
 
     let mut query: SearchQuery = params.into_inner().try_into()?;
@@ -342,15 +353,26 @@ pub async fn search_with_url_query(
     let search_kind =
         search_kind(&query, index_scheduler.get_ref(), index_uid.to_string(), &index)?;
     let retrieve_vector = RetrieveVectors::new(query.retrieve_vectors);
+
+    // Extract personalization and query string before moving query
+    let personalize = query.personalize.clone();
+    let query_str = query.q.clone();
+
     let permit = search_queue.try_get_search_permit().await?;
+    let include_metadata = parse_include_metadata_header(&req);
+
     let search_result = tokio::task::spawn_blocking(move || {
         perform_search(
-            index_uid.to_string(),
+            SearchParams {
+                index_uid: index_uid.to_string(),
+                query,
+                search_kind,
+                retrieve_vectors: retrieve_vector,
+                features: index_scheduler.features(),
+                request_uid,
+                include_metadata,
+            },
             &index,
-            query,
-            search_kind,
-            retrieve_vector,
-            index_scheduler.features(),
         )
     })
     .await;
@@ -361,9 +383,14 @@ pub async fn search_with_url_query(
     }
     analytics.publish(aggregate, &req);
 
-    let search_result = search_result?;
+    let mut search_result = search_result?;
 
-    debug!(returns = ?search_result, "Search get");
+    // Apply personalization if requested
+    search_result = personalization_service
+        .rerank_search_results(search_result, personalize.as_ref(), query_str.as_deref())
+        .await?;
+
+    debug!(request_uid = ?request_uid, returns = ?search_result, "Search get");
     Ok(HttpResponse::Ok().json(search_result))
 }
 
@@ -426,15 +453,17 @@ pub async fn search_with_url_query(
 pub async fn search_with_post(
     index_scheduler: GuardedData<ActionPolicy<{ actions::SEARCH }>, Data<IndexScheduler>>,
     search_queue: web::Data<SearchQueue>,
+    personalization_service: web::Data<crate::personalization::PersonalizationService>,
     index_uid: web::Path<String>,
     params: AwebJson<SearchQuery, DeserrJsonError>,
     req: HttpRequest,
     analytics: web::Data<Analytics>,
 ) -> Result<HttpResponse, ResponseError> {
     let index_uid = IndexUid::try_from(index_uid.into_inner())?;
+    let request_uid = Uuid::now_v7();
 
     let mut query = params.into_inner();
-    debug!(parameters = ?query, "Search post");
+    debug!(request_uid = ?request_uid, parameters = ?query, "Search post");
 
     // Tenant token search_rules.
     if let Some(search_rules) = index_scheduler.filters().get_index_search_rules(&index_uid) {
@@ -449,15 +478,25 @@ pub async fn search_with_post(
         search_kind(&query, index_scheduler.get_ref(), index_uid.to_string(), &index)?;
     let retrieve_vectors = RetrieveVectors::new(query.retrieve_vectors);
 
+    let include_metadata = parse_include_metadata_header(&req);
+
+    // Extract personalization and query string before moving query
+    let personalize = query.personalize.clone();
+    let query_str = query.q.clone();
+
     let permit = search_queue.try_get_search_permit().await?;
     let search_result = tokio::task::spawn_blocking(move || {
         perform_search(
-            index_uid.to_string(),
+            SearchParams {
+                index_uid: index_uid.to_string(),
+                query,
+                search_kind,
+                retrieve_vectors,
+                features: index_scheduler.features(),
+                request_uid,
+                include_metadata,
+            },
             &index,
-            query,
-            search_kind,
-            retrieve_vectors,
-            index_scheduler.features(),
         )
     })
     .await;
@@ -471,9 +510,14 @@ pub async fn search_with_post(
     }
     analytics.publish(aggregate, &req);
 
-    let search_result = search_result?;
+    let mut search_result = search_result?;
 
-    debug!(returns = ?search_result, "Search post");
+    // Apply personalization if requested
+    search_result = personalization_service
+        .rerank_search_results(search_result, personalize.as_ref(), query_str.as_deref())
+        .await?;
+
+    debug!(request_uid = ?request_uid, returns = ?search_result, "Search post");
     Ok(HttpResponse::Ok().json(search_result))
 }
 

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

@@ -7,6 +7,7 @@ use serde_json::{json, Value};
 
 use crate::aggregate_methods;
 use crate::analytics::{Aggregate, AggregateMethod};
+use crate::metrics::MEILISEARCH_PERSONALIZED_SEARCH_REQUESTS;
 use crate::search::{
     SearchQuery, SearchResult, DEFAULT_CROP_LENGTH, DEFAULT_CROP_MARKER,
     DEFAULT_HIGHLIGHT_POST_TAG, DEFAULT_HIGHLIGHT_PRE_TAG, DEFAULT_SEARCH_LIMIT,
@@ -95,6 +96,9 @@ pub struct SearchAggregator<Method: AggregateMethod> {
     show_ranking_score_details: bool,
     ranking_score_threshold: bool,
 
+    // personalization
+    total_personalized: usize,
+
     marker: std::marker::PhantomData<Method>,
 }
 
@@ -129,6 +133,7 @@ impl<Method: AggregateMethod> SearchAggregator<Method> {
             hybrid,
             ranking_score_threshold,
             locales,
+            personalize,
         } = query;
 
         let mut ret = Self::default();
@@ -204,6 +209,12 @@ impl<Method: AggregateMethod> SearchAggregator<Method> {
             ret.locales = locales.iter().copied().collect();
         }
 
+        // personalization
+        if personalize.is_some() {
+            ret.total_personalized = 1;
+            MEILISEARCH_PERSONALIZED_SEARCH_REQUESTS.inc();
+        }
+
         ret.highlight_pre_tag = *highlight_pre_tag != DEFAULT_HIGHLIGHT_PRE_TAG();
         ret.highlight_post_tag = *highlight_post_tag != DEFAULT_HIGHLIGHT_POST_TAG();
         ret.crop_marker = *crop_marker != DEFAULT_CROP_MARKER();
@@ -234,6 +245,8 @@ impl<Method: AggregateMethod> SearchAggregator<Method> {
             facet_stats: _,
             degraded,
             used_negative_operator,
+            request_uid: _,
+            metadata: _,
         } = result;
 
         self.total_succeeded = self.total_succeeded.saturating_add(1);
@@ -294,6 +307,7 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
             total_used_negative_operator,
             ranking_score_threshold,
             mut locales,
+            total_personalized,
             marker: _,
         } = *new;
 
@@ -379,6 +393,9 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
         // locales
         self.locales.append(&mut locales);
 
+        // personalization
+        self.total_personalized = self.total_personalized.saturating_add(total_personalized);
+
         self
     }
 
@@ -424,6 +441,7 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
             total_used_negative_operator,
             ranking_score_threshold,
             locales,
+            total_personalized,
             marker: _,
         } = *self;
 
@@ -497,6 +515,9 @@ impl<Method: AggregateMethod> Aggregate for SearchAggregator<Method> {
                 "show_ranking_score_details": show_ranking_score_details,
                 "ranking_score_threshold": ranking_score_threshold,
             },
+            "personalization": {
+                "total_personalized": total_personalized,
+            },
         })
     }
 }

crates/meilisearch/src/routes/metrics.rs

@@ -180,12 +180,6 @@ pub async fn get_metrics(
 
     let response = String::from_utf8(buffer).expect("Failed to convert bytes to string");
 
-    // We cannot specify the version with ContentType(TEXT_PLAIN_UTF_8) so we have to write everything by hand :(
-    // see the following for what should be returned: https://prometheus.io/docs/instrumenting/content_negotiation/#content-type-response
-    let content_type = ("content-type", "text/plain; version=0.0.4; charset=utf-8");
-
-    Ok(HttpResponse::Ok()
-        // .insert_header(header::ContentType(mime::TEXT_PLAIN_UTF_8))
-        .insert_header(content_type)
-        .body(response))
+    let content_type = ("content-type", prometheus::TEXT_FORMAT);
+    Ok(HttpResponse::Ok().insert_header(content_type).body(response))
 }

crates/meilisearch/src/routes/mod.rs

@@ -45,6 +45,7 @@ use crate::routes::webhooks::{WebhookResults, WebhookSettings, WebhookWithMetada
 use crate::search::{
     FederatedSearch, FederatedSearchResult, Federation, FederationOptions, MergeFacets,
     SearchQueryWithIndex, SearchResultWithIndex, SimilarQuery, SimilarResult,
+    INCLUDE_METADATA_HEADER,
 };
 use crate::search_queue::SearchQueue;
 use crate::Opt;
@@ -184,6 +185,18 @@ pub fn is_dry_run(req: &HttpRequest, opt: &Opt) -> Result<bool, ResponseError> {
         .is_some_and(|s| s.to_lowercase() == "true"))
 }
 
+/// Parse the `Meili-Include-Metadata` header from an HTTP request.
+///
+/// Returns `true` if the header is present and set to "true" or "1" (case-insensitive).
+/// Returns `false` if the header is not present or has any other value.
+pub fn parse_include_metadata_header(req: &HttpRequest) -> bool {
+    req.headers()
+        .get(INCLUDE_METADATA_HEADER)
+        .and_then(|h| h.to_str().ok())
+        .map(|v| matches!(v.to_lowercase().as_str(), "true" | "1"))
+        .unwrap_or(false)
+}
+
 #[derive(Debug, Serialize, Deserialize, ToSchema)]
 #[serde(rename_all = "camelCase")]
 pub struct SummarizedTaskView {

crates/meilisearch/src/routes/multi_search.rs

@@ -9,6 +9,7 @@ use meilisearch_types::keys::actions;
 use serde::Serialize;
 use tracing::debug;
 use utoipa::{OpenApi, ToSchema};
+use uuid::Uuid;
 
 use super::multi_search_analytics::MultiSearchAggregator;
 use crate::analytics::Analytics;
@@ -17,10 +18,11 @@ use crate::extractors::authentication::policies::ActionPolicy;
 use crate::extractors::authentication::{AuthenticationError, GuardedData};
 use crate::extractors::sequential_extractor::SeqHandler;
 use crate::routes::indexes::search::search_kind;
+use crate::routes::parse_include_metadata_header;
 use crate::search::{
     add_search_rules, perform_federated_search, perform_search, FederatedSearch,
-    FederatedSearchResult, RetrieveVectors, SearchQueryWithIndex, SearchResultWithIndex,
-    PROXY_SEARCH_HEADER, PROXY_SEARCH_HEADER_VALUE,
+    FederatedSearchResult, RetrieveVectors, SearchParams, SearchQueryWithIndex,
+    SearchResultWithIndex, PROXY_SEARCH_HEADER, PROXY_SEARCH_HEADER_VALUE,
 };
 use crate::search_queue::SearchQueue;
 
@@ -151,6 +153,7 @@ pub async fn multi_search_with_post(
     // Since we don't want to process half of the search requests and then get a permit refused
     // we're going to get one permit for the whole duration of the multi-search request.
     let permit = search_queue.try_get_search_permit().await?;
+    let request_uid = Uuid::now_v7();
 
     let federated_search = params.into_inner();
 
@@ -186,16 +189,31 @@ pub async fn multi_search_with_post(
         err
     })?;
 
+    let include_metadata = parse_include_metadata_header(&req);
     let response = match federation {
         Some(federation) => {
+            debug!(
+                request_uid = ?request_uid,
+                federation = ?federation,
+                parameters = ?queries,
+                "Federated-search"
+            );
+
             // check remote header
             let is_proxy = req
                 .headers()
                 .get(PROXY_SEARCH_HEADER)
                 .is_some_and(|value| value.as_bytes() == PROXY_SEARCH_HEADER_VALUE.as_bytes());
-            let search_result =
-                perform_federated_search(&index_scheduler, queries, federation, features, is_proxy)
-                    .await;
+            let search_result = perform_federated_search(
+                &index_scheduler,
+                queries,
+                federation,
+                features,
+                is_proxy,
+                request_uid,
+                include_metadata,
+            )
+            .await;
             permit.drop().await;
 
             if search_result.is_ok() {
@@ -203,6 +221,13 @@ pub async fn multi_search_with_post(
             }
 
             analytics.publish(multi_aggregate, &req);
+
+            debug!(
+                request_uid = ?request_uid,
+                returns = ?search_result,
+                "Federated-search"
+            );
+
             HttpResponse::Ok().json(search_result?)
         }
         None => {
@@ -216,7 +241,12 @@ pub async fn multi_search_with_post(
                     .map(SearchQueryWithIndex::into_index_query_federation)
                     .enumerate()
                 {
-                    debug!(on_index = query_index, parameters = ?query, "Multi-search");
+                    debug!(
+                        request_uid = ?request_uid,
+                        on_index = query_index,
+                        parameters = ?query,
+                        "Multi-search"
+                    );
 
                     if federation_options.is_some() {
                         return Err((
@@ -252,12 +282,16 @@ pub async fn multi_search_with_post(
 
                     let search_result = tokio::task::spawn_blocking(move || {
                         perform_search(
-                            index_uid_str.clone(),
+                            SearchParams {
+                                index_uid: index_uid_str.clone(),
+                                query,
+                                search_kind,
+                                retrieve_vectors: retrieve_vector,
+                                features,
+                                request_uid,
+                                include_metadata,
+                            },
                             &index,
-                            query,
-                            search_kind,
-                            retrieve_vector,
-                            features,
                         )
                     })
                     .await
@@ -286,7 +320,11 @@ pub async fn multi_search_with_post(
                 err
             })?;
 
-            debug!(returns = ?search_results, "Multi-search");
+            debug!(
+                request_uid = ?request_uid,
+                returns = ?search_results,
+                "Multi-search"
+            );
 
             HttpResponse::Ok().json(SearchResults { results: search_results })
         }

crates/meilisearch/src/routes/multi_search_analytics.rs

@@ -67,6 +67,7 @@ impl MultiSearchAggregator {
             hybrid: _,
             ranking_score_threshold: _,
             locales: _,
+            personalize: _,
         } in &federated_search.queries
         {
             if let Some(federation_options) = federation_options {

crates/meilisearch/src/routes/tasks_test.rs

@@ -226,14 +226,14 @@ mod tests {
         {
             let params = "types=createIndex";
             let err = deserr_query_params::<TaskDeletionOrCancelationQuery>(params).unwrap_err();
-            snapshot!(meili_snap::json_string!(err), @r#"
+            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`, `export`, `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`, `indexCompaction`.",
               "code": "invalid_task_types",
               "type": "invalid_request",
               "link": "https://docs.meilisearch.com/errors#invalid_task_types"
             }
-            "#);
+            "###);
         }
     }
     #[test]

crates/meilisearch/src/routes/webhooks.rs

@@ -1,3 +1,4 @@
+use core::convert::Infallible;
 use std::collections::BTreeMap;
 use std::str::FromStr;
 
@@ -7,7 +8,6 @@ use actix_http::header::{
 };
 use actix_web::web::{self, Data, Path};
 use actix_web::{HttpRequest, HttpResponse};
-use core::convert::Infallible;
 use deserr::actix_web::AwebJson;
 use deserr::{DeserializeError, Deserr, ValuePointerRef};
 use index_scheduler::IndexScheduler;
@@ -24,12 +24,12 @@ use tracing::debug;
 use url::Url;
 use utoipa::{OpenApi, ToSchema};
 use uuid::Uuid;
+use WebhooksError::*;
 
 use crate::analytics::{Aggregate, Analytics};
 use crate::extractors::authentication::policies::ActionPolicy;
 use crate::extractors::authentication::GuardedData;
 use crate::extractors::sequential_extractor::SeqHandler;
-use WebhooksError::*;
 
 #[derive(OpenApi)]
 #[openapi(

crates/meilisearch/src/search/federated/perform.rs

@@ -17,8 +17,10 @@ use meilisearch_types::milli::vector::Embedding;
 use meilisearch_types::milli::{self, DocumentId, OrderBy, TimeBudget, DEFAULT_VALUES_PER_FACET};
 use roaring::RoaringBitmap;
 use tokio::task::JoinHandle;
+use uuid::Uuid;
 
 use super::super::ranking_rules::{self, RankingRules};
+use super::super::SearchMetadata;
 use super::super::{
     compute_facet_distribution_stats, prepare_search, AttributesFormat, ComputedFacets, HitMaker,
     HitsInfo, RetrieveVectors, SearchHit, SearchKind, SearchQuery, SearchQueryWithIndex,
@@ -39,12 +41,20 @@ pub async fn perform_federated_search(
     federation: Federation,
     features: RoFeatures,
     is_proxy: bool,
+    request_uid: Uuid,
+    include_metadata: bool,
 ) -> Result<FederatedSearchResult, ResponseError> {
     if is_proxy {
         features.check_network("Performing a remote federated search")?;
     }
     let before_search = std::time::Instant::now();
-    let deadline = before_search + std::time::Duration::from_secs(9);
+
+    let timeout = std::env::var("MEILI_EXPERIMENTAL_REMOTE_SEARCH_TIMEOUT_SECONDS")
+        .ok()
+        .map(|p| p.parse().unwrap())
+        .unwrap_or(25);
+
+    let deadline = before_search + std::time::Duration::from_secs(timeout);
 
     let required_hit_count = federation.limit + federation.offset;
     let retrieve_vectors = queries.iter().any(|q| q.retrieve_vectors);
@@ -57,14 +67,27 @@ pub async fn perform_federated_search(
 
     // 1. partition queries by host and index
     let mut partitioned_queries = PartitionedQueries::new();
+
+    // Preconstruct metadata keeping the original queries order for later metadata building
+    let precomputed_query_metadata: Vec<_> = queries
+        .iter()
+        .map(|q| {
+            (q.index_uid.to_string(), q.federation_options.as_ref().and_then(|o| o.remote.clone()))
+        })
+        .collect();
+
     for (query_index, federated_query) in queries.into_iter().enumerate() {
         partitioned_queries.partition(federated_query, query_index, &network, features)?
     }
 
     // 2. perform queries, merge and make hits index by index
     // 2.1. start remote queries
-    let remote_search =
-        RemoteSearch::start(partitioned_queries.remote_queries_by_host, &federation, deadline);
+    let remote_search = RemoteSearch::start(
+        partitioned_queries.remote_queries_by_host,
+        &federation,
+        deadline,
+        include_metadata,
+    );
 
     // 2.2. concurrently execute local queries
     let params = SearchByIndexParams {
@@ -106,11 +129,63 @@ pub async fn perform_federated_search(
     let after_waiting_remote_results = std::time::Instant::now();
 
     // 3. merge hits and metadata across indexes and hosts
-    // 3.1. merge metadata
+
+    // 3.1. Build metadata in the same order as the original queries
+    let query_metadata = if include_metadata {
+        // 3.1.1. Create a map of (remote, index_uid) -> primary_key for quick lookup
+        // This prevents collisions when multiple remotes have the same index_uid but different primary keys
+        let mut primary_key_per_index = std::collections::HashMap::new();
+
+        // 3.1.1.1 Build metadata for remote results
+        for remote_result in &remote_results {
+            if let Some(remote_metadata) = &remote_result.metadata {
+                for remote_meta in remote_metadata {
+                    if let SearchMetadata {
+                        remote: Some(remote_name),
+                        index_uid,
+                        primary_key: Some(primary_key),
+                        ..
+                    } = &remote_meta
+                    {
+                        let key = (Some(remote_name), index_uid);
+                        primary_key_per_index.insert(key, primary_key);
+                    }
+                }
+            }
+        }
+
+        // 3.1.1.2 Build metadata for local results
+        for local_meta in &results_by_index {
+            if let SearchResultByIndex { index, primary_key: Some(primary_key), .. } = &local_meta {
+                let key = (None, index);
+                primary_key_per_index.insert(key, primary_key);
+            }
+        }
+
+        // if there are remote results, set the local remote name
+        let local_remote_name =
+            (!remote_results.is_empty()).then_some(network.local.clone()).flatten();
+
+        // 3.1.2 Build metadata in the same order as the original queries
+        let mut query_metadata = Vec::new();
+        for (index_uid, remote) in precomputed_query_metadata {
+            let primary_key =
+                primary_key_per_index.get(&(remote.as_ref(), &index_uid)).map(|pk| pk.to_string());
+            let query_uid = Uuid::now_v7();
+            // if the remote is not set, use the local remote name
+            let remote = remote.or_else(|| local_remote_name.clone());
+            query_metadata.push(SearchMetadata { query_uid, primary_key, index_uid, remote });
+        }
+        Some(query_metadata)
+    } else {
+        None
+    };
+
+    // 3.2. merge federation metadata
     let (estimated_total_hits, degraded, used_negative_operator, facets, max_remote_duration) =
         merge_metadata(&mut results_by_index, &remote_results);
 
-    // 3.2. merge hits
+    // 3.3. merge hits
     let merged_hits: Vec<_> = merge_index_global_results(results_by_index, &mut remote_results)
         .skip(federation.offset)
         .take(federation.limit)
@@ -125,7 +200,7 @@ pub async fn perform_federated_search(
         .map(|hit| hit.hit())
         .collect();
 
-    // 3.3. merge query vectors
+    // 3.4. merge query vectors
     let query_vectors = if retrieve_vectors {
         for remote_results in remote_results.iter_mut() {
             if let Some(remote_vectors) = remote_results.query_vectors.take() {
@@ -144,7 +219,7 @@ pub async fn perform_federated_search(
         None
     };
 
-    // 3.4. merge facets
+    // 3.5. merge facets
     let (facet_distribution, facet_stats, facets_by_index) =
         facet_order.merge(federation.merge_facets, remote_results, facets);
 
@@ -170,6 +245,8 @@ pub async fn perform_federated_search(
         facet_stats,
         facets_by_index,
         remote_errors: partitioned_queries.has_remote.then_some(remote_errors),
+        request_uid: Some(request_uid),
+        metadata: query_metadata,
     })
 }
 
@@ -219,7 +296,7 @@ struct SearchResultByQueryIterItem<'a> {
 
 fn merge_index_local_results(
     results_by_query: Vec<SearchResultByQuery<'_>>,
-) -> impl Iterator<Item = SearchResultByQueryIterItem> + '_ {
+) -> impl Iterator<Item = SearchResultByQueryIterItem<'_>> + '_ {
     itertools::kmerge_by(
         results_by_query.into_iter().map(SearchResultByQueryIter::new),
         |left: &SearchResultByQueryIterItem, right: &SearchResultByQueryIterItem| {
@@ -393,6 +470,7 @@ struct SearchHitByIndex {
 
 struct SearchResultByIndex {
     index: String,
+    primary_key: Option<String>,
     hits: Vec<SearchHitByIndex>,
     estimated_total_hits: usize,
     degraded: bool,
@@ -411,6 +489,7 @@ fn merge_metadata(
     let mut max_remote_duration = Duration::ZERO;
     for SearchResultByIndex {
         index,
+        primary_key: _,
         hits: _,
         estimated_total_hits: estimated_total_hits_by_index,
         facets: facets_by_index,
@@ -439,6 +518,8 @@ fn merge_metadata(
         degraded: degraded_for_host,
         used_negative_operator: host_used_negative_operator,
         remote_errors: _,
+        metadata: _,
+        request_uid: _,
     } in remote_results
     {
         let this_remote_duration = Duration::from_millis(*processing_time_ms as u64);
@@ -566,7 +647,12 @@ struct RemoteSearch {
 }
 
 impl RemoteSearch {
-    fn start(queries: RemoteQueriesByHost, federation: &Federation, deadline: Instant) -> Self {
+    fn start(
+        queries: RemoteQueriesByHost,
+        federation: &Federation,
+        deadline: Instant,
+        include_metadata: bool,
+    ) -> Self {
         let mut in_flight_remote_queries = BTreeMap::new();
         let client = reqwest::ClientBuilder::new()
             .connect_timeout(std::time::Duration::from_millis(200))
@@ -586,7 +672,10 @@ impl RemoteSearch {
                     // never merge distant facets
                     proxy_federation.merge_facets = None;
                     let params = params.clone();
-                    async move { proxy_search(&node, queries, proxy_federation, &params).await }
+                    async move {
+                        proxy_search(&node, queries, proxy_federation, &params, include_metadata)
+                            .await
+                    }
                 }),
             );
         }
@@ -630,6 +719,13 @@ impl RemoteSearch {
                             continue 'remote_queries;
                         }
 
+                        // Add remote name to metadata
+                        if let Some(metadata) = res.metadata.as_mut() {
+                            for meta in metadata {
+                                meta.remote = Some(node_name.clone());
+                            }
+                        }
+
                         federation.insert(
                             FEDERATION_REMOTE.to_string(),
                             serde_json::Value::String(node_name.clone()),
@@ -725,6 +821,7 @@ impl SearchByIndex {
             }
         };
         let rtxn = index.read_txn()?;
+        let primary_key = index.primary_key(&rtxn)?.map(|pk| pk.to_string());
         let criteria = index.criteria(&rtxn)?;
         let dictionary = index.dictionary(&rtxn)?;
         let dictionary: Option<Vec<_>> =
@@ -977,6 +1074,7 @@ impl SearchByIndex {
             })?;
         self.results_by_index.push(SearchResultByIndex {
             index: index_uid,
+            primary_key,
             hits: merged_result,
             estimated_total_hits,
             degraded,

crates/meilisearch/src/search/federated/proxy.rs

@@ -7,7 +7,7 @@ use serde::de::DeserializeOwned;
 use serde_json::Value;
 
 use super::types::{FederatedSearch, FederatedSearchResult, Federation};
-use crate::search::SearchQueryWithIndex;
+use crate::search::{SearchQueryWithIndex, INCLUDE_METADATA_HEADER};
 
 pub const PROXY_SEARCH_HEADER: &str = "Meili-Proxy-Search";
 pub const PROXY_SEARCH_HEADER_VALUE: &str = "true";
@@ -98,6 +98,7 @@ pub async fn proxy_search(
     queries: Vec<SearchQueryWithIndex>,
     federation: Federation,
     params: &ProxySearchParams,
+    include_metadata: bool,
 ) -> Result<FederatedSearchResult, ProxySearchError> {
     let url = format!("{}/multi-search", node.url);
 
@@ -105,7 +106,12 @@ pub async fn proxy_search(
 
     let search_api_key = node.search_api_key.as_deref();
 
-    let max_deadline = std::time::Instant::now() + std::time::Duration::from_secs(5);
+    let timeout = std::env::var("MEILI_EXPERIMENTAL_REMOTE_SEARCH_TIMEOUT_SECONDS")
+        .ok()
+        .map(|p| p.parse().unwrap())
+        .unwrap_or(25);
+
+    let max_deadline = std::time::Instant::now() + std::time::Duration::from_secs(timeout);
 
     let deadline = if let Some(deadline) = params.deadline {
         std::time::Instant::min(deadline, max_deadline)
@@ -114,7 +120,16 @@ pub async fn proxy_search(
     };
 
     for i in 0..params.try_count {
-        match try_proxy_search(&url, search_api_key, &federated, &params.client, deadline).await {
+        match try_proxy_search(
+            &url,
+            search_api_key,
+            &federated,
+            &params.client,
+            deadline,
+            include_metadata,
+        )
+        .await
+        {
             Ok(response) => return Ok(response),
             Err(retry) => {
                 let duration = retry.into_duration(i)?;
@@ -122,7 +137,7 @@ pub async fn proxy_search(
             }
         }
     }
-    try_proxy_search(&url, search_api_key, &federated, &params.client, deadline)
+    try_proxy_search(&url, search_api_key, &federated, &params.client, deadline, include_metadata)
         .await
         .map_err(Retry::into_error)
 }
@@ -133,6 +148,7 @@ async fn try_proxy_search(
     federated: &FederatedSearch,
     client: &Client,
     deadline: std::time::Instant,
+    include_metadata: bool,
 ) -> Result<FederatedSearchResult, Retry> {
     let timeout = deadline.saturating_duration_since(std::time::Instant::now());
 
@@ -143,6 +159,8 @@ async fn try_proxy_search(
         request
     };
     let request = request.header(PROXY_SEARCH_HEADER, PROXY_SEARCH_HEADER_VALUE);
+    let request =
+        if include_metadata { request.header(INCLUDE_METADATA_HEADER, "true") } else { request };
 
     let response = request.send().await;
     let response = match response {

crates/meilisearch/src/search/federated/types.rs

@@ -16,6 +16,9 @@ use meilisearch_types::milli::order_by_map::OrderByMap;
 use meilisearch_types::milli::OrderBy;
 use serde::{Deserialize, Serialize};
 use utoipa::ToSchema;
+use uuid::Uuid;
+
+use crate::search::SearchMetadata;
 
 use super::super::{ComputedFacets, FacetStats, HitsInfo, SearchHit, SearchQueryWithIndex};
 use crate::milli::vector::Embedding;
@@ -131,6 +134,10 @@ pub struct FederatedSearchResult {
     pub facet_stats: Option<BTreeMap<String, FacetStats>>,
     #[serde(default, skip_serializing_if = "FederatedFacets::is_empty")]
     pub facets_by_index: FederatedFacets,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub request_uid: Option<Uuid>,
+    #[serde(default, skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<Vec<SearchMetadata>>,
 
     #[serde(default, skip_serializing_if = "Option::is_none")]
     pub remote_errors: Option<BTreeMap<String, ResponseError>>,
@@ -156,6 +163,8 @@ impl fmt::Debug for FederatedSearchResult {
             facet_stats,
             facets_by_index,
             remote_errors,
+            request_uid,
+            metadata,
         } = self;
 
         let mut debug = f.debug_struct("SearchResult");
@@ -188,6 +197,12 @@ impl fmt::Debug for FederatedSearchResult {
         if let Some(remote_errors) = remote_errors {
             debug.field("remote_errors", &remote_errors);
         }
+        if let Some(request_uid) = request_uid {
+            debug.field("request_uid", &request_uid);
+        }
+        if let Some(metadata) = metadata {
+            debug.field("metadata", &metadata);
+        }
 
         debug.finish()
     }

crates/meilisearch/src/search/mod.rs

@@ -36,6 +36,7 @@ use serde_json::{json, Value};
 #[cfg(test)]
 mod mod_test;
 use utoipa::ToSchema;
+use uuid::Uuid;
 
 use crate::error::MeilisearchHttpError;
 
@@ -56,6 +57,14 @@ pub const DEFAULT_CROP_MARKER: fn() -> String = || "…".to_string();
 pub const DEFAULT_HIGHLIGHT_PRE_TAG: fn() -> String = || "<em>".to_string();
 pub const DEFAULT_HIGHLIGHT_POST_TAG: fn() -> String = || "</em>".to_string();
 pub const DEFAULT_SEMANTIC_RATIO: fn() -> SemanticRatio = || SemanticRatio(0.5);
+pub const INCLUDE_METADATA_HEADER: &str = "Meili-Include-Metadata";
+
+#[derive(Clone, Default, PartialEq, Deserr, ToSchema, Debug)]
+#[deserr(error = DeserrJsonError<InvalidSearchPersonalize>, rename_all = camelCase, deny_unknown_fields)]
+pub struct Personalize {
+    #[deserr(default, error = DeserrJsonError<InvalidSearchPersonalizeUserContext>)]
+    pub user_context: Option<String>,
+}
 
 #[derive(Clone, Default, PartialEq, Deserr, ToSchema)]
 #[deserr(error = DeserrJsonError, rename_all = camelCase, deny_unknown_fields)]
@@ -120,6 +129,8 @@ pub struct SearchQuery {
     pub ranking_score_threshold: Option<RankingScoreThreshold>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchLocales>)]
     pub locales: Option<Vec<Locale>>,
+    #[deserr(default, error = DeserrJsonError<InvalidSearchPersonalize>, default)]
+    pub personalize: Option<Personalize>,
 }
 
 impl From<SearchParameters> for SearchQuery {
@@ -167,6 +178,7 @@ impl From<SearchParameters> for SearchQuery {
             highlight_post_tag: DEFAULT_HIGHLIGHT_POST_TAG(),
             crop_marker: DEFAULT_CROP_MARKER(),
             locales: None,
+            personalize: None,
         }
     }
 }
@@ -248,6 +260,7 @@ impl fmt::Debug for SearchQuery {
             attributes_to_search_on,
             ranking_score_threshold,
             locales,
+            personalize,
         } = self;
 
         let mut debug = f.debug_struct("SearchQuery");
@@ -336,6 +349,10 @@ impl fmt::Debug for SearchQuery {
             debug.field("locales", &locales);
         }
 
+        if let Some(personalize) = personalize {
+            debug.field("personalize", &personalize);
+        }
+
         debug.finish()
     }
 }
@@ -541,6 +558,9 @@ pub struct SearchQueryWithIndex {
     pub ranking_score_threshold: Option<RankingScoreThreshold>,
     #[deserr(default, error = DeserrJsonError<InvalidSearchLocales>, default)]
     pub locales: Option<Vec<Locale>>,
+    #[deserr(default, error = DeserrJsonError<InvalidSearchPersonalize>, default)]
+    #[serde(skip)]
+    pub personalize: Option<Personalize>,
 
     #[deserr(default)]
     pub federation_options: Option<FederationOptions>,
@@ -598,6 +618,7 @@ impl SearchQueryWithIndex {
             attributes_to_search_on,
             ranking_score_threshold,
             locales,
+            personalize,
         } = query;
 
         SearchQueryWithIndex {
@@ -629,6 +650,7 @@ impl SearchQueryWithIndex {
             attributes_to_search_on,
             ranking_score_threshold,
             locales,
+            personalize,
             federation_options,
         }
     }
@@ -664,6 +686,7 @@ impl SearchQueryWithIndex {
             hybrid,
             ranking_score_threshold,
             locales,
+            personalize,
         } = self;
         (
             index_uid,
@@ -695,6 +718,7 @@ impl SearchQueryWithIndex {
                 hybrid,
                 ranking_score_threshold,
                 locales,
+                personalize,
                 // do not use ..Default::default() here,
                 // rather add any missing field from `SearchQuery` to `SearchQueryWithIndex`
             },
@@ -835,6 +859,18 @@ pub struct SearchHit {
     pub ranking_score_details: Option<serde_json::Map<String, serde_json::Value>>,
 }
 
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)]
+#[serde(rename_all = "camelCase")]
+#[schema(rename_all = "camelCase")]
+pub struct SearchMetadata {
+    pub query_uid: Uuid,
+    pub index_uid: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub primary_key: Option<String>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub remote: Option<String>,
+}
+
 #[derive(Serialize, Clone, PartialEq, ToSchema)]
 #[serde(rename_all = "camelCase")]
 #[schema(rename_all = "camelCase")]
@@ -851,6 +887,10 @@ pub struct SearchResult {
     pub facet_distribution: Option<BTreeMap<String, IndexMap<String, u64>>>,
     #[serde(skip_serializing_if = "Option::is_none")]
     pub facet_stats: Option<BTreeMap<String, FacetStats>>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub request_uid: Option<Uuid>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub metadata: Option<SearchMetadata>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub semantic_hit_count: Option<u32>,
@@ -872,6 +912,8 @@ impl fmt::Debug for SearchResult {
             hits_info,
             facet_distribution,
             facet_stats,
+            request_uid,
+            metadata,
             semantic_hit_count,
             degraded,
             used_negative_operator,
@@ -901,6 +943,12 @@ impl fmt::Debug for SearchResult {
         if let Some(semantic_hit_count) = semantic_hit_count {
             debug.field("semantic_hit_count", &semantic_hit_count);
         }
+        if let Some(request_uid) = request_uid {
+            debug.field("request_uid", &request_uid);
+        }
+        if let Some(metadata) = metadata {
+            debug.field("metadata", &metadata);
+        }
 
         debug.finish()
     }
@@ -925,7 +973,7 @@ pub struct SearchResultWithIndex {
     pub result: SearchResult,
 }
 
-#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, Eq, ToSchema)]
+#[derive(Serialize, Deserialize, Debug, Clone, PartialEq, ToSchema)]
 #[serde(untagged)]
 pub enum HitsInfo {
     #[serde(rename_all = "camelCase")]
@@ -1113,15 +1161,28 @@ pub fn prepare_search<'t>(
     Ok((search, is_finite_pagination, max_total_hits, offset))
 }
 
-pub fn perform_search(
-    index_uid: String,
-    index: &Index,
-    query: SearchQuery,
-    search_kind: SearchKind,
-    retrieve_vectors: RetrieveVectors,
-    features: RoFeatures,
-) -> Result<SearchResult, ResponseError> {
+pub struct SearchParams {
+    pub index_uid: String,
+    pub query: SearchQuery,
+    pub search_kind: SearchKind,
+    pub retrieve_vectors: RetrieveVectors,
+    pub features: RoFeatures,
+    pub request_uid: Uuid,
+    pub include_metadata: bool,
+}
+
+pub fn perform_search(params: SearchParams, index: &Index) -> Result<SearchResult, ResponseError> {
+    let SearchParams {
+        index_uid,
+        query,
+        search_kind,
+        retrieve_vectors,
+        features,
+        request_uid,
+        include_metadata,
+    } = params;
     let before_search = Instant::now();
+    let index_uid_for_metadata = index_uid.clone();
     let rtxn = index.read_txn()?;
     let time_budget = match index.search_cutoff(&rtxn)? {
         Some(cutoff) => TimeBudget::new(Duration::from_millis(cutoff)),
@@ -1142,7 +1203,20 @@ pub fn perform_search(
             query_vector,
         },
         semantic_hit_count,
-    ) = search_from_kind(index_uid, search_kind, search)?;
+    ) = search_from_kind(index_uid.clone(), search_kind, search)?;
+
+    let metadata = if include_metadata {
+        let query_uid = Uuid::now_v7();
+        let primary_key = index.primary_key(&rtxn)?.map(|pk| pk.to_string());
+        Some(SearchMetadata {
+            query_uid,
+            index_uid: index_uid_for_metadata,
+            primary_key,
+            remote: None, // Local searches don't have a remote
+        })
+    } else {
+        None
+    };
 
     let SearchQuery {
         q,
@@ -1174,6 +1248,7 @@ pub fn perform_search(
         attributes_to_search_on: _,
         filter: _,
         distinct: _,
+        personalize: _,
     } = query;
 
     let format = AttributesFormat {
@@ -1225,7 +1300,6 @@ pub fn perform_search(
         .transpose()?
         .map(|ComputedFacets { distribution, stats }| (distribution, stats))
         .unzip();
-
     let result = SearchResult {
         hits: documents,
         hits_info,
@@ -1237,6 +1311,8 @@ pub fn perform_search(
         degraded,
         used_negative_operator,
         semantic_hit_count,
+        request_uid: Some(request_uid),
+        metadata,
     };
     Ok(result)
 }
@@ -2080,7 +2156,7 @@ pub(crate) fn parse_filter(
     facets: &Value,
     filter_parsing_error_code: Code,
     features: RoFeatures,
-) -> Result<Option<Filter>, ResponseError> {
+) -> Result<Option<Filter<'_>>, ResponseError> {
     let filter = match facets {
         Value::String(expr) => Filter::from_str(expr).map_err(|e| e.into()),
         Value::Array(arr) => parse_filter_array(arr).map_err(|e| e.into()),
@@ -2117,7 +2193,7 @@ pub(crate) fn parse_filter(
     Ok(filter)
 }
 
-fn parse_filter_array(arr: &[Value]) -> Result<Option<Filter>, MeilisearchHttpError> {
+fn parse_filter_array(arr: &'_ [Value]) -> Result<Option<Filter<'_>>, MeilisearchHttpError> {
     let mut ands = Vec::new();
     for value in arr {
         match value {

crates/meilisearch/src/search_queue.rs

@@ -13,9 +13,9 @@
 //! What is going to happen at this point is that you're going to send a oneshot::Sender over an async mpsc channel.
 //! Then, the queue/scheduler is going to either:
 //! - Drop your oneshot channel => that means there are too many searches going on, and yours won't be executed.
-//!                                You should exit and free all the RAM you use ASAP.
+//!   You should exit and free all the RAM you use ASAP.
 //! - Sends you a Permit => that will unlock the method, and you will be able to process your search.
-//!                         And should drop the Permit only once you have freed all the RAM consumed by the method.
+//!   And should drop the Permit only once you have freed all the RAM consumed by the method.
 
 use std::num::NonZeroUsize;
 use std::sync::atomic::{AtomicUsize, Ordering};

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`, `export`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`, `*.get`, `webhooks.get`, `webhooks.update`, `webhooks.delete`, `webhooks.create`, `webhooks.*`",
+      "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`, `export`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`, `*.get`, `webhooks.get`, `webhooks.update`, `webhooks.delete`, `webhooks.create`, `webhooks.*`, `indexes.compact`",
       "code": "invalid_api_key_actions",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_api_key_actions"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]

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`, `export`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`, `*.get`, `webhooks.get`, `webhooks.update`, `webhooks.delete`, `webhooks.create`, `webhooks.*`",
+      "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`, `export`, `network.get`, `network.update`, `chatCompletions`, `chats.*`, `chats.get`, `chats.delete`, `chatsSettings.*`, `chatsSettings.get`, `chatsSettings.update`, `*.get`, `webhooks.get`, `webhooks.update`, `webhooks.delete`, `webhooks.create`, `webhooks.*`, `indexes.compact`",
       "code": "invalid_api_key_actions",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_api_key_actions"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]

crates/meilisearch/tests/auth/tenant_token_multi_search.rs

@@ -1040,7 +1040,7 @@ async fn error_single_search_forbidden_token() {
     ];
 
     let failed_query_indexes: Vec<_> =
-        std::iter::repeat(Some(0)).take(5).chain(std::iter::repeat(None).take(6)).collect();
+        std::iter::repeat_n(Some(0), 5).chain(std::iter::repeat_n(None, 6)).collect();
 
     let failed_query_indexes = vec![failed_query_indexes; ACCEPTED_KEYS_SINGLE.len()];
 
@@ -1118,10 +1118,9 @@ async fn error_multi_search_forbidden_token() {
         },
     ];
 
-    let failed_query_indexes: Vec<_> = std::iter::repeat(Some(0))
-        .take(5)
-        .chain(std::iter::repeat(Some(1)).take(5))
-        .chain(std::iter::repeat(None).take(6))
+    let failed_query_indexes: Vec<_> = std::iter::repeat_n(Some(0), 5)
+        .chain(std::iter::repeat_n(Some(1), 5))
+        .chain(std::iter::repeat_n(None, 6))
         .collect();
 
     let failed_query_indexes = vec![failed_query_indexes; ACCEPTED_KEYS_BOTH.len()];

crates/meilisearch/tests/batches/errors.rs

@@ -40,14 +40,14 @@ async fn batch_bad_types() {
 
     let (response, code) = server.batches_filter("types=doggo").await;
     snapshot!(code, @"400 Bad Request");
-    snapshot!(json_string!(response), @r#"
+    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`, `export`, `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`, `indexCompaction`.",
       "code": "invalid_task_types",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_task_types"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]

crates/meilisearch/tests/common/index.rs

@@ -516,6 +516,18 @@ impl<State> Index<'_, State> {
         self.service.post_encoded(url, query, self.encoder).await
     }
 
+    pub async fn search_with_headers(
+        &self,
+        query: Value,
+        headers: Vec<(&str, &str)>,
+    ) -> (Value, StatusCode) {
+        let url = format!("/indexes/{}/search", urlencode(self.uid.as_ref()));
+        let body = serde_json::to_string(&query).unwrap();
+        let mut all_headers = vec![("content-type", "application/json")];
+        all_headers.extend(headers);
+        self.service.post_str(url, body, all_headers).await
+    }
+
     pub async fn search_get(&self, query: &str) -> (Value, StatusCode) {
         let url = format!("/indexes/{}/search{}", urlencode(self.uid.as_ref()), query);
         self.service.get(url).await

crates/meilisearch/tests/common/mod.rs

@@ -522,6 +522,26 @@ pub async fn shared_index_with_geo_documents() -> &'static Index<'static, Shared
         .await
 }
 
+pub async fn shared_index_geojson_documents() -> &'static Index<'static, Shared> {
+    static INDEX: OnceCell<Index<'static, Shared>> = OnceCell::const_new();
+    INDEX
+        .get_or_init(|| async {
+            // Retrieved from https://gitlab-forge.din.developpement-durable.gouv.fr/pub/geomatique/descartes/d-map/-/blob/main/demo/examples/commons/countries.geojson?ref_type=heads
+            let server = Server::new_shared();
+            let index = server._index("SHARED_GEOJSON_DOCUMENTS").to_shared();
+            let countries = include_str!("../documents/geojson/assets/countries.json");
+            let lille = serde_json::from_str::<serde_json::Value>(countries).unwrap();
+            let (response, _code) = index._add_documents(Value(lille), Some("name")).await;
+            server.wait_task(response.uid()).await.succeeded();
+
+            let (response, _code) =
+                index._update_settings(json!({"filterableAttributes": ["_geojson"]})).await;
+            server.wait_task(response.uid()).await.succeeded();
+            index
+        })
+        .await
+}
+
 pub async fn shared_index_for_fragments() -> Index<'static, Shared> {
     static INDEX: OnceCell<(Server<Shared>, String)> = OnceCell::const_new();
     let (server, uid) = INDEX

crates/meilisearch/tests/common/server.rs

@@ -390,6 +390,17 @@ impl<State> Server<State> {
         self.service.post("/multi-search", queries).await
     }
 
+    pub async fn multi_search_with_headers(
+        &self,
+        queries: Value,
+        headers: Vec<(&str, &str)>,
+    ) -> (Value, StatusCode) {
+        let body = serde_json::to_string(&queries).unwrap();
+        let mut all_headers = vec![("content-type", "application/json")];
+        all_headers.extend(headers);
+        self.service.post_str("/multi-search", body, all_headers).await
+    }
+
     pub async fn list_indexes_raw(&self, parameters: &str) -> (Value, StatusCode) {
         self.service.get(format!("/indexes{parameters}")).await
     }
@@ -490,6 +501,8 @@ pub fn default_settings(dir: impl AsRef<Path>) -> Opt {
             max_indexing_threads: MaxThreads::from_str("2").unwrap(),
             experimental_no_edition_2024_for_settings: false,
             experimental_no_edition_2024_for_dumps: false,
+            experimental_no_edition_2024_for_prefix_post_processing: false,
+            experimental_no_edition_2024_for_facet_post_processing: false,
         },
         experimental_enable_metrics: false,
         ..Parser::parse_from(None as Option<&str>)

crates/meilisearch/tests/documents/add_documents.rs

@@ -1,6 +1,3 @@
-use crate::common::encoder::Encoder;
-use crate::common::{default_settings, GetAllDocumentsOptions, Server, Value};
-use crate::json;
 use actix_web::test;
 use meili_snap::{json_string, snapshot};
 use meilisearch::Opt;
@@ -8,6 +5,10 @@ use time::format_description::well_known::Rfc3339;
 use time::OffsetDateTime;
 use uuid::Uuid;
 
+use crate::common::encoder::Encoder;
+use crate::common::{default_settings, GetAllDocumentsOptions, Server, Value};
+use crate::json;
+
 /// This is the basic usage of our API and every other tests uses the content-type application/json
 #[actix_rt::test]
 async fn add_documents_test_json_content_types() {
@@ -1852,7 +1853,7 @@ async fn add_documents_with_geo_field() {
         .await;
     snapshot!(code, @"200 OK");
     // we are expecting docs 4 and 3 first as they have geo
-    snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }),
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }),
     @r###"
     {
       "hits": [
@@ -1884,7 +1885,8 @@ async fn add_documents_with_geo_field() {
       "processingTimeMs": "[time]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 4
+      "estimatedTotalHits": 4,
+      "requestUid": "[uuid]"
     }
     "###);
 }
@@ -1939,7 +1941,7 @@ async fn update_documents_with_geo_field() {
     let (response, code) = index.search_post(json!({"sort": ["_geoPoint(10,0):asc"]})).await;
     snapshot!(code, @"200 OK");
     // we are expecting docs 4 and 3 first as they have geo
-    snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }),
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }),
     @r###"
     {
       "hits": [
@@ -1971,7 +1973,8 @@ async fn update_documents_with_geo_field() {
       "processingTimeMs": "[time]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 4
+      "estimatedTotalHits": 4,
+      "requestUid": "[uuid]"
     }
     "###);
 
@@ -2043,7 +2046,7 @@ async fn update_documents_with_geo_field() {
     let (response, code) = index.search_post(json!({"sort": ["_geoPoint(10,0):asc"]})).await;
     snapshot!(code, @"200 OK");
     // the search response should not have changed: we are expecting docs 4 and 3 first as they have geo
-    snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }),
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }),
     @r###"
     {
       "hits": [
@@ -2076,7 +2079,8 @@ async fn update_documents_with_geo_field() {
       "processingTimeMs": "[time]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 4
+      "estimatedTotalHits": 4,
+      "requestUid": "[uuid]"
     }
     "###);
 }

crates/meilisearch/tests/documents/errors.rs

@@ -134,14 +134,14 @@ async fn get_all_documents_bad_filter() {
 
     let (response, code) = index.get_all_documents_raw("?filter=doggo").await;
     snapshot!(code, @"400 Bad Request");
-    snapshot!(json_string!(response), @r###"
+    snapshot!(json_string!(response), @r#"
     {
-      "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `doggo`.\n1:6 doggo",
+      "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `doggo`.\n1:6 doggo",
       "code": "invalid_document_filter",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_document_filter"
     }
-    "###);
+    "#);
 
     let (response, code) = index.get_all_documents_raw("?filter=doggo=bernese").await;
     snapshot!(code, @"400 Bad Request");
@@ -523,14 +523,14 @@ async fn delete_document_by_filter() {
     // send bad filter
     let (response, code) = index.delete_document_by_filter(json!({ "filter": "hello"})).await;
     snapshot!(code, @"400 Bad Request");
-    snapshot!(response, @r###"
+    snapshot!(response, @r#"
     {
-      "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `hello`.\n1:6 hello",
+      "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `hello`.\n1:6 hello",
       "code": "invalid_document_filter",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_document_filter"
     }
-    "###);
+    "#);
 
     // send empty filter
     let (response, code) = index.delete_document_by_filter(json!({ "filter": ""})).await;
@@ -724,14 +724,14 @@ async fn fetch_document_by_filter() {
 
     let (response, code) = index.fetch_documents(json!({ "filter": "cool doggo" })).await;
     snapshot!(code, @"400 Bad Request");
-    snapshot!(response, @r###"
+    snapshot!(response, @r#"
     {
-      "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `cool doggo`.\n1:11 cool doggo",
+      "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `cool doggo`.\n1:11 cool doggo",
       "code": "invalid_document_filter",
       "type": "invalid_request",
       "link": "https://docs.meilisearch.com/errors#invalid_document_filter"
     }
-    "###);
+    "#);
 
     let (response, code) = index.fetch_documents(json!({ "filter": "doggo = bernese" })).await;
     snapshot!(code, @"400 Bad Request");

crates/meilisearch/tests/documents/geojson/assets/lille.geojson

@@ -0,0 +1,547 @@
+{
+    "type": "Polygon",
+    "coordinates": [
+      [
+        [
+          3.11681,
+          50.63646
+        ],
+        [
+          3.11945,
+          50.63488
+        ],
+        [
+          3.12134,
+          50.63504
+        ],
+        [
+          3.12064,
+          50.63127
+        ],
+        [
+          3.12203,
+          50.62785
+        ],
+        [
+          3.12389,
+          50.6262
+        ],
+        [
+          3.12161,
+          50.62358
+        ],
+        [
+          3.12547,
+          50.62114
+        ],
+        [
+          3.12447,
+          50.61874
+        ],
+        [
+          3.12288,
+          50.61988
+        ],
+        [
+          3.12054,
+          50.61846
+        ],
+        [
+          3.11846,
+          50.61754
+        ],
+        [
+          3.11482,
+          50.6207
+        ],
+        [
+          3.11232,
+          50.6188
+        ],
+        [
+          3.10936,
+          50.61727
+        ],
+        [
+          3.10822,
+          50.61765
+        ],
+        [
+          3.10603,
+          50.61536
+        ],
+        [
+          3.1041,
+          50.61596
+        ],
+        [
+          3.10017,
+          50.6186
+        ],
+        [
+          3.09688,
+          50.61714
+        ],
+        [
+          3.09575,
+          50.61795
+        ],
+        [
+          3.0891,
+          50.61532
+        ],
+        [
+          3.08625,
+          50.61792
+        ],
+        [
+          3.07948,
+          50.61428
+        ],
+        [
+          3.07146,
+          50.6066
+        ],
+        [
+          3.06819,
+          50.60918
+        ],
+        [
+          3.06502,
+          50.61046
+        ],
+        [
+          3.06223,
+          50.61223
+        ],
+        [
+          3.05925,
+          50.60659
+        ],
+        [
+          3.05463,
+          50.60077
+        ],
+        [
+          3.04906,
+          50.6008
+        ],
+        [
+          3.04726,
+          50.6035
+        ],
+        [
+          3.04328,
+          50.60667
+        ],
+        [
+          3.04155,
+          50.60417
+        ],
+        [
+          3.03767,
+          50.60456
+        ],
+        [
+          3.03528,
+          50.60538
+        ],
+        [
+          3.03239,
+          50.60725
+        ],
+        [
+          3.0254,
+          50.6111
+        ],
+        [
+          3.02387,
+          50.6125
+        ],
+        [
+          3.0248,
+          50.61344
+        ],
+        [
+          3.02779,
+          50.61418
+        ],
+        [
+          3.02414,
+          50.6169
+        ],
+        [
+          3.02312,
+          50.61975
+        ],
+        [
+          3.02172,
+          50.62082
+        ],
+        [
+          3.01953,
+          50.62484
+        ],
+        [
+          3.01811,
+          50.62529
+        ],
+        [
+          3.01313,
+          50.62558
+        ],
+        [
+          3.01385,
+          50.62695
+        ],
+        [
+          3.00844,
+          50.62717
+        ],
+        [
+          3.0056,
+          50.6267
+        ],
+        [
+          3.00229,
+          50.62557
+        ],
+        [
+          3.00119,
+          50.62723
+        ],
+        [
+          2.99769,
+          50.62901
+        ],
+        [
+          2.99391,
+          50.62732
+        ],
+        [
+          2.98971,
+          50.63036
+        ],
+        [
+          2.9862,
+          50.63328
+        ],
+        [
+          2.98178,
+          50.63404
+        ],
+        [
+          2.97917,
+          50.63499
+        ],
+        [
+          2.97284,
+          50.63429
+        ],
+        [
+          2.97174,
+          50.63365
+        ],
+        [
+          2.97002,
+          50.63366
+        ],
+        [
+          2.96956,
+          50.63506
+        ],
+        [
+          2.97046,
+          50.6365
+        ],
+        [
+          2.96878,
+          50.63833
+        ],
+        [
+          2.97039,
+          50.6395
+        ],
+        [
+          2.97275,
+          50.64183
+        ],
+        [
+          2.97225,
+          50.64381
+        ],
+        [
+          2.9745,
+          50.64442
+        ],
+        [
+          2.97474,
+          50.64648
+        ],
+        [
+          2.97091,
+          50.65108
+        ],
+        [
+          2.96975,
+          50.65361
+        ],
+        [
+          2.97061,
+          50.65513
+        ],
+        [
+          2.96929,
+          50.65739
+        ],
+        [
+          2.97072,
+          50.6581
+        ],
+        [
+          2.97973,
+          50.66048
+        ],
+        [
+          2.98369,
+          50.66123
+        ],
+        [
+          2.9865,
+          50.65959
+        ],
+        [
+          2.9896,
+          50.65845
+        ],
+        [
+          2.9963,
+          50.65666
+        ],
+        [
+          2.99903,
+          50.65552
+        ],
+        [
+          3.00274,
+          50.65235
+        ],
+        [
+          3.00714,
+          50.64887
+        ],
+        [
+          3.01088,
+          50.64845
+        ],
+        [
+          3.01318,
+          50.64541
+        ],
+        [
+          3.01974,
+          50.63972
+        ],
+        [
+          3.02317,
+          50.63813
+        ],
+        [
+          3.02639,
+          50.63613
+        ],
+        [
+          3.029,
+          50.63521
+        ],
+        [
+          3.03414,
+          50.6382
+        ],
+        [
+          3.03676,
+          50.63888
+        ],
+        [
+          3.03686,
+          50.64147
+        ],
+        [
+          3.03791,
+          50.64379
+        ],
+        [
+          3.0409,
+          50.64577
+        ],
+        [
+          3.04582,
+          50.64807
+        ],
+        [
+          3.05132,
+          50.64866
+        ],
+        [
+          3.05055,
+          50.64949
+        ],
+        [
+          3.05244,
+          50.65055
+        ],
+        [
+          3.05784,
+          50.64927
+        ],
+        [
+          3.0596,
+          50.65105
+        ],
+        [
+          3.06414,
+          50.65041
+        ],
+        [
+          3.06705,
+          50.64936
+        ],
+        [
+          3.07023,
+          50.64706
+        ],
+        [
+          3.07203,
+          50.64355
+        ],
+        [
+          3.07526,
+          50.64188
+        ],
+        [
+          3.0758,
+          50.64453
+        ],
+        [
+          3.07753,
+          50.64381
+        ],
+        [
+          3.07861,
+          50.64542
+        ],
+        [
+          3.08299,
+          50.64725
+        ],
+        [
+          3.08046,
+          50.64912
+        ],
+        [
+          3.08349,
+          50.65082
+        ],
+        [
+          3.08354,
+          50.65155
+        ],
+        [
+          3.08477,
+          50.65312
+        ],
+        [
+          3.08542,
+          50.65654
+        ],
+        [
+          3.08753,
+          50.65687
+        ],
+        [
+          3.09032,
+          50.65602
+        ],
+        [
+          3.09018,
+          50.65142
+        ],
+        [
+          3.09278,
+          50.65086
+        ],
+        [
+          3.09402,
+          50.64982
+        ],
+        [
+          3.09908,
+          50.65146
+        ],
+        [
+          3.10316,
+          50.65227
+        ],
+        [
+          3.09726,
+          50.64723
+        ],
+        [
+          3.09387,
+          50.64358
+        ],
+        [
+          3.09357,
+          50.64095
+        ],
+        [
+          3.09561,
+          50.64133
+        ],
+        [
+          3.09675,
+          50.64018
+        ],
+        [
+          3.09454,
+          50.63891
+        ],
+        [
+          3.09627,
+          50.63693
+        ],
+        [
+          3.09795,
+          50.63713
+        ],
+        [
+          3.09919,
+          50.63576
+        ],
+        [
+          3.10324,
+          50.6351
+        ],
+        [
+          3.10613,
+          50.63532
+        ],
+        [
+          3.10649,
+          50.63434
+        ],
+        [
+          3.1109,
+          50.63525
+        ],
+        [
+          3.11502,
+          50.63504
+        ],
+        [
+          3.11681,
+          50.63646
+        ]
+      ]
+    ]
+  }

crates/meilisearch/tests/documents/geojson/mod.rs

@@ -0,0 +1,421 @@
+use meili_snap::{json_string, snapshot};
+
+use crate::common::{shared_index_geojson_documents, Server};
+use crate::json;
+
+const LILLE: &str = include_str!("assets/lille.geojson");
+
+#[actix_rt::test]
+async fn basic_add_settings_and_geojson_documents() {
+    let server = Server::new_shared();
+    let index = server.unique_index();
+    let (task, _status_code) =
+        index.update_settings(json!({"filterableAttributes": ["_geojson"]})).await;
+    server.wait_task(task.uid()).await.succeeded();
+
+    let (response, _) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }),
+    @r###"
+    {
+      "hits": [],
+      "query": "",
+      "processingTimeMs": "[duration]",
+      "limit": 20,
+      "offset": 0,
+      "estimatedTotalHits": 0,
+      "requestUid": "[uuid]"
+    }
+    "###);
+
+    let lille: serde_json::Value = serde_json::from_str(LILLE).unwrap();
+    let documents = json!([
+        {
+            "id": "missing",
+        },
+        {
+            "id": "point",
+            "_geojson": { "type": "Point", "coordinates": [1, 1] },
+        },
+        {
+            "id": "lille",
+            "_geojson": lille,
+        },
+    ]);
+
+    let (task, _status_code) = index.add_documents(documents, None).await;
+    let response = server.wait_task(task.uid()).await.succeeded();
+    snapshot!(json_string!(response, { ".uid" => "[uid]", ".batchUid" => "[batch_uid]", ".duration" => "[duration]", ".enqueuedAt" => "[date]", ".startedAt" => "[date]", ".finishedAt" => "[date]" }),
+        @r#"
+    {
+      "uid": "[uid]",
+      "batchUid": "[batch_uid]",
+      "indexUid": "[uuid]",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 3,
+        "indexedDocuments": 3
+      },
+      "error": null,
+      "duration": "[duration]",
+      "enqueuedAt": "[date]",
+      "startedAt": "[date]",
+      "finishedAt": "[date]"
+    }
+    "#);
+
+    let (response, code) = index.get_all_documents_raw("?ids=missing,point").await;
+
+    snapshot!(code, @"200 OK");
+    snapshot!(response,
+    @r#"
+    {
+      "results": [
+        {
+          "id": "missing"
+        },
+        {
+          "id": "point",
+          "_geojson": {
+            "type": "Point",
+            "coordinates": [
+              1,
+              1
+            ]
+          }
+        }
+      ],
+      "offset": 0,
+      "limit": 20,
+      "total": 2
+    }
+    "#);
+
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }),
+    @r###"
+    {
+      "hits": [
+        {
+          "id": "point",
+          "_geojson": {
+            "type": "Point",
+            "coordinates": [
+              1,
+              1
+            ]
+          }
+        }
+      ],
+      "query": "",
+      "processingTimeMs": "[duration]",
+      "limit": 20,
+      "offset": 0,
+      "estimatedTotalHits": 1,
+      "requestUid": "[uuid]"
+    }
+    "###);
+}
+
+#[actix_rt::test]
+async fn basic_add_geojson_documents_and_settings() {
+    let server = Server::new_shared();
+    let index = server.unique_index();
+
+    let lille: serde_json::Value = serde_json::from_str(LILLE).unwrap();
+    let documents = json!([
+        {
+            "id": "missing",
+        },
+        {
+            "id": "point",
+            "_geojson": { "type": "Point", "coordinates": [1, 1] },
+        },
+        {
+            "id": "lille",
+            "_geojson": lille,
+        },
+    ]);
+
+    let (task, _status_code) = index.add_documents(documents, None).await;
+    let response = server.wait_task(task.uid()).await.succeeded();
+    snapshot!(response,
+        @r#"
+    {
+      "uid": "[uid]",
+      "batchUid": "[batch_uid]",
+      "indexUid": "[uuid]",
+      "status": "succeeded",
+      "type": "documentAdditionOrUpdate",
+      "canceledBy": null,
+      "details": {
+        "receivedDocuments": 3,
+        "indexedDocuments": 3
+      },
+      "error": null,
+      "duration": "[duration]",
+      "enqueuedAt": "[date]",
+      "startedAt": "[date]",
+      "finishedAt": "[date]"
+    }
+    "#);
+
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    snapshot!(response,
+    @r#"
+    {
+      "message": "Index `[uuid]`: Attribute `_geojson` is not filterable. This index does not have configured filterable attributes.\n14:15 _geoPolygon([0,0],[0,2],[2,2],[2,0])",
+      "code": "invalid_search_filter",
+      "type": "invalid_request",
+      "link": "https://docs.meilisearch.com/errors#invalid_search_filter"
+    }
+    "#);
+
+    let (task, _status_code) =
+        index.update_settings(json!({"filterableAttributes": ["_geojson"]})).await;
+    server.wait_task(task.uid()).await.succeeded();
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }),
+    @r###"
+    {
+      "hits": [
+        {
+          "id": "point",
+          "_geojson": {
+            "type": "Point",
+            "coordinates": [
+              1,
+              1
+            ]
+          }
+        }
+      ],
+      "query": "",
+      "processingTimeMs": "[duration]",
+      "limit": 20,
+      "offset": 0,
+      "estimatedTotalHits": 1,
+      "requestUid": "[uuid]"
+    }
+    "###);
+}
+
+#[actix_rt::test]
+async fn add_and_remove_geojson() {
+    let server = Server::new_shared();
+    let index = server.unique_index();
+    index.update_settings(json!({"filterableAttributes": ["_geojson"]})).await;
+
+    let documents = json!([
+        {
+            "id": "missing",
+        },
+        {
+            "id": 0,
+            "_geojson": { "type": "Point", "coordinates": [1, 1] },
+        }
+    ]);
+    let (task, _status_code) = index.add_documents(documents, None).await;
+    server.wait_task(task.uid()).await.succeeded();
+    let (response, _code) =
+        index.search_get("?filter=_geoPolygon([0,0],[0,0.9],[0.9,0.9],[0.9,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 0);
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 1);
+
+    let (task, _) = index.delete_document(0).await;
+    server.wait_task(task.uid()).await.succeeded();
+    let (response, _code) =
+        index.search_get("?filter=_geoPolygon([0,0],[0,0.9],[0.9,0.9],[0.9,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 0);
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 0);
+
+    // add it back
+    let documents = json!([
+        {
+            "id": 0,
+            "_geojson": { "type": "Point", "coordinates": [1, 1] },
+        }
+    ]);
+    let (task, _status_code) = index.add_documents(documents, None).await;
+    server.wait_task(task.uid()).await.succeeded();
+    let (response, _code) =
+        index.search_get("?filter=_geoPolygon([0,0],[0,0.9],[0.9,0.9],[0.9,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 0);
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 1);
+}
+
+#[actix_rt::test]
+async fn partial_update_geojson() {
+    let server = Server::new_shared();
+    let index = server.unique_index();
+    let (task, _) = index.update_settings(json!({"filterableAttributes": ["_geojson"]})).await;
+    server.wait_task(task.uid()).await.succeeded();
+
+    let documents = json!([
+        {
+            "id": 0,
+            "_geojson": { "type": "Point", "coordinates": [1, 1] },
+        }
+    ]);
+    let (task, _status_code) = index.add_documents(documents, None).await;
+    server.wait_task(task.uid()).await.succeeded();
+    let (response, _code) =
+        index.search_get("?filter=_geoPolygon([0,0],[0,0.9],[0.9,0.9],[0.9,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 0);
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 1);
+
+    let documents = json!([
+        {
+            "id": 0,
+            "_geojson": { "type": "Point", "coordinates": [0.5, 0.5] },
+        }
+    ]);
+    let (task, _status_code) = index.update_documents(documents, None).await;
+    server.wait_task(task.uid()).await.succeeded();
+    let (response, _code) =
+        index.search_get("?filter=_geoPolygon([0,0],[0,0.9],[0.9,0.9],[0.9,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 1);
+    let (response, _code) = index.search_get("?filter=_geoPolygon([0,0],[0,2],[2,2],[2,0])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 1);
+    let (response, _code) =
+        index.search_get("?filter=_geoPolygon([0.9,0.9],[0.9,2],[2,2],[2,0.9])").await;
+    assert_eq!(response.get("hits").unwrap().as_array().unwrap().len(), 0);
+}
+
+#[actix_rt::test]
+async fn geo_bounding_box() {
+    let index = shared_index_geojson_documents().await;
+
+    // The bounding box is a polygon over middle Europe
+    let (response, code) =
+        index.search_get("?filter=_geoBoundingBox([50.53987503447863,21.43443989912143],[43.76393151539099,0.54979129195425])&attributesToRetrieve=name").await;
+    snapshot!(code, @"200 OK");
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
+    {
+      "hits": [
+        {
+          "name": "Austria"
+        },
+        {
+          "name": "Belgium"
+        },
+        {
+          "name": "Bosnia_and_Herzegovina"
+        },
+        {
+          "name": "Switzerland"
+        },
+        {
+          "name": "Czech_Republic"
+        },
+        {
+          "name": "Germany"
+        },
+        {
+          "name": "France"
+        },
+        {
+          "name": "Croatia"
+        },
+        {
+          "name": "Hungary"
+        },
+        {
+          "name": "Italy"
+        },
+        {
+          "name": "Luxembourg"
+        },
+        {
+          "name": "Netherlands"
+        },
+        {
+          "name": "Poland"
+        },
+        {
+          "name": "Romania"
+        },
+        {
+          "name": "Republic_of_Serbia"
+        },
+        {
+          "name": "Slovakia"
+        },
+        {
+          "name": "Slovenia"
+        }
+      ],
+      "query": "",
+      "processingTimeMs": "[duration]",
+      "limit": 20,
+      "offset": 0,
+      "estimatedTotalHits": 17,
+      "requestUid": "[uuid]"
+    }
+    "###);
+
+    // Between Russia and Alaska
+    let (response, code) = index
+        .search_get("?filter=_geoBoundingBox([70,-148],[63,152])&attributesToRetrieve=name")
+        .await;
+    snapshot!(code, @"200 OK");
+    snapshot!(json_string!(response, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
+    {
+      "hits": [
+        {
+          "name": "Canada"
+        },
+        {
+          "name": "Russia"
+        },
+        {
+          "name": "United_States_of_America"
+        }
+      ],
+      "query": "",
+      "processingTimeMs": "[duration]",
+      "limit": 20,
+      "offset": 0,
+      "estimatedTotalHits": 3,
+      "requestUid": "[uuid]"
+    }
+    "###);
+}
+
+#[actix_rt::test]
+async fn bug_5904() {
+    // https://github.com/meilisearch/meilisearch/issues/5904
+
+    let server = Server::new_shared();
+    let index = server.unique_index();
+    let (response, _code) =
+        index.update_settings(json!({"filterableAttributes": ["_geojson"]})).await;
+    server.wait_task(response.uid()).await.succeeded();
+
+    let geojson = json!({
+      "id": 1,
+      "_geojson": {
+        "type": "FeatureCollection",
+        "features": [
+          {
+            "type": "Feature",
+            "geometry": {
+              "type": "Point",
+              "coordinates": [
+                4.23914,
+                48.382893
+              ]
+            },
+            "properties": {}
+          }
+        ]
+      }
+    });
+    let (response, _code) = index.add_documents(geojson, Some("id")).await;
+    server.wait_task(response.uid()).await.succeeded();
+}

crates/meilisearch/tests/documents/mod.rs

@@ -1,5 +1,6 @@
 mod add_documents;
 mod delete_documents;
 mod errors;
+mod geojson;
 mod get_documents;
 mod update_documents;

crates/meilisearch/tests/index/update_index.rs

@@ -1,5 +1,4 @@
 use meili_snap::snapshot;
-
 use time::format_description::well_known::Rfc3339;
 use time::OffsetDateTime;
 

crates/meilisearch/tests/search/errors.rs

@@ -642,14 +642,14 @@ async fn filter_invalid_syntax_object() {
         &json!({"filterableAttributes": ["title"]}),
         &json!({"filter": "title & Glass"}),
         |response, code| {
-            snapshot!(response, @r###"
+            snapshot!(response, @r#"
             {
-              "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `title & Glass`.\n1:14 title & Glass",
+              "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `title & Glass`.\n1:14 title & Glass",
               "code": "invalid_search_filter",
               "type": "invalid_request",
               "link": "https://docs.meilisearch.com/errors#invalid_search_filter"
             }
-            "###);
+            "#);
             snapshot!(code, @"400 Bad Request");
         },
     )
@@ -663,14 +663,14 @@ async fn filter_invalid_syntax_array() {
         &json!({"filterableAttributes": ["title"]}),
         &json!({"filter": ["title & Glass"]}),
         |response, code| {
-            snapshot!(response, @r###"
+            snapshot!(response, @r#"
             {
-              "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, or `_geoBoundingBox` at `title & Glass`.\n1:14 title & Glass",
+              "message": "Was expecting an operation `=`, `!=`, `>=`, `>`, `<=`, `<`, `IN`, `NOT IN`, `TO`, `EXISTS`, `NOT EXISTS`, `IS NULL`, `IS NOT NULL`, `IS EMPTY`, `IS NOT EMPTY`, `CONTAINS`, `NOT CONTAINS`, `STARTS WITH`, `NOT STARTS WITH`, `_geoRadius`, `_geoBoundingBox` or `_geoPolygon` at `title & Glass`.\n1:14 title & Glass",
               "code": "invalid_search_filter",
               "type": "invalid_request",
               "link": "https://docs.meilisearch.com/errors#invalid_search_filter"
             }
-            "###);
+            "#);
             snapshot!(code, @"400 Bad Request");
         },
     )

crates/meilisearch/tests/search/filters.rs

@@ -742,7 +742,7 @@ async fn vector_filter_all_embedders() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -762,9 +762,10 @@ async fn vector_filter_all_embedders() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 4
+      "estimatedTotalHits": 4,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -839,7 +840,7 @@ async fn vector_filter_specific_embedder() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -859,9 +860,10 @@ async fn vector_filter_specific_embedder() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 4
+      "estimatedTotalHits": 4,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -874,7 +876,7 @@ async fn vector_filter_user_provided() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -885,9 +887,10 @@ async fn vector_filter_user_provided() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 1
+      "estimatedTotalHits": 1,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -900,7 +903,7 @@ async fn vector_filter_specific_fragment() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -914,9 +917,10 @@ async fn vector_filter_specific_fragment() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 2
+      "estimatedTotalHits": 2,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 
     let (value, _code) = index
         .search_post(json!({
@@ -924,7 +928,7 @@ async fn vector_filter_specific_fragment() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -941,9 +945,10 @@ async fn vector_filter_specific_fragment() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 3
+      "estimatedTotalHits": 3,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -976,16 +981,17 @@ async fn vector_filter_document_template_but_fragments_used() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [],
       "query": "",
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 0
+      "estimatedTotalHits": 0,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -1023,7 +1029,7 @@ async fn vector_filter_document_template() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -1040,9 +1046,10 @@ async fn vector_filter_document_template() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 3
+      "estimatedTotalHits": 3,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -1075,7 +1082,7 @@ async fn vector_filter_negation() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -1092,9 +1099,10 @@ async fn vector_filter_negation() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 3
+      "estimatedTotalHits": 3,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -1107,7 +1115,7 @@ async fn vector_filter_or_combination() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -1124,9 +1132,10 @@ async fn vector_filter_or_combination() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 3
+      "estimatedTotalHits": 3,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }
 
 #[actix_rt::test]
@@ -1139,7 +1148,7 @@ async fn vector_filter_regenerate() {
             "attributesToRetrieve": ["name"]
         }))
         .await;
-    snapshot!(value, @r#"
+    snapshot!(json_string!(value, { ".processingTimeMs" => "[duration]", ".requestUid" => "[uuid]" }), @r###"
     {
       "hits": [
         {
@@ -1156,7 +1165,8 @@ async fn vector_filter_regenerate() {
       "processingTimeMs": "[duration]",
       "limit": 20,
       "offset": 0,
-      "estimatedTotalHits": 3
+      "estimatedTotalHits": 3,
+      "requestUid": "[uuid]"
     }
-    "#);
+    "###);
 }

crates/meilisearch/tests/search/geo.rs

@@ -33,7 +33,7 @@ async fn geo_bounding_box_with_string_and_number() {
             }),
             |response, code| {
                 assert_eq!(code, 200, "{response}");
-                snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }), @r###"
+                snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }), @r###"
                 {
                   "hits": [
                     {
@@ -63,7 +63,8 @@ async fn geo_bounding_box_with_string_and_number() {
                   "processingTimeMs": "[time]",
                   "limit": 20,
                   "offset": 0,
-                  "estimatedTotalHits": 2
+                  "estimatedTotalHits": 2,
+                  "requestUid": "[uuid]"
                 }
                 "###);
             },
@@ -84,7 +85,7 @@ async fn bug_4640() {
             }),
             |response, code| {
                 assert_eq!(code, 200, "{response}");
-                snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }), @r###"
+                snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }), @r###"
                 {
                   "hits": [
                     {
@@ -123,7 +124,8 @@ async fn bug_4640() {
                   "processingTimeMs": "[time]",
                   "limit": 20,
                   "offset": 0,
-                  "estimatedTotalHits": 3
+                  "estimatedTotalHits": 3,
+                  "requestUid": "[uuid]"
                 }
                 "###);
             },
@@ -147,7 +149,7 @@ async fn geo_asc_with_words() {
         &json!({"q": "jean"}),
         |response, code| {
             assert_eq!(code, 200, "{response}");
-            snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }), @r###"
+            snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }), @r###"
             {
               "hits": [
                 {
@@ -179,7 +181,8 @@ async fn geo_asc_with_words() {
               "processingTimeMs": "[time]",
               "limit": 20,
               "offset": 0,
-              "estimatedTotalHits": 3
+              "estimatedTotalHits": 3,
+              "requestUid": "[uuid]"
             }
             "###);
         },
@@ -192,7 +195,7 @@ async fn geo_asc_with_words() {
         &json!({"q": "bob"}),
         |response, code| {
             assert_eq!(code, 200, "{response}");
-            snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }), @r###"
+            snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }), @r###"
             {
               "hits": [
                 {
@@ -216,7 +219,8 @@ async fn geo_asc_with_words() {
               "processingTimeMs": "[time]",
               "limit": 20,
               "offset": 0,
-              "estimatedTotalHits": 2
+              "estimatedTotalHits": 2,
+              "requestUid": "[uuid]"
             }
             "###);
         },
@@ -229,7 +233,7 @@ async fn geo_asc_with_words() {
         &json!({"q": "intel"}),
         |response, code| {
             assert_eq!(code, 200, "{response}");
-            snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }), @r###"
+            snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }), @r###"
             {
               "hits": [
                 {
@@ -245,7 +249,8 @@ async fn geo_asc_with_words() {
               "processingTimeMs": "[time]",
               "limit": 20,
               "offset": 0,
-              "estimatedTotalHits": 1
+              "estimatedTotalHits": 1,
+              "requestUid": "[uuid]"
             }
             "###);
         },
@@ -269,7 +274,7 @@ async fn geo_sort_with_words() {
       &json!({"q": "jean", "sort": ["_geoPoint(0.0, 0.0):asc"]}),
       |response, code| {
           assert_eq!(code, 200, "{response}");
-          snapshot!(json_string!(response, { ".processingTimeMs" => "[time]" }), @r###"
+          snapshot!(json_string!(response, { ".processingTimeMs" => "[time]", ".requestUid" => "[uuid]" }), @r###"
           {
             "hits": [
               {
@@ -304,7 +309,8 @@ async fn geo_sort_with_words() {
             "processingTimeMs": "[time]",
             "limit": 20,
             "offset": 0,
-            "estimatedTotalHits": 3
+            "estimatedTotalHits": 3,
+            "requestUid": "[uuid]"
           }
           "###);
       },