Merge pull request #1994 from qdrant/tiered-multitenancy

[v1.16] tiered multitenancy
2026-10-04 02:18:29 +02:00 · 2025-11-17 15:01:38 +01:00
parent 204164a406 37f4a7aedf
commit be24d900ef
61 changed files with 999 additions and 394 deletions
@@ -0,0 +1,2 @@
+This code snippet is used to create a collection with a User Defined Sharding (aka custom sharding) configured.
+Unlike default auto-sharding, that uses hash-based sharding strategy, user-defined sharding allows to create named Shards and route requests to specific Shards based on application-level logic.
@@ -0,0 +1,13 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+	collectionName: "{collection_name}",
+	// ... other collection parameters
+	shardNumber: 1,
+	shardingMethod: ShardingMethod.Custom
+);
+```
@@ -0,0 +1,19 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateCollection(context.Background(), &qdrant.CreateCollection{
+	CollectionName: "{collection_name}",
+	// ... other collection parameters
+	ShardNumber:    qdrant.PtrOf(uint32(1)),
+	ShardingMethod: qdrant.ShardingMethod_Custom.Enum(),
+})
+```
@@ -0,0 +1,8 @@
+```http
+PUT /collections/{collection_name}
+{
+    "shard_number": 1,
+    "sharding_method": "custom"
+    // ... other collection parameters
+}
+```
@@ -0,0 +1,21 @@
+```java
+import static io.qdrant.client.ShardKeyFactory.shardKey;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.ShardingMethod;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            // ... other collection parameters
+            .setShardNumber(1)
+            .setShardingMethod(ShardingMethod.Custom)
+            .build())
+    .get();
+```
@@ -0,0 +1,12 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    shard_number=1,
+    sharding_method=models.ShardingMethod.CUSTOM,
+    # ... other collection parameters
+)
+```
@@ -0,0 +1,17 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateCollectionBuilder, Distance, ShardingMethod, VectorParamsBuilder,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .vectors_config(VectorParamsBuilder::new(300, Distance::Cosine))
+            .shard_number(1)
+            .sharding_method(ShardingMethod::Custom.into()),
+    )
+    .await?;
+```
@@ -0,0 +1,11 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+    shard_number: 1,
+    sharding_method: "custom",
+    // ... other collection parameters
+});
+```
@@ -0,0 +1,5 @@
+This code snippet creates a named shard with the name "default" in a Qdrant collection.
+Collection is required to be configured with `custom` sharding method to support named shards.
+Once created, named shard will receive all requests that specify its name in the shard key selector.
+
+If no named shard is specified in the request, request will be broadcasted to all shards in the collection.
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateShardKeyAsync(
+    "{collection_name}",
+    new CreateShardKey { ShardKey = new ShardKey { Keyword = "default", } }
+    );
+```
@@ -0,0 +1,16 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateShardKey(context.Background(), "{collection_name}", &qdrant.CreateShardKey{
+	ShardKey: qdrant.NewShardKey("default"),
+})
+```
@@ -0,0 +1,6 @@
+```http
+PUT /collections/{collection_name}/shards
+{
+  "shard_key": "default"
+}
+```
@@ -0,0 +1,18 @@
+```java
+import static io.qdrant.client.ShardKeyFactory.shardKey;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateShardKey;
+import io.qdrant.client.grpc.Collections.CreateShardKeyRequest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createShardKeyAsync(CreateShardKeyRequest.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setRequest(CreateShardKey.newBuilder()
+                                .setShardKey(shardKey("default"))
+                                .build())
+                .build()).get();
+```
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_shard_key("{collection_name}", "default")
+```
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateShardKeyBuilder, CreateShardKeyRequestBuilder
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_shard_key(
+        CreateShardKeyRequestBuilder::new("{collection_name}")
+            .request(CreateShardKeyBuilder::default().shard_key("default".to_string())),
+    )
+    .await?;
+```
@@ -0,0 +1,9 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createShardKey("{collection_name}", {
+    shard_key: "default"
+});
+```
@@ -0,0 +1,5 @@
+This code snippet creates a named shard with the name "user_1" in a Qdrant collection.
+This shard is intended to be used as a dedicated shard for a specific tenant or user, allowing for better data isolation and management. Creation of the shard specifies initial state as `Partial`, as it needs to be populated with data before it can serve requests.
+
+Collection is required to be configured with `custom` sharding method to support named shards.
+Once created, named shard will receive all requests that specify its name in the shard key selector.
@@ -0,0 +1,14 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateShardKeyAsync(
+    "{collection_name}",
+    new CreateShardKey { 
+        ShardKey = new ShardKey { Keyword = "default" },
+        InitialState = ReplicaState.Partial
+    }
+);
+```
@@ -0,0 +1,21 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateShardKey(
+	context.Background(),
+	"{collection_name}",
+	&qdrant.CreateShardKey{
+		ShardKey: qdrant.NewShardKey("default"),
+		InitialState: qdrant.ReplicaState_PARTIAL,
+	}
+)
+```
@@ -0,0 +1,7 @@
+```http
+PUT /collections/{collection_name}/shards
+{
+  "shard_key": "user_1",
+  "initial_state": "Partial"
+}
+```
@@ -0,0 +1,20 @@
+```java
+import static io.qdrant.client.ShardKeyFactory.shardKey;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateShardKey;
+import io.qdrant.client.grpc.Collections.CreateShardKeyRequest;
+import io.qdrant.client.grpc.Collections.ReplicaState;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createShardKeyAsync(CreateShardKeyRequest.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setRequest(CreateShardKey.newBuilder()
+                                .setShardKey(shardKey("default"))
+                                .setInitialState(ReplicaState.PARTIAL)
+                                .build())
+                .build()).get();
+```
@@ -0,0 +1,11 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_shard_key(
+    "{collection_name}",
+    shard_key="user_1",
+    initial_state=models.ReplicaState.PARTIAL
+)
+```
@@ -0,0 +1,20 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateShardKeyBuilder, CreateShardKeyRequestBuilder
+};
+use qdrant_client::qdrant::ReplicaState;
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_shard_key(
+        CreateShardKeyRequestBuilder::new("{collection_name}")
+            .request(
+                CreateShardKeyBuilder::default()
+                    .shard_key("user_1".to_string())
+                    .initial_state(ReplicaState::Partial)
+            ),
+    )
+    .await?;
+```
@@ -0,0 +1,10 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createShardKey("{collection_name}", {
+    shard_key: "default",
+    initial_state: "Partial"
+});
+```
@@ -0,0 +1,5 @@
+This code snippet creates a named shard in a Qdrant collection.
+Collection is required to be configured with `custom` sharding method to support named shards.
+Once created, named shard will receive all requests that specify its name in the shard key selector.
+
+If no named shard is specified in the request, request will be broadcasted to all shards in the collection.
@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateShardKeyAsync(
+    "{collection_name}",
+    new CreateShardKey { ShardKey = new ShardKey { Keyword = "{shard_key}", } }
+    );
+```
@@ -0,0 +1,16 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.CreateShardKey(context.Background(), "{collection_name}", &qdrant.CreateShardKey{
+	ShardKey: qdrant.NewShardKey("{shard_key}"),
+})
+```
@@ -0,0 +1,6 @@
+```http
+PUT /collections/{collection_name}/shards
+{
+  "shard_key": "{shard_key}"
+}
+```
@@ -0,0 +1,18 @@
+```java
+import static io.qdrant.client.ShardKeyFactory.shardKey;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateShardKey;
+import io.qdrant.client.grpc.Collections.CreateShardKeyRequest;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client.createShardKeyAsync(CreateShardKeyRequest.newBuilder()
+                .setCollectionName("{collection_name}")
+                .setRequest(CreateShardKey.newBuilder()
+                                .setShardKey(shardKey("{shard_key}"))
+                                .build())
+                .build()).get();
+```
@@ -0,0 +1,7 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_shard_key("{collection_name}", "{shard_key}")
+```
@@ -0,0 +1,15 @@
+```rust
+use qdrant_client::qdrant::{
+    CreateShardKeyBuilder, CreateShardKeyRequestBuilder
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_shard_key(
+        CreateShardKeyRequestBuilder::new("{collection_name}")
+            .request(CreateShardKeyBuilder::default().shard_key("{shard_key}".to_string())),
+    )
+    .await?;
+```
@@ -0,0 +1,9 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createShardKey("{collection_name}", {
+    shard_key: "{shard_key}"
+});
+```
@@ -0,0 +1 @@
+This code snippet demonstrates how to insert point into Qdrant collection with custom sharding enabled. Request have an additional parameter, `shard_key`, which specifies routing information for the point being inserted.
@@ -0,0 +1,15 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new() { Id = 111, Vectors = new[] { 0.1f, 0.2f, 0.3f } }
+	},
+	shardKeySelector: new ShardKeySelector { ShardKeys = { new List<ShardKey> { "user_1" } } }
+);
+```
@@ -0,0 +1,27 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id:      qdrant.NewIDNum(111),
+			Vectors: qdrant.NewVectors(0.1, 0.2, 0.3),
+		},
+	},
+	ShardKeySelector: &qdrant.ShardKeySelector{
+		ShardKeys: []*qdrant.ShardKey{
+			qdrant.NewShardKey("user_1"),
+		},
+	},
+})
+```
@@ -0,0 +1,12 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1111,
+            "vector": [0.1, 0.2, 0.3]
+        },
+    ]
+    "shard_key": "user_1"
+}
+```
@@ -0,0 +1,30 @@
+```java
+import java.util.List;
+
+import static io.qdrant.client.PointIdFactory.id;
+import static io.qdrant.client.ShardKeySelectorFactory.shardKeySelector;
+import static io.qdrant.client.VectorsFactory.vectors;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+import io.qdrant.client.grpc.Points.UpsertPoints;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .upsertAsync(
+        UpsertPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .addAllPoints(
+                List.of(
+                    PointStruct.newBuilder()
+                        .setId(id(111))
+                        .setVectors(vectors(0.1f, 0.2f, 0.3f))
+                        .build()))
+            .setShardKeySelector(shardKeySelector("user_1"))
+            .build()
+    )
+    .get();
+```
@@ -0,0 +1,16 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1111,
+            vector=[0.1, 0.2, 0.3],
+        ),
+    ],
+    shard_key_selector="user_1",
+)
+```
@@ -0,0 +1,18 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+use qdrant_client::Payload;
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![PointStruct::new(
+                111,
+                vec![0.1, 0.2, 0.3],
+                Payload::default(),
+            )],
+        )
+        .shard_key_selector("user_1".to_string()),
+    )
+    .await?;
+```
@@ -0,0 +1,15 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+    points: [
+        {
+            id: 1111,
+            vector: [0.1, 0.2, 0.3],
+        },
+    ],
+    shard_key: "user_1",
+});
+```
@@ -0,0 +1,2 @@
+This code snippet is for a PUT request to insert points into a collection, where each point has an ID, a payload containing a group ID, and a vector. The code illustrates partitioning vectors by user to ensure that each user can only access their own vectors. It emphasizes adding a `group_id` field to each vector in the collection, facilitating user-specific data access control. Additionally, it suggests using an appropriate naming convention for the key in the payload for flexibility in data structures.
+In addition, the snippet includes a shard key selector, allowing a dymamic routing between shared and dedicated shards based on the existance of `target` shard in the collection.
@@ -0,0 +1,23 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpsertAsync(
+	collectionName: "{collection_name}",
+	points: new List<PointStruct>
+	{
+		new()
+		{
+			Id = 1,
+			Vectors = new[] { 0.9f, 0.1f, 0.1f },
+			Payload = { ["group_id"] = "user_1" }
+		}
+	},
+	shardKeySelector: new ShardKeySelector { 
+		ShardKeys = { new List<ShardKey> { "user_1" } },
+		Fallback = new ShardKey { Keyword = "default" }
+	}
+);
+```
@@ -0,0 +1,29 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.Upsert(context.Background(), &qdrant.UpsertPoints{
+	CollectionName: "{collection_name}",
+	Points: []*qdrant.PointStruct{
+		{
+			Id:      qdrant.NewIDNum(1),
+			Vectors: qdrant.NewVectors(0.9, 0.1, 0.1),
+			Payload: qdrant.NewValueMap(map[string]any{"group_id": "user_1"}),
+		}
+	},
+	ShardKeySelector: &qdrant.ShardKeySelector{
+		ShardKeys: []*qdrant.ShardKey{
+			qdrant.NewShardKey("user_1"),
+		},
+		Fallback: qdrant.NewShardKey("default"),
+	},
+})
+```
@@ -0,0 +1,16 @@
+```http
+PUT /collections/{collection_name}/points
+{
+    "points": [
+        {
+            "id": 1,
+            "payload": {"group_id": "user_1"},
+            "vector": [0.9, 0.1, 0.1]
+        }
+    ],
+    "shard_key": {
+        "fallback": "default",
+        "target": "user_1"
+    }
+}
+```
@@ -0,0 +1,34 @@
+```java
+import java.util.List;
+import java.util.Map;
+
+import static io.qdrant.client.ShardKeyFactory.shardKey;
+
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Points.PointStruct;
+
+import io.qdrant.client.grpc.Points.ShardKeySelector;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .upsertAsync(
+        UpsertPoints.newBuilder()
+            .setCollectionName("{collection_name}")
+            .addAllPoints(
+                List.of(
+                    PointStruct.newBuilder()
+                        .setId(id(1))
+                        .setVectors(vectors(0.9f, 0.1f, 0.1f))
+                        .putAllPayload(Map.of("group_id", value("user_1")))
+                        .build()))
+            .setShardKeySelector(
+                ShardKeySelector.newBuilder()
+                    .addShardKeys(shardKey("user_1"))
+                    .setFallback(shardKey("default"))
+                    .build())
+            .build())
+    .get();
+```
@@ -0,0 +1,16 @@
+```python
+client.upsert(
+    collection_name="{collection_name}",
+    points=[
+        models.PointStruct(
+            id=1,
+            payload={"group_id": "user_1"},
+            vector=[0.9, 0.1, 0.1],
+        ),
+    ],
+    shard_key_selector=models.ShardKeyWithFallback(
+        target="user_1",
+        fallback="default"
+    )
+)
+```
@@ -0,0 +1,26 @@
+```rust
+use qdrant_client::qdrant::{PointStruct, UpsertPointsBuilder};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+let shard_key_selector = ShardKeySelectorBuilder::with_shard_key("user_1")
+    .fallback("default")
+    .build();
+
+client
+    .upsert_points(
+        UpsertPointsBuilder::new(
+            "{collection_name}",
+            vec![
+                PointStruct::new(
+                    1,
+                    vec![0.9, 0.1, 0.1],
+                    [("group_id", "user_1".into())]
+                ),
+            ],
+        )
+        .shard_key_selector(shard_key_selector),
+    )
+    .await?;
+```
@@ -0,0 +1,19 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.upsert("{collection_name}", {
+  points: [
+    {
+      id: 1,
+      payload: { group_id: "user_1" },
+      vector: [0.9, 0.1, 0.1],
+    }
+  ],
+  shard_key: {
+    target: "user_1",
+    fallback: "default"
+  }
+});
+```
@@ -0,0 +1,3 @@
+This request is used to proote tenant from shared Shard to dedicated shard.
+It takes two shard keys - one indicated where to transfer from, another where to thatsfer to,
+as well as filtering condition which defines a subset of points to transfer.
@@ -0,0 +1,18 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+using static Qdrant.Client.Grpc.Conditions;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.UpdateCollectionClusterSetupAsync(new()
+{
+    CollectionName = "{collection_name}",
+	ReplicatePoints = new()
+    {
+        FromShardKey = "default",
+		ToShardKey = "user_1",
+		Filter = MatchKeyword("group_id", "user_1")
+    }
+});
+```
@@ -0,0 +1,24 @@
+```go
+import (
+	"context"
+
+	"github.com/qdrant/go-client/qdrant"
+)
+
+client, err := qdrant.NewClient(&qdrant.Config{
+	Host: "localhost",
+	Port: 6334,
+})
+
+client.UpdateClusterCollectionSetup(ctx, qdrant.NewUpdateCollectionClusterReplicatePoints(
+	"{collection_name}", &qdrant.ReplicatePoints{
+		FromShardKey: qdrant.NewShardKey("default"),
+		ToShardKey:   qdrant.NewShardKey("user_1"),
+		Filter: &qdrant.Filter{
+			Must: []*qdrant.Condition{
+				qdrant.NewMatch("group_id", "user_1"),
+			},
+		},
+	},
+))
+```
@@ -0,0 +1,17 @@
+```http
+POST /collections/{collection_name}/cluster
+{
+    "replicate_points": {
+        "filter": {
+            "must": {
+                "key": "group_id",
+                "match": {
+                    "value": "user_1"
+                }
+            }
+        },
+        "from_shard_key": "default",
+        "to_shard_key": "user_1"
+    }
+}
+```
@@ -0,0 +1,29 @@
+```java
+import static io.qdrant.client.ConditionFactory.matchKeyword;
+import static io.qdrant.client.QueryFactory.nearest;
+import static io.qdrant.client.ShardKeyFactory.shardKey;
+
+import io.qdrant.client.grpc.Collections.ReplicatePoints;
+import io.qdrant.client.grpc.Collections.UpdateCollectionClusterSetupRequest;
+import io.qdrant.client.grpc.Points.Filter;
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+
+client
+    .updateCollectionClusterSetupAsync(
+        UpdateCollectionClusterSetupRequest.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setReplicatePoints(
+                ReplicatePoints.newBuilder()
+                    .setFromShardKey(shardKey("default"))
+                    .setToShardKey(shardKey("user_1"))
+                    .setFilter(
+                        Filter.newBuilder().addMust(matchKeyword("group_id", "user_1")).build())
+                    .build())
+            .build())
+    .get();
+```
@@ -0,0 +1,26 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+
+client.cluster_collection_update(
+    collection_name="{collection_name}",
+    cluster_operation=models.ReplicatePointsOperation(
+        replicate_points=models.ReplicatePoints(
+            from_shard_key="default",
+            to_shard_key="user_1",
+            filter=models.Filter(
+                must=[
+                    models.FieldCondition(
+                        key="group_id",
+                        match=models.MatchValue(
+                            value="user_1",
+                        )
+                    )
+                ]
+            )
+        )
+    )
+)
+```
@@ -0,0 +1,27 @@
+```rust
+use qdrant_client::qdrant::{
+    update_collection_cluster_setup_request::Operation, Condition, Filter,
+    ReplicatePointsBuilder, ShardKey, UpdateCollectionClusterSetupRequest,
+};
+use qdrant_client::Qdrant;
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .update_collection_cluster_setup(UpdateCollectionClusterSetupRequest {
+        collection_name: "{collection_name}".to_string(),
+        operation: Some(Operation::ReplicatePoints(
+            ReplicatePointsBuilder::new(
+                ShardKey::from("default"),
+                ShardKey::from("user_1"),
+            )
+            .filter(Filter::must([Condition::matches(
+                "group_id",
+                "user_1".to_string(),
+            )]))
+            .build(),
+        )),
+        timeout: None,
+    })
+    .await?;
+```
@@ -0,0 +1,20 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.updateCollectionCluster("{collection_name}", {
+    replicate_points: {
+        filter: {
+            must: {
+                key: "group_id",
+                match: {
+                    value: "user_1"
+                }
+            }
+        },
+        from_shard_key: "default",
+        to_shard_key: "user_1"
+    }
+});
+```
				`@@ -0,0 +1 @@`
				This code snippet demonstrates how to insert point into Qdrant collection with custom sharding enabled. Request have an additional parameter, `shard_key`, which specifies routing information for the point being inserted.