Optimizing Vector Cluster Performance

Temporarily disable replicas during data ingestion and enable them after data ingestion is complete. Use this solution when importing historical data in batches or performing a full update (for example, when initializing a vector database).

Set the number of replicas:

PUT my_index/_settings
{
    "number_of_replicas": 0
}

Write performance is enhanced by avoiding real-time vector index building on replica nodes.

Set the index refresh interval to 120s or longer to reduce the number of small segments generated during frequent index refreshes and also reduce the vector index building overhead caused by segment merges. You can also disable automatic index refresh by setting the refresh interval to –1. Use this solution in high-throughput write scenarios (for example, when writing vectorized log data).

Set refresh_interval.

PUT my_index/_settings
{
    "refresh_interval": "120s"
}

Index refreshes occur less frequently. The reduces the number of small segments and also the overhead of segment merges, leading to enhanced write performance.

Increasing the number of threads for vector index building accelerates the indexing process. However, too many such threads will compete for query resources. Use this solution when there are sufficient CPU resources but the write latency is high—such as in GPU-accelerated environments.

The default value of native.vector.index_threads is 4. Change this value as needed.

PUT _cluster/settings
{
  "persistent": {
    "native.vector.index_threads": 8
  }
}

Vector index building is accelerated, and the performance of concurrent writes is enhanced.

After batch data ingestion, perform the force merge operation to forcibly merge segments, thus reducing the number of segments. Typically, you should perform this operation after data ingestion and before data query (for example, after a scheduled batch ingestion).

Perform the force merge operation:

POST my_index/_forcemerge?max_num_segments=1

Multiple segments are merged into a single segment. This reduces the file scanning overhead and accelerates the query speed.

During batch writes, the maximum size of segments generated by the system is 5 GB. You can increase this upper limit to reduce the number of segments generated after automatic merging. Typically, you should perform this operation before batch data ingestion starts.

Increase the maximum segment size:

PUT my_index/_settings
{
  "index.merge.policy.max_merged_segment": "10gb"
}

Increasing the maximum segment size helps to reduce the number of segments and thus accelerate query performance.

When the off-heap memory required by vector indexes exceeds the circuit breaker limit, the index cache manager frequently swaps in and out index data from the cache, which slows down queries. You can raise the circuit breaker limit to reduce circuit breaking (indicated by CircuitBreakingException recorded in the log) resulted from insufficient memory.

The default circuit breaker limit for off-heap memory is 80%. You can adjust this limit as required.

PUT _cluster/settings
{
  "persistent": {
    "native.cache.circuit_breaker.cpu.limit": "85%"
  }
}

It is less likely for vector index data to be swapped out from the memory, and query jitter is reduced.

If the query result needs to return only a few fields that are either keywords or numeric values, you can use the docvalue_fields parameter to fetch them. Use this method if only numeric or enumerated metadata (such as product IDs and class labels) needs to be fetched. It can significantly reduce overhead during the fetch phase.

Use the docvalue_fields parameter to fetch only specific fields:

POST my_index/_search
{
  "size": 2,
  "stored_fields": ["_none_"],
  "docvalue_fields": ["my_label"],
  "query": {
    "vector": {
      "my_vector": {
        "vector": [1, 1],
        "topk": 2
      }
    }
  }
}

There is no need to parse the entire _source document. Column-oriented storage (docvalues) reduces the overhead during the fetch phase and improves query performance.