Configuration

EdgeConfig describes the vectors an Edge Shard stores and the parameters that govern how it indexes, stores, and searches them. Pass it to create/new when starting a new shard, and optionally to load when reopening one.

Every parameter except vectors and sparse_vectors is optional. A parameter left unset is considered as not specified rather than set to the default: when loading an existing shard, each unspecified parameter resolves through provided - persisted in edge_config.json - derived from the existing segments - default, so it keeps whatever the shard already has. This is why a configuration that sets only wal_options leaves the rest of the shard’s configuration untouched.

EdgeConfig

EdgeConfig(
    vectors: Optional[Union[EdgeVectorParams, Dict[str, EdgeVectorParams]]] = None,
    sparse_vectors: Optional[Dict[str, EdgeSparseVectorParams]] = None,
    on_disk_payload: Optional[bool] = None,
    hnsw_config: Optional[HnswIndexConfig] = None,
    quantization_config: Optional[QuantizationConfigType] = None,
    optimizers: Optional[EdgeOptimizersConfig] = None,
    max_search_threads: Optional[int] = None,
    search_pool_core: Optional[int] = None,
)

In Rust, EdgeConfig is a struct whose fields you can set directly, or build with the fluent EdgeConfig::builder():

let config = EdgeConfig::builder()
    .vector("text", EdgeVectorParams::builder(384, Distance::Cosine).build())
    .on_disk_payload(true)
    .build();

A new shard must define at least one of vectors or sparse_vectors; both are validated against the existing segments on load. Python raises ValueError if both are empty, so changing only a tunable parameter still requires redeclaring the vectors. Rust accepts a tunables-only configuration and takes the vectors from the shard.

Dense Vector Parameters

EdgeVectorParams configures one named dense vector. size and distance are required and cannot be changed after the shard is created.

EdgeVectorParams(
    size: int,
    distance: Distance,
    on_disk: Optional[bool] = None,
    multivector_config: Optional[MultiVectorConfig] = None,
    datatype: Optional[VectorStorageDatatype] = None,
    quantization_config: Optional[QuantizationConfigType] = None,
    hnsw_config: Optional[HnswIndexConfig] = None,
)

pub fn builder(size: usize, distance: Distance) -> EdgeVectorParamsBuilder

Sparse Vector Parameters

EdgeSparseVectorParams configures one named sparse vector. All parameters are optional.

EdgeSparseVectorParams(
    full_scan_threshold: Optional[int] = None,
    on_disk: Optional[bool] = None,
    modifier: Optional[Modifier] = None,
    datatype: Optional[VectorStorageDatatype] = None,
)

pub fn builder() -> EdgeSparseVectorParamsBuilder

Optimizer Parameters

EdgeOptimizersConfig controls what the optimize method does when you call it.

EdgeOptimizersConfig(
    deleted_threshold: Optional[float] = None,
    vacuum_min_vector_number: Optional[int] = None,
    default_segment_number: Optional[int] = None,
    max_segment_size: Optional[int] = None,
    indexing_threshold: Optional[int] = None,
    prevent_unoptimized: Optional[bool] = None,
)

In Rust, set the fields you need and leave the rest at their defaults:

pub struct EdgeOptimizersConfig {
    pub deleted_threshold: Option<f64>,
    pub vacuum_min_vector_number: Option<usize>,
    pub default_segment_number: Option<usize>,
    pub max_segment_size: Option<usize>,
    pub indexing_threshold: Option<usize>,
    pub prevent_unoptimized: Option<bool>,
}

let optimizers = EdgeOptimizersConfig {
    indexing_threshold: Some(20_000),
    ..Default::default()
};

optimize

Applies the optimizer parameters above: removes data marked for deletion, merges segments, and builds indexes. Qdrant Edge has no background optimizer, so optimization happens only when you call this method. It runs synchronously and blocks until no further optimization is planned.

def optimize(self) -> bool

pub fn optimize(&self) -> OperationResult<bool>

Returns True if any segment was optimized, and False if the shard was already optimal.

Call optimize at a point when blocking is acceptable, such as after a batch of upserts or during an idle period. Until it runs, newly written vectors are searchable but not yet indexed, which shows up as an indexed_vectors_count below points_count in info.

WAL Options

Rust only

Qdrant Edge records every update in a write-ahead log before applying it to storage. WalOptions is available in Rust only, and is set through EdgeConfig.wal_options.

pub struct WalOptions {
    pub segment_capacity: usize,
    pub segment_queue_len: usize,
    pub retain_closed: NonZeroUsize,
}

The WAL file is pre-allocated to segment_capacity, which inflates backup sizes and OS storage reports. Reduce it for embedded and mobile deployments where 32 MiB is too large. Refer to Custom WAL Size.

Change Configuration on a Live Shard

Update a shard’s configuration after it has been opened and persist the change to edge_config.json. Rust only.

pub fn set_hnsw_config(&self, hnsw_config: HnswConfig) -> OperationResult<()>
pub fn set_vector_hnsw_config(&self, vector_name: &str, hnsw_config: HnswConfig) -> OperationResult<()>
pub fn set_optimizers_config(&self, optimizers: EdgeOptimizersConfig) -> OperationResult<()>

Changes apply to work done after the call. Existing segments converge to the new parameters as the optimizers run.