[v1.16] Document properly strict mode (#1989)

* Document properly strict mode

* add snippet to turn off the strict mode on unindexed filtering

* snippets to disable strict mode

* restructure

* snippets for max_payload_index_count

* sigh

* snippets for max_query_limit

* snippets for max_timeout

* snippets for filter_max_conditions

* snippets for upsert_max_batchsize

* snippets for max_collection_vector_size_bytes

* snippets for rate limiting

* snippets for max_points_count

* snippets for unindexed_filtering_update

* snippets for max_collection_vector_size_bytes

* snippets for condition_max_size

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

* Update qdrant-landing/content/documentation/guides/administration.md

* Update qdrant-landing/content/documentation/guides/administration.md

---------

Co-authored-by: Tim Visée <tim@visee.me>
Co-authored-by: Abdon Pijpelink <abdon.pijpelink@qdrant.com>

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/_description.md

@@ -0,0 +1 @@
+This code snippet set `condition_max_size` on the strict mode configuration to cap the maximum number of element a filtering condition can have.

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "condition_max_size": 10
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, condition_max_size = 10 }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    ConditionMaxSize: qdrant.PtrOf(uint64(10)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "condition_max_size": 10
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setConditionMaxSize(10).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, condition_max_size=10),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).condition_max_size(10)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/condition-max-size/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    condition_max_size: 10,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/_description.md

@@ -0,0 +1 @@
+This code snippet completely disable strict mode on an existing configuration.

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/bash.md

@@ -0,0 +1,9 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" false
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = false }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/go.md

@@ -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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(false),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/http.md

@@ -0,0 +1,8 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": false
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(false).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=False),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(false)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/disable/typescript.md

@@ -0,0 +1,11 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: false,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/_description.md

@@ -0,0 +1 @@
+This code snippet set `filter_max_conditions` on the strict mode configuration to cap the maximum number of conditions filters can have.

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "filter_max_conditions": 10
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, filter_max_conditions = 10 }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    FilterMaxConditions: qdrant.PtrOf(uint64(10)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "filter_max_conditions": 10
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setFilterMaxConditions(10).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, filter_max_conditions=10),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).filter_max_conditions(10)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/filter-max-conditions/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    filter_max_conditions: 10,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/_description.md

@@ -0,0 +1 @@
+This code snippet set `max_collection_vector_size_bytes` and `max_collection_payload_size_bytes` on the strict mode configuration to cap the maximum size in bytes of a collection.

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/bash.md

@@ -0,0 +1,11 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "max_collection_vector_size_bytes": 100000,
+      "max_collection_payload_size_bytes": 100000
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, max_collection_vector_size_bytes = 1000000, max_collection_payload_size_bytes = 1000000 }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/go.md

@@ -0,0 +1,21 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    MaxCollectionVectorSizeBytes: qdrant.PtrOf(uint64(1000000)),
+    MaxCollectionPayloadSizeBytes: qdrant.PtrOf(uint64(1000000)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/http.md

@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "max_collection_vector_size_bytes": 1000000,
+        "max_collection_payload_size_bytes": 1000000
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setMaxCollectionVectorSizeBytes(1000000).setMaxCollectionPayloadSizeBytes(1000000).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, max_collection_vector_size_bytes=1000000, max_collection_payload_size_bytes=1000000),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).max_collection_vector_size_bytes(1000000).max_collection_payload_size_bytes(1000000)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-collection-storage-size-bytes/typescript.md

@@ -0,0 +1,13 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    max_collection_vector_size_bytes: 1000000,
+    max_collection_payload_size_bytes: 1000000,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/_description.md

@@ -0,0 +1 @@
+This code snippet set `max_payload_index_count` on the strict mode configuration to cap the maximum number of payload index.

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "max_payload_index_count": 10
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, max_payload_index_count = 10 }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    MaxPayloadIndexCount: qdrant.PtrOf(uint64(10)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "max_payload_index_count": 10
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setMaxPayloadIndexCount(10).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, max_payload_index_count=10),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).max_payload_index_count(10)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-payload-index-count/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    max_payload_index_count: 10,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/_description.md

@@ -0,0 +1 @@
+This code snippet set `max_points_count` on the strict mode configuration to cap the maximum number of points for a collection.

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "max_points_count": 1000
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, max_points_count = 1000 }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    MaxPointsCount: qdrant.PtrOf(uint64(1000)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "max_points_count": 1000
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setMaxPointsCount(1000).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, max_points_count=1000),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).max_points_count(1000)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-points-count/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    max_points_count: 1000,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/_description.md

@@ -0,0 +1 @@
+This code snippet set `max_query_limit` on the strict mode configuration to cap the maximum number points can be retrieved in a single query.

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "max_query_limit": 10
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, max_query_limit = 10 }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    MaxQueryLimit: qdrant.PtrOf(uint64(10)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "max_query_limit": 10
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setMaxQueryLimit(10).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, max_query_limit=10),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).max_query_limit(10)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-query-limit/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    max_query_limit: 10,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/_description.md

@@ -0,0 +1 @@
+This code snippet set `max_timeout` on the strict mode configuration to cap the maximum value in seconds for the `timeout` parameters for all API operations.

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "max_timeout": 10
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, max_timeout = 10 }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    MaxTimeout: qdrant.PtrOf(uint64(10)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "max_timeout": 10
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setMaxTimeout(10).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, max_timeout=10),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).max_timeout(10)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/max-timeout/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    max_timeout: 10,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/_description.md

@@ -0,0 +1 @@
+This code snippet set `read_rate_limit` & `write_rate_limit` on the strict mode configuration to cap the maximum of operations per minute per replica..

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/bash.md

@@ -0,0 +1,11 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "read_rate_limit": 1000,
+      "write_rate_limit": 100,
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, read_rate_limit = 1000, write_rate_limit = 100}
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/go.md

@@ -0,0 +1,21 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    ReadRateLimit: qdrant.PtrOf(uint64(1000)),
+    WriteRateLimit: qdrant.PtrOf(uint64(100)),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/http.md

@@ -0,0 +1,10 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "read_rate_limit": 1000,
+        "write_rate_limit": 100,
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setReadRateLimit(1000).setWriteRateLimit(100).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, read_rate_limit=1000, write_rate_limit=1000,),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).read_rate_limit(1000).write_rate_limit(100)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/rate-limiting/typescript.md

@@ -0,0 +1,13 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    read_rate_limit: 1000,
+    write_rate_limit: 100,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/_description.md

@@ -0,0 +1 @@
+This code snippet turns off `unindexed_filtering_retrieve` on the strict mode configuration to enable retrieving points by filtering on a non indexed payload key.

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "unindexed_filtering_retrieve": true
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, unindexed_filtering_retrieve = true }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    UnindexedFilteringRetrieve: qdrant.PtrOf(true),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "unindexed_filtering_retrieve": true
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setUnindexedFilteringRetrieve(true).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, unindexed_filtering_retrieve=True),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).unindexed_filtering_retrieve(true)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve-off/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    unindexed_filtering_retrieve: true,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/_description.md

@@ -0,0 +1 @@
+This code snippet enables `unindexed_filtering_retrieve` on the strict mode configuration to prevent retrieving points by filtering on a non indexed payload key.

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/bash.md

@@ -0,0 +1,10 @@
+```bash
+curl -X PUT http://localhost:6333/collections/{collection_name} \
+  -H 'Content-Type: application/json' \
+  --data-raw '{
+    "strict_mode_config": {
+      "enabled":" true,
+      "unindexed_filtering_retrieve": false
+    }
+  }'
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/csharp.md

@@ -0,0 +1,11 @@
+```csharp
+using Qdrant.Client;
+using Qdrant.Client.Grpc;
+
+var client = new QdrantClient("localhost", 6334);
+
+await client.CreateCollectionAsync(
+  collectionName: "{collection_name}",
+  strictModeConfig: new StrictModeConfig { enabled = true, unindexed_filtering_retrieve = false }
+);
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/go.md

@@ -0,0 +1,20 @@
+```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}",
+  StrictModeConfig: &qdrant.StrictModeConfig{
+    Enabled: qdrant.PtrOf(true),
+    UnindexedFilteringRetrieve: qdrant.PtrOf(false),
+  },
+})
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/http.md

@@ -0,0 +1,9 @@
+```http
+PUT /collections/{collection_name}
+{
+    "strict_mode_config": {
+        "enabled": true,
+        "unindexed_filtering_retrieve": false
+    }
+}
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/java.md

@@ -0,0 +1,19 @@
+
+```java
+import io.qdrant.client.QdrantClient;
+import io.qdrant.client.QdrantGrpcClient;
+import io.qdrant.client.grpc.Collections.CreateCollection;
+import io.qdrant.client.grpc.Collections.StrictModeCOnfig;
+
+QdrantClient client =
+    new QdrantClient(QdrantGrpcClient.newBuilder("localhost", 6334, false).build());
+
+client
+    .createCollectionAsync(
+        CreateCollection.newBuilder()
+            .setCollectionName("{collection_name}")
+            .setStrictModeConfig(
+                StrictModeConfig.newBuilder().setEnabled(true).setUnindexedFilteringRetrieve(false).build())
+            .build())
+    .get();
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_client import QdrantClient, models
+
+client = QdrantClient(url="http://localhost:6333")
+
+client.create_collection(
+    collection_name="{collection_name}",
+    strict_mode_config=models.StrictModeConfig(enabled=True, unindexed_filtering_retrieve=False),
+)
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/rust.md

@@ -0,0 +1,13 @@
+```rust
+use qdrant_client::Qdrant;
+use qdrant_client::qdrant::{CreateCollectionBuilder, StrictModeConfigBuilder};
+
+let client = Qdrant::from_url("http://localhost:6334").build()?;
+
+client
+    .create_collection(
+        CreateCollectionBuilder::new("{collection_name}")
+            .strict_config_mode(StrictModeConfigBuilder::default().enabled(true).unindexed_filtering_retrieve(false)),
+    )
+    .await?;
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-retrieve/typescript.md

@@ -0,0 +1,12 @@
+```typescript
+import { QdrantClient } from "@qdrant/js-client-rest";
+
+const client = new QdrantClient({ host: "localhost", port: 6333 });
+
+client.createCollection("{collection_name}", {
+  strict_mode_config: {
+    enabled: true,
+    unindexed_filtering_retrieve: false,
+  },
+});
+```

qdrant-landing/content/documentation/headless/snippets/strict-mode/unindexed-filtering-update/_description.md

@@ -0,0 +1 @@
+This code snippet enables `unindexed_filtering_update` on the strict mode configuration to prevent updating points by filtering on a non indexed payload key.