Document the x-modulus-hash exchange type

This commit adds documentation for the built-in `x-modulus-hash` exchange.
It adds a dedicated page explaining its core features: stable routing,
weighted routing, and how it compares to the consistent hash exchange.

It also adds a bullet point to the message ordering section in `queues.md`
to highlight the common use case of using `x-modulus-hash` with Single
Active Consumer (SAC) to process messages concurrently while preserving
order for each domain entity.

Docs for rabbitmq/rabbitmq-server#15849

Author: ansd

docs/exchanges.md

@@ -67,6 +67,7 @@ RabbitMQ ships with multiple exchange types:
  * Direct: covered in [tutorial 4](https://www.rabbitmq.com/tutorials)
  * Default direct exchange: a built-in direct exchange with special characteristics
  * [Local Random](./local-random-exchange)
+ * [Modulus Hash](./modulus-hash-exchange)
  * [JMS Topic](https://github.com/rabbitmq/rabbitmq-server/blob/main/deps/rabbitmq_jms_topic_exchange/README.md)
  * [Consistent Hashing exchange](https://github.com/rabbitmq/rabbitmq-server/tree/main/deps/rabbitmq_consistent_hash_exchange)
  * [Random exchange](https://github.com/rabbitmq/rabbitmq-server/tree/main/deps/rabbitmq_random_exchange)

docs/modulus-hash-exchange.md

@@ -0,0 +1,55 @@
+---
+title: Modulus Hash Exchange
+---
+<!--
+Copyright (c) 2005-2026 Broadcom. All Rights Reserved. The term "Broadcom" refers to Broadcom Inc. and/or its subsidiaries.
+
+All rights reserved. This program and the accompanying materials
+are made available under the terms of the under the Apache License,
+Version 2.0 (the "License”); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+https://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+-->
+
+# Modulus Hash Exchange
+
+## Overview {#overview}
+
+The `x-modulus-hash` exchange is a built-in exchange type in RabbitMQ that distributes messages across bound queues based on a hash of the routing key. It is designed to partition messages across a number of regular queues (shards) while guaranteeing stable routing.
+
+When a message is published to this exchange, it hashes the message's routing key and applies a `Hash mod N` operation to pick the destination queue, where `N` is the total number of bound destinations. 
+
+**Note:** This exchange ignores the values of the binding keys.
+
+## Stable Routing {#stable-routing}
+
+A key feature of the `x-modulus-hash` exchange is that it guarantees **stable routing**. As long as the bindings to the exchange remain the same, messages with the same routing key will always be routed to exactly the same destination queue, even across node restarts.
+
+This makes it an excellent choice for use cases where message ordering matters for a specific domain entity (e.g. an order ID), but you still want to process messages concurrently across multiple consumers.
+
+### Concurrent Processing with Message Ordering
+
+A common pattern is to bind `N` queues to an `x-modulus-hash` exchange and enable the [Single Active Consumer (SAC)](./consumers#single-active-consumer) feature on each queue. This provides:
+* **Message ordering:** Thanks to stable routing, all messages for a specific routing key end up in the same queue. SAC ensures they are processed in order.
+* **Concurrent consumption:** `N` application instances can process messages in parallel, each consuming from a different queue.
+* **Fault tolerance:** If an active consumer crashes, the broker will automatically deliver messages to another consumer attached to that queue.
+
+## Weighted Routing {#weighted-routing}
+
+The `x-modulus-hash` exchange also supports **weighted routing** implicitly. If a user binds the exact same queue `M` times to the same exchange instance (using different dummy binding keys, since the binding key is ignored for routing), the queue will have an `M / N` probability of receiving any given message. This allows you to easily distribute more load to specific queues if needed.
+
+## Comparison with Consistent Hash Exchange
+
+RabbitMQ also provides a [Consistent Hash Exchange](https://github.com/rabbitmq/rabbitmq-server/blob/main/deps/rabbitmq_consistent_hash_exchange/README.md) plugin. While both can partition messages based on routing keys, they have different trade-offs:
+
+* **Modulus Hash Exchange:** Simpler, built-in, and guarantees stable routing. However, if you add or remove queues (changing `N`), the routing for almost all keys will be reshuffled.
+* **Consistent Hash Exchange:** Requires enabling a plugin and manages a more complex hash ring. It minimizes reshuffling when queues are added or removed, making it better for dynamic topologies.
+
+If your topology is static and you need strict message ordering guarantees, the `x-modulus-hash` exchange is recommended.

docs/queues.md

@@ -251,6 +251,8 @@ To keep order with queues:
 * For quorum queues, set a [delivery limit](./quorum-queues#poison-message-handling).
   This ensures messages are requeued at the front of the queue.
 * AMQP 0-9-1: don’t use `basic.get`.  When stopping a consumer, prefer closing the [channel](./channels) over `basic.cancel`.
+* If you need to process messages concurrently while preserving order for each domain entity (e.g. per order ID), you can use the
+  [`x-modulus-hash` exchange](./modulus-hash-exchange) to partition messages across multiple queues, each with a single active consumer.
 
 ## Durability {#durability}
 

sidebarsDocs.js

@@ -171,6 +171,11 @@ const sidebars = {
               id: 'local-random-exchange',
               label: 'Local random exchange',
             },
+            {
+              type: 'doc',
+              id: 'modulus-hash-exchange',
+              label: 'Modulus hash exchange',
+            },
             {
               type: 'doc',
               id: 'connection-blocked',