Edge 0.7 documentation updates (#2391)

* docs(edge): add "Modify the Vector Schema" step to quickstart

Documents the new Edge 0.7 API for adding and removing named vector
fields on an existing shard without recreating it, with Python and
Rust snippets.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(edge): mention quantization support in quickstart

Adds a note after the EdgeConfig snippet that Edge supports all four
quantization methods (Scalar, Product, Binary, TurboQuant), with a
link to the quantization guide.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(edge): add On-Device BM25 page for Edge 0.7

New guide covering the built-in BM25 sparse embedder: configuring a
sparse vector shard, creating a Bm25/EdgeBm25 embedder, embedding and
upserting documents, and querying. Includes Python and Rust snippets.
Also adds the page to the Edge index navigation table.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* docs(edge): add WAL segment size configuration to quickstart

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

* Upgrade code snippets to Edge 0.7.2

* Review feedback

---------

Co-authored-by: Claude Sonnet 4.6 <noreply@anthropic.com>

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/configure-bm25-shard/python.md

@@ -0,0 +1,14 @@
+```python
+from qdrant_edge import (
+    EdgeConfig,
+    EdgeShard,
+    EdgeSparseVectorParams,
+    Modifier,
+)
+
+config = EdgeConfig(
+    sparse_vectors={"text": EdgeSparseVectorParams(modifier=Modifier.Idf)},
+)
+
+shard = EdgeShard.create(SHARD_DIRECTORY, config)
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/configure-bm25-shard/rust.md

@@ -0,0 +1,9 @@
+```rust
+let config = EdgeConfigBuilder::new()
+    .sparse_vector("text", EdgeSparseVectorParamsBuilder::new()
+        .modifier(Modifier::Idf)
+        .build())
+    .build();
+
+let shard = EdgeShard::new(Path::new(SHARD_DIRECTORY), config)?;
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/create-bm25/python.md

@@ -0,0 +1,5 @@
+```python
+from qdrant_edge import Bm25, Bm25Config
+
+bm25 = Bm25(Bm25Config(language="english"))
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/create-bm25/rust.md

@@ -0,0 +1,6 @@
+```rust
+let bm25 = EdgeBm25::new(EdgeBm25Config {
+    language: Some("english".to_string()),
+    ..Default::default()
+})?;
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/embed-and-upsert/python.md

@@ -0,0 +1,10 @@
+```python
+from qdrant_edge import Point, UpdateOperation
+
+shard.update(UpdateOperation.upsert_points([
+    Point(1, {"text": bm25.embed_document("the quick brown fox")}, {"title": "Article 1"}),
+    Point(2, {"text": bm25.embed_document("a lazy dog sleeps")},   {"title": "Article 2"}),
+    Point(3, {"text": bm25.embed_document("foxes are clever")},    {"title": "Article 3"}),
+]))
+shard.optimize()
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/embed-and-upsert/rust.md

@@ -0,0 +1,20 @@
+```rust
+let docs = [
+    (1u64, "the quick brown fox", "Article 1"),
+    (2,    "a lazy dog sleeps",   "Article 2"),
+    (3,    "foxes are clever",    "Article 3"),
+];
+
+let points = docs.iter().map(|(id, text, title)| {
+    PointStruct::new(
+        *id,
+        Vectors::new_named([("text", bm25.embed_document(text))]),
+        json!({ "title": title }),
+    ).into()
+}).collect();
+
+shard.update(UpdateOperation::PointOperation(
+    PointOperations::UpsertPoints(PointInsertOperations::PointsList(points)),
+))?;
+shard.optimize()?;
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/python.md

@@ -0,0 +1,41 @@
+```python
+from pathlib import Path
+
+SHARD_DIRECTORY = "./qdrant-edge-bm25"
+
+from qdrant_edge import (
+    EdgeConfig,
+    EdgeShard,
+    EdgeSparseVectorParams,
+    Modifier,
+)
+
+config = EdgeConfig(
+    sparse_vectors={"text": EdgeSparseVectorParams(modifier=Modifier.Idf)},
+)
+
+shard = EdgeShard.create(SHARD_DIRECTORY, config)
+
+from qdrant_edge import Bm25, Bm25Config
+
+bm25 = Bm25(Bm25Config(language="english"))
+
+from qdrant_edge import Point, UpdateOperation
+
+shard.update(UpdateOperation.upsert_points([
+    Point(1, {"text": bm25.embed_document("the quick brown fox")}, {"title": "Article 1"}),
+    Point(2, {"text": bm25.embed_document("a lazy dog sleeps")},   {"title": "Article 2"}),
+    Point(3, {"text": bm25.embed_document("foxes are clever")},    {"title": "Article 3"}),
+]))
+shard.optimize()
+
+from qdrant_edge import Query, QueryRequest
+
+query_vector = bm25.embed_query("clever fox")
+
+results = shard.query(QueryRequest(
+    query=Query.Nearest(query_vector, using="text"),
+    limit=3,
+    with_payload=True,
+))
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/query-with-bm25/python.md

@@ -0,0 +1,11 @@
+```python
+from qdrant_edge import Query, QueryRequest
+
+query_vector = bm25.embed_query("clever fox")
+
+results = shard.query(QueryRequest(
+    query=Query.Nearest(query_vector, using="text"),
+    limit=3,
+    with_payload=True,
+))
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/query-with-bm25/rust.md

@@ -0,0 +1,18 @@
+```rust
+let query_vector = bm25.embed_query("clever fox");
+
+let results = shard.query(QueryRequest {
+    prefetches: vec![],
+    query: Some(ScoringQuery::Vector(QueryEnum::Nearest(NamedQuery {
+        query: VectorInternal::from(query_vector),
+        using: Some("text".to_string()),
+    }))),
+    filter: None,
+    score_threshold: None,
+    limit: 3,
+    offset: 0,
+    params: None,
+    with_vector: WithVector::Bool(false),
+    with_payload: WithPayloadInterface::Bool(true),
+})?;
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/generated/rust.md

@@ -0,0 +1,63 @@
+```rust
+use std::path::Path;
+
+use qdrant_edge::bm25_embed::{EdgeBm25, EdgeBm25Config};
+use qdrant_edge::external::serde_json::json;
+use qdrant_edge::{
+    EdgeConfigBuilder, EdgeShard, EdgeSparseVectorParamsBuilder, Modifier,
+    NamedQuery, PointInsertOperations, PointOperations, PointStruct,
+    QueryEnum, QueryRequest, ScoringQuery, UpdateOperation,
+    VectorInternal, Vectors, WithPayloadInterface, WithVector,
+};
+
+const SHARD_DIRECTORY: &str = "./qdrant-edge-bm25";
+
+let config = EdgeConfigBuilder::new()
+    .sparse_vector("text", EdgeSparseVectorParamsBuilder::new()
+        .modifier(Modifier::Idf)
+        .build())
+    .build();
+
+let shard = EdgeShard::new(Path::new(SHARD_DIRECTORY), config)?;
+
+let bm25 = EdgeBm25::new(EdgeBm25Config {
+    language: Some("english".to_string()),
+    ..Default::default()
+})?;
+
+let docs = [
+    (1u64, "the quick brown fox", "Article 1"),
+    (2,    "a lazy dog sleeps",   "Article 2"),
+    (3,    "foxes are clever",    "Article 3"),
+];
+
+let points = docs.iter().map(|(id, text, title)| {
+    PointStruct::new(
+        *id,
+        Vectors::new_named([("text", bm25.embed_document(text))]),
+        json!({ "title": title }),
+    ).into()
+}).collect();
+
+shard.update(UpdateOperation::PointOperation(
+    PointOperations::UpsertPoints(PointInsertOperations::PointsList(points)),
+))?;
+shard.optimize()?;
+
+let query_vector = bm25.embed_query("clever fox");
+
+let results = shard.query(QueryRequest {
+    prefetches: vec![],
+    query: Some(ScoringQuery::Vector(QueryEnum::Nearest(NamedQuery {
+        query: VectorInternal::from(query_vector),
+        using: Some("text".to_string()),
+    }))),
+    filter: None,
+    score_threshold: None,
+    limit: 3,
+    offset: 0,
+    params: None,
+    with_vector: WithVector::Bool(false),
+    with_payload: WithPayloadInterface::Bool(true),
+})?;
+```

qdrant-landing/content/documentation/headless/snippets/edge/bm25/python.py

@@ -0,0 +1,48 @@
+from pathlib import Path
+
+SHARD_DIRECTORY = "./qdrant-edge-bm25"
+Path(SHARD_DIRECTORY).mkdir(parents=True, exist_ok=True) # @hide
+
+# @block-start configure-bm25-shard
+from qdrant_edge import (
+    EdgeConfig,
+    EdgeShard,
+    EdgeSparseVectorParams,
+    Modifier,
+)
+
+config = EdgeConfig(
+    sparse_vectors={"text": EdgeSparseVectorParams(modifier=Modifier.Idf)},
+)
+
+shard = EdgeShard.create(SHARD_DIRECTORY, config)
+# @block-end configure-bm25-shard
+
+# @block-start create-bm25
+from qdrant_edge import Bm25, Bm25Config
+
+bm25 = Bm25(Bm25Config(language="english"))
+# @block-end create-bm25
+
+# @block-start embed-and-upsert
+from qdrant_edge import Point, UpdateOperation
+
+shard.update(UpdateOperation.upsert_points([
+    Point(1, {"text": bm25.embed_document("the quick brown fox")}, {"title": "Article 1"}),
+    Point(2, {"text": bm25.embed_document("a lazy dog sleeps")},   {"title": "Article 2"}),
+    Point(3, {"text": bm25.embed_document("foxes are clever")},    {"title": "Article 3"}),
+]))
+shard.optimize()
+# @block-end embed-and-upsert
+
+# @block-start query-with-bm25
+from qdrant_edge import Query, QueryRequest
+
+query_vector = bm25.embed_query("clever fox")
+
+results = shard.query(QueryRequest(
+    query=Query.Nearest(query_vector, using="text"),
+    limit=3,
+    with_payload=True,
+))
+# @block-end query-with-bm25

qdrant-landing/content/documentation/headless/snippets/edge/bm25/rust.rs

@@ -0,0 +1,74 @@
+use std::path::Path;
+
+use qdrant_edge::bm25_embed::{EdgeBm25, EdgeBm25Config};
+use qdrant_edge::external::serde_json::json;
+use qdrant_edge::{
+    EdgeConfigBuilder, EdgeShard, EdgeSparseVectorParamsBuilder, Modifier,
+    NamedQuery, PointInsertOperations, PointOperations, PointStruct,
+    QueryEnum, QueryRequest, ScoringQuery, UpdateOperation,
+    VectorInternal, Vectors, WithPayloadInterface, WithVector,
+};
+
+pub async fn main() -> anyhow::Result<()> {
+    const SHARD_DIRECTORY: &str = "./qdrant-edge-bm25";
+    fs_err::create_dir_all(SHARD_DIRECTORY)?; // @hide
+
+    // @block-start configure-bm25-shard
+    let config = EdgeConfigBuilder::new()
+        .sparse_vector("text", EdgeSparseVectorParamsBuilder::new()
+            .modifier(Modifier::Idf)
+            .build())
+        .build();
+
+    let shard = EdgeShard::new(Path::new(SHARD_DIRECTORY), config)?;
+    // @block-end configure-bm25-shard
+
+    // @block-start create-bm25
+    let bm25 = EdgeBm25::new(EdgeBm25Config {
+        language: Some("english".to_string()),
+        ..Default::default()
+    })?;
+    // @block-end create-bm25
+
+    // @block-start embed-and-upsert
+    let docs = [
+        (1u64, "the quick brown fox", "Article 1"),
+        (2,    "a lazy dog sleeps",   "Article 2"),
+        (3,    "foxes are clever",    "Article 3"),
+    ];
+
+    let points = docs.iter().map(|(id, text, title)| {
+        PointStruct::new(
+            *id,
+            Vectors::new_named([("text", bm25.embed_document(text))]),
+            json!({ "title": title }),
+        ).into()
+    }).collect();
+
+    shard.update(UpdateOperation::PointOperation(
+        PointOperations::UpsertPoints(PointInsertOperations::PointsList(points)),
+    ))?;
+    shard.optimize()?;
+    // @block-end embed-and-upsert
+
+    // @block-start query-with-bm25
+    let query_vector = bm25.embed_query("clever fox");
+
+    let results = shard.query(QueryRequest {
+        prefetches: vec![],
+        query: Some(ScoringQuery::Vector(QueryEnum::Nearest(NamedQuery {
+            query: VectorInternal::from(query_vector),
+            using: Some("text".to_string()),
+        }))),
+        filter: None,
+        score_threshold: None,
+        limit: 3,
+        offset: 0,
+        params: None,
+        with_vector: WithVector::Bool(false),
+        with_payload: WithPayloadInterface::Bool(true),
+    })?;
+    // @block-end query-with-bm25
+
+    Ok(())
+}

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/generated/configure-edge-shard/rust.md

@@ -2,23 +2,13 @@
 const VECTOR_NAME: &str = "my-vector";
 const VECTOR_DIMENSION: usize = 4;
 
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: Default::default(),
-};
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .build();
 ```

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/generated/configure-optimizer/rust.md

@@ -1,26 +1,17 @@
 ```rust
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: EdgeOptimizersConfig {
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .optimizers(EdgeOptimizersConfig {
         deleted_threshold: Some(0.2),
         vacuum_min_vector_number: Some(100),
         default_segment_number: Some(2),
         ..Default::default()
-    },
-};
+    })
+    .build();
 ```

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/generated/modify-vector-schema/python.md

@@ -0,0 +1,8 @@
+```python
+from qdrant_edge import Modifier
+
+edge_shard.update(UpdateOperation.create_sparse_vector(
+    vector_name="text",
+    modifier=Modifier.Idf,
+))
+```

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/generated/modify-vector-schema/rust.md

@@ -0,0 +1,11 @@
+```rust
+edge_shard.update(UpdateOperation::VectorNameOperation(
+    VectorNameOperations::CreateVectorName(CreateVectorName {
+        vector_name: "text".to_string(),
+        config: VectorNameConfig::sparse(SparseVectorConfig {
+            modifier: Some(Modifier::Idf),
+            datatype: None,
+        }),
+    }),
+))?;
+```

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/generated/python.md

@@ -43,6 +43,13 @@ records = edge_shard.retrieve(
     with_vector=False
 )
 
+from qdrant_edge import Modifier
+
+edge_shard.update(UpdateOperation.create_sparse_vector(
+    vector_name="text",
+    modifier=Modifier.Idf,
+))
+
 from qdrant_edge import Query, QueryRequest
 
 results = edge_shard.query(

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/generated/rust.md

@@ -1,15 +1,16 @@
 ```rust
-use std::collections::HashMap;
 use std::path::Path;
 
 use qdrant_edge::EdgeShard;
 use qdrant_edge::{
-    Condition, CreateIndex, Distance, EdgeConfig, EdgeOptimizersConfig,
-    EdgeVectorParams, FacetRequest, FieldCondition, FieldIndexOperations,
-    Filter, Match, MatchValue, NamedQuery, PayloadFieldSchema,
-    PayloadSchemaType, PointId, PointInsertOperations, PointOperations,
-    PointStruct, PointStructPersisted, QueryEnum, QueryRequest, ScoringQuery,
-    UpdateOperation, ValueVariants, Vectors, WithPayloadInterface, WithVector,
+    Condition, CreateIndex, CreateVectorName, Distance, EdgeConfigBuilder,
+    EdgeOptimizersConfig, EdgeVectorParamsBuilder, FacetRequest, FieldCondition,
+    FieldIndexOperations, Filter, Match, MatchValue, Modifier, NamedQuery,
+    PayloadFieldSchema, PayloadSchemaType, PointId, PointInsertOperations,
+    PointOperations, PointStruct, PointStructPersisted, QueryEnum, QueryRequest,
+    ScoringQuery, SparseVectorConfig, UpdateOperation, ValueVariants,
+    VectorNameConfig, VectorNameOperations, Vectors, WalOptions,
+    WithPayloadInterface, WithVector,
 };
 use serde_json::json;
 
@@ -20,25 +21,15 @@ fs_err::create_dir_all(SHARD_DIRECTORY)?;
 const VECTOR_NAME: &str = "my-vector";
 const VECTOR_DIMENSION: usize = 4;
 
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: Default::default(),
-};
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .build();
 
 let edge_shard = EdgeShard::new(
     Path::new(SHARD_DIRECTORY),
@@ -66,6 +57,16 @@ let retrieved = edge_shard.retrieve(
     Some(WithVector::Bool(false)),
 )?;
 
+edge_shard.update(UpdateOperation::VectorNameOperation(
+    VectorNameOperations::CreateVectorName(CreateVectorName {
+        vector_name: "text".to_string(),
+        config: VectorNameConfig::sparse(SparseVectorConfig {
+            modifier: Some(Modifier::Idf),
+            datatype: None,
+        }),
+    }),
+))?;
+
 let results = edge_shard.query(QueryRequest {
     prefetches: vec![],
     query: Some(ScoringQuery::Vector(QueryEnum::Nearest(NamedQuery {
@@ -117,30 +118,21 @@ let facet_response = edge_shard.facet(FacetRequest {
 
 edge_shard.optimize()?;
 
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: EdgeOptimizersConfig {
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .optimizers(EdgeOptimizersConfig {
         deleted_threshold: Some(0.2),
         vacuum_min_vector_number: Some(100),
         default_segment_number: Some(2),
         ..Default::default()
-    },
-};
+    })
+    .build();
 
 edge_shard.update(UpdateOperation::FieldIndexOperation(
     FieldIndexOperations::CreateIndex(CreateIndex {
@@ -154,4 +146,13 @@ edge_shard.update(UpdateOperation::FieldIndexOperation(
 drop(edge_shard);
 
 let edge_shard = EdgeShard::load(Path::new(SHARD_DIRECTORY), None)?;
+
+let config = EdgeConfigBuilder::new()
+    .wal_options(WalOptions {
+        segment_capacity: 4 * 1024 * 1024,
+        ..Default::default()
+    })
+    .build();
+
+let edge_shard = EdgeShard::load(Path::new(SHARD_DIRECTORY), Some(config))?;
 ```

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/generated/wal-options/rust.md

@@ -0,0 +1,10 @@
+```rust
+let config = EdgeConfigBuilder::new()
+    .wal_options(WalOptions {
+        segment_capacity: 4 * 1024 * 1024,
+        ..Default::default()
+    })
+    .build();
+
+let edge_shard = EdgeShard::load(Path::new(SHARD_DIRECTORY), Some(config))?;
+```

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/python.py

@@ -52,6 +52,15 @@ records = edge_shard.retrieve(
 )
 # @block-end retrieve-point
 
+# @block-start modify-vector-schema
+from qdrant_edge import Modifier
+
+edge_shard.update(UpdateOperation.create_sparse_vector(
+    vector_name="text",
+    modifier=Modifier.Idf,
+))
+# @block-end modify-vector-schema
+
 # @block-start query-points
 from qdrant_edge import Query, QueryRequest
 

qdrant-landing/content/documentation/headless/snippets/edge/quickstart/rust.rs

@@ -1,14 +1,15 @@
-use std::collections::HashMap;
 use std::path::Path;
 
 use qdrant_edge::EdgeShard;
 use qdrant_edge::{
-    Condition, CreateIndex, Distance, EdgeConfig, EdgeOptimizersConfig,
-    EdgeVectorParams, FacetRequest, FieldCondition, FieldIndexOperations,
-    Filter, Match, MatchValue, NamedQuery, PayloadFieldSchema,
-    PayloadSchemaType, PointId, PointInsertOperations, PointOperations,
-    PointStruct, PointStructPersisted, QueryEnum, QueryRequest, ScoringQuery,
-    UpdateOperation, ValueVariants, Vectors, WithPayloadInterface, WithVector,
+    Condition, CreateIndex, CreateVectorName, Distance, EdgeConfigBuilder,
+    EdgeOptimizersConfig, EdgeVectorParamsBuilder, FacetRequest, FieldCondition,
+    FieldIndexOperations, Filter, Match, MatchValue, Modifier, NamedQuery,
+    PayloadFieldSchema, PayloadSchemaType, PointId, PointInsertOperations,
+    PointOperations, PointStruct, PointStructPersisted, QueryEnum, QueryRequest,
+    ScoringQuery, SparseVectorConfig, UpdateOperation, ValueVariants,
+    VectorNameConfig, VectorNameOperations, Vectors, WalOptions,
+    WithPayloadInterface, WithVector,
 };
 use serde_json::json;
 
@@ -23,25 +24,15 @@ pub async fn main() -> anyhow::Result<()> {
     const VECTOR_NAME: &str = "my-vector";
     const VECTOR_DIMENSION: usize = 4;
 
-    let config = EdgeConfig {
-        on_disk_payload: true,
-        vectors: HashMap::from([(
-            VECTOR_NAME.to_string(),
-            EdgeVectorParams {
-                size: VECTOR_DIMENSION,
-                distance: Distance::Cosine,
-                on_disk: Some(true),
-                quantization_config: None,
-                multivector_config: None,
-                datatype: None,
-                hnsw_config: None,
-            },
-        )]),
-        sparse_vectors: HashMap::new(),
-        hnsw_config: Default::default(),
-        quantization_config: None,
-        optimizers: Default::default(),
-    };
+    let config = EdgeConfigBuilder::new()
+        .on_disk_payload(true)
+        .vector(
+            VECTOR_NAME,
+            EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+                .on_disk(true)
+                .build(),
+        )
+        .build();
     // @block-end configure-edge-shard
 
     // @block-start initialize-edge-shard
@@ -76,6 +67,18 @@ pub async fn main() -> anyhow::Result<()> {
     )?;
     // @block-end retrieve-point
 
+    // @block-start modify-vector-schema
+    edge_shard.update(UpdateOperation::VectorNameOperation(
+        VectorNameOperations::CreateVectorName(CreateVectorName {
+            vector_name: "text".to_string(),
+            config: VectorNameConfig::sparse(SparseVectorConfig {
+                modifier: Some(Modifier::Idf),
+                datatype: None,
+            }),
+        }),
+    ))?;
+    // @block-end modify-vector-schema
+
     // @block-start query-points
     let results = edge_shard.query(QueryRequest {
         prefetches: vec![],
@@ -136,30 +139,21 @@ pub async fn main() -> anyhow::Result<()> {
     // @block-end optimize
 
     // @block-start configure-optimizer
-    let config = EdgeConfig {
-        on_disk_payload: true,
-        vectors: HashMap::from([(
-            VECTOR_NAME.to_string(),
-            EdgeVectorParams {
-                size: VECTOR_DIMENSION,
-                distance: Distance::Cosine,
-                on_disk: Some(true),
-                quantization_config: None,
-                multivector_config: None,
-                datatype: None,
-                hnsw_config: None,
-            },
-        )]),
-        sparse_vectors: HashMap::new(),
-        hnsw_config: Default::default(),
-        quantization_config: None,
-        optimizers: EdgeOptimizersConfig {
+    let config = EdgeConfigBuilder::new()
+        .on_disk_payload(true)
+        .vector(
+            VECTOR_NAME,
+            EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+                .on_disk(true)
+                .build(),
+        )
+        .optimizers(EdgeOptimizersConfig {
             deleted_threshold: Some(0.2),
             vacuum_min_vector_number: Some(100),
             default_segment_number: Some(2),
             ..Default::default()
-        },
-    };
+        })
+        .build();
     // @block-end configure-optimizer
 
     // @block-start create-payload-index
@@ -181,5 +175,16 @@ pub async fn main() -> anyhow::Result<()> {
     let edge_shard = EdgeShard::load(Path::new(SHARD_DIRECTORY), None)?;
     // @block-end load-edge-shard
 
+    // @block-start wal-options
+    let config = EdgeConfigBuilder::new()
+        .wal_options(WalOptions {
+            segment_capacity: 4 * 1024 * 1024,
+            ..Default::default()
+        })
+        .build();
+
+    let edge_shard = EdgeShard::load(Path::new(SHARD_DIRECTORY), Some(config))?;
+    // @block-end wal-options
+
     Ok(())
 }

qdrant-landing/content/documentation/headless/snippets/edge/synchronization-guide/generated/initialize-mutable-shard/rust.md

@@ -4,25 +4,15 @@ const VECTOR_DIMENSION: usize = 4;
 const VECTOR_NAME: &str = "my-vector";
 
 fs_err::create_dir_all(MUTABLE_SHARD_DIR)?;
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: Default::default(),
-};
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .build();
 
 let mutable_shard = EdgeShard::new(
     Path::new(MUTABLE_SHARD_DIR),

qdrant-landing/content/documentation/headless/snippets/edge/synchronization-guide/generated/rust.md

@@ -8,11 +8,11 @@ use qdrant_client::qdrant::PointStruct;
 use qdrant_edge::EdgeShard;
 use qdrant_edge::internal::SnapshotManifest;
 use qdrant_edge::{
-    Condition, Distance, EdgeConfig, EdgeVectorParams, FieldCondition, Filter,
-    JsonPath, NamedQuery, PointId, PointInsertOperations, PointOperations,
-    PointStruct as EdgePoint, PointStructPersisted, QueryEnum, QueryRequest,
-    Range, ScoringQuery, UpdateOperation, Vectors, WithPayloadInterface,
-    WithVector,
+    Condition, Distance, EdgeConfigBuilder, EdgeVectorParamsBuilder,
+    FieldCondition, Filter, JsonPath, NamedQuery, PointId, PointInsertOperations,
+    PointOperations, PointStruct as EdgePoint, PointStructPersisted, QueryEnum,
+    QueryRequest, Range, ScoringQuery, UpdateOperation, Vectors,
+    WithPayloadInterface, WithVector,
 };
 use serde_json::json;
 
@@ -21,25 +21,15 @@ const VECTOR_DIMENSION: usize = 4;
 const VECTOR_NAME: &str = "my-vector";
 
 fs_err::create_dir_all(MUTABLE_SHARD_DIR)?;
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: Default::default(),
-};
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .build();
 
 let mutable_shard = EdgeShard::new(
     Path::new(MUTABLE_SHARD_DIR),

qdrant-landing/content/documentation/headless/snippets/edge/synchronization-guide/rust.rs

@@ -7,11 +7,11 @@ use qdrant_client::qdrant::PointStruct;
 use qdrant_edge::EdgeShard;
 use qdrant_edge::internal::SnapshotManifest;
 use qdrant_edge::{
-    Condition, Distance, EdgeConfig, EdgeVectorParams, FieldCondition, Filter,
-    JsonPath, NamedQuery, PointId, PointInsertOperations, PointOperations,
-    PointStruct as EdgePoint, PointStructPersisted, QueryEnum, QueryRequest,
-    Range, ScoringQuery, UpdateOperation, Vectors, WithPayloadInterface,
-    WithVector,
+    Condition, Distance, EdgeConfigBuilder, EdgeVectorParamsBuilder,
+    FieldCondition, Filter, JsonPath, NamedQuery, PointId, PointInsertOperations,
+    PointOperations, PointStruct as EdgePoint, PointStructPersisted, QueryEnum,
+    QueryRequest, Range, ScoringQuery, UpdateOperation, Vectors,
+    WithPayloadInterface, WithVector,
 };
 use serde_json::json;
 
@@ -29,25 +29,15 @@ pub async fn main() -> anyhow::Result<()> {
     const VECTOR_NAME: &str = "my-vector";
 
     fs_err::create_dir_all(MUTABLE_SHARD_DIR)?;
-    let config = EdgeConfig {
-        on_disk_payload: true,
-        vectors: HashMap::from([(
-            VECTOR_NAME.to_string(),
-            EdgeVectorParams {
-                size: VECTOR_DIMENSION,
-                distance: Distance::Cosine,
-                on_disk: Some(true),
-                quantization_config: None,
-                multivector_config: None,
-                datatype: None,
-                hnsw_config: None,
-            },
-        )]),
-        sparse_vectors: HashMap::new(),
-        hnsw_config: Default::default(),
-        quantization_config: None,
-        optimizers: Default::default(),
-    };
+    let config = EdgeConfigBuilder::new()
+        .on_disk_payload(true)
+        .vector(
+            VECTOR_NAME,
+            EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, Distance::Cosine)
+                .on_disk(true)
+                .build(),
+        )
+        .build();
 
     let mutable_shard = EdgeShard::new(
         Path::new(MUTABLE_SHARD_DIR),

qdrant-landing/content/documentation/headless/snippets/edge/synchronization-patterns/generated/initialize-edge-shard/rust.md

@@ -3,25 +3,15 @@ const VECTOR_DIMENSION: usize = 4;
 const VECTOR_NAME: &str = "my-vector";
 
 fs_err::create_dir_all(SHARD_DIRECTORY)?;
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: qdrant_edge::Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: Default::default(),
-};
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, qdrant_edge::Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .build();
 
 let edge_shard = EdgeShard::new(
     Path::new(SHARD_DIRECTORY),

qdrant-landing/content/documentation/headless/snippets/edge/synchronization-patterns/generated/rust.md

@@ -10,7 +10,7 @@ use qdrant_client::Qdrant;
 use qdrant_edge::EdgeShard;
 use qdrant_edge::internal::SnapshotManifest;
 use qdrant_edge::{
-    EdgeConfig, EdgeVectorParams, PointId, PointInsertOperations,
+    EdgeConfigBuilder, EdgeVectorParamsBuilder, PointId, PointInsertOperations,
     PointOperations, PointStruct as EdgePoint, PointStructPersisted,
     UpdateOperation, Vectors,
 };
@@ -88,25 +88,15 @@ const VECTOR_DIMENSION: usize = 4;
 const VECTOR_NAME: &str = "my-vector";
 
 fs_err::create_dir_all(SHARD_DIRECTORY)?;
-let config = EdgeConfig {
-    on_disk_payload: true,
-    vectors: HashMap::from([(
-        VECTOR_NAME.to_string(),
-        EdgeVectorParams {
-            size: VECTOR_DIMENSION,
-            distance: qdrant_edge::Distance::Cosine,
-            on_disk: Some(true),
-            quantization_config: None,
-            multivector_config: None,
-            datatype: None,
-            hnsw_config: None,
-        },
-    )]),
-    sparse_vectors: HashMap::new(),
-    hnsw_config: Default::default(),
-    quantization_config: None,
-    optimizers: Default::default(),
-};
+let config = EdgeConfigBuilder::new()
+    .on_disk_payload(true)
+    .vector(
+        VECTOR_NAME,
+        EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, qdrant_edge::Distance::Cosine)
+            .on_disk(true)
+            .build(),
+    )
+    .build();
 
 let edge_shard = EdgeShard::new(
     Path::new(SHARD_DIRECTORY),

qdrant-landing/content/documentation/headless/snippets/edge/synchronization-patterns/rust.rs

@@ -9,7 +9,7 @@ use qdrant_client::Qdrant;
 use qdrant_edge::EdgeShard;
 use qdrant_edge::internal::SnapshotManifest;
 use qdrant_edge::{
-    EdgeConfig, EdgeVectorParams, PointId, PointInsertOperations,
+    EdgeConfigBuilder, EdgeVectorParamsBuilder, PointId, PointInsertOperations,
     PointOperations, PointStruct as EdgePoint, PointStructPersisted,
     UpdateOperation, Vectors,
 };
@@ -100,25 +100,15 @@ pub async fn main() -> anyhow::Result<()> {
     const VECTOR_NAME: &str = "my-vector";
 
     fs_err::create_dir_all(SHARD_DIRECTORY)?;
-    let config = EdgeConfig {
-        on_disk_payload: true,
-        vectors: HashMap::from([(
-            VECTOR_NAME.to_string(),
-            EdgeVectorParams {
-                size: VECTOR_DIMENSION,
-                distance: qdrant_edge::Distance::Cosine,
-                on_disk: Some(true),
-                quantization_config: None,
-                multivector_config: None,
-                datatype: None,
-                hnsw_config: None,
-            },
-        )]),
-        sparse_vectors: HashMap::new(),
-        hnsw_config: Default::default(),
-        quantization_config: None,
-        optimizers: Default::default(),
-    };
+    let config = EdgeConfigBuilder::new()
+        .on_disk_payload(true)
+        .vector(
+            VECTOR_NAME,
+            EdgeVectorParamsBuilder::new(VECTOR_DIMENSION, qdrant_edge::Distance::Cosine)
+                .on_disk(true)
+                .build(),
+        )
+        .build();
 
     let edge_shard = EdgeShard::new(
         Path::new(SHARD_DIRECTORY),