Meilisearch Rust SDK

This example demonstrates a full-stack setup using async_graphql and actix-web for the GraphQL server, diesel for PostgreSQL database queries, and meilisearch-sdk to perform searches.

To run the example, you must first ensure a Meilisearch server is running. Then, execute the application using Cargo.

# 1. Start Meilisearch
meilisearch --master-key <your master key>

# 2. Run the application
cargo run --release

To use the meilisearch-sdk in your Rust project, add it to your Cargo.toml dependencies. The crate is async by default, so you will likely need an async runtime like tokio or the futures crate to block on async functions.

Optional dependencies:

• futures = "0.3": Useful if you are not using an async runtime and need to block on futures.
• serde = { version = "1.0", features = ["derive"] }: Highly recommended as most SDK features require serde for serialization/deserialization.

You can also enable the sync feature to make most structs Sync, though this may result in slightly slower performance.

[dependencies]
meilisearch-sdk = "0.33.0"

# Optional dependencies
futures = "0.3"
serde = { version = "1.0", features = ["derive"] }

Compile the Rust source files into WebAssembly for browser use. This command targets the web module and skips TypeScript generation. The resulting compiled files are placed in the examples/web_app/pkg directory.

wasm-pack build . --target=web --no-typescript

To build the web_app example, you must have wasm-pack installed. You can install it using the following shell command:

curl https://rustwasm.github.io/wasm-pack/installer/init.sh -sSf | sh

Because of browser security restrictions, you cannot open the compiled index.html file directly from the file system. You must serve the pkg directory using a web server.

To serve the application locally, navigate to the examples/web_app/pkg directory and run a local server (e.g., using Python):

```console
# Navigate to the pkg directory first
cd pkg
python3 -m http.server 8080

Then, access the application at http://localhost:8080/ in your browser.

To use filtering, you must first register the attributes you want to filter by using set_filterable_attributes. This is a one-time operation per index, but note that updating these settings triggers an index rebuild.

Once configured, you can apply filters using .with_filter("filter_expression") in your search query.

// 1. Configure filterable attributes (do this once)
let filterable_attributes = ["id", "genres"];
client.index("movies").set_filterable_attributes(&filterable_attributes).await.unwrap();

// 2. Perform the filtered search
let search_result = client.index("movies")
  .search()
  .with_query("wonder")
  .with_filter("id > 1 AND genres = Action")
  .execute::<Movie>()
  .await
  .unwrap();

println!("{:?}", search_result.hits);

The meilisearch_test macro simplifies writing Meilisearch integration tests by automating client initialization and index lifecycle management. It handles the boilerplate of creating a Client, creating a uniquely named Index for parallel test execution, and ensuring the index is deleted after the test completes.

To use it, annotate your async test function with #[meilisearch_test] and include the desired types (Client, Index, or String) in the function arguments. The macro will inject the initialized objects into your test.

#[meilisearch_test]
async fn test_get_tasks(index: Index, client: Client) -> Result<(), Error> {
  let tasks = index.get_tasks().await?;
  // Your test logic here
  Ok(())
}

The BatchStrategy enum indicates the reason why the Meilisearch autobatcher decided to stop accumulating tasks into a single batch and start processing it. This is useful for debugging performance and understanding how Meilisearch groups operations.

Available strategies:

• SizeLimitReached: The batch reached its configured size threshold.
• TimeLimitReached: The batch reached its configured time window threshold.
• Unknown: A placeholder for forward-compatibility with future Meilisearch versions.

When performing a similarity search, the API returns a SimilarResults<T> object containing metadata about the query and a list of hits. Each hit is wrapped in a SimilarResult<T>.

SimilarResults<T>

• hits: A vector of SimilarResult<T> objects.
• offset: The number of documents skipped.
• limit: The number of results returned.
• estimated_total_hits: Estimated total number of matches.
• performance_details: Performance trace of the query (if requested).
• processing_time_ms: Processing time of the query in milliseconds.
• id: Identifier of the target document used for the search.

SimilarResult<T>

• result: The actual document data of type T (flattened into the object).
• ranking_score: The global ranking score (_rankingScore), if requested.
• ranking_score_details: Detailed ranking score information (_rankingScoreDetails), if requested.