v2.6.22

Release date: August 4, 2026

We are excited to announce the release of Milvus v2.6.22! This release improves QueryNode efficiency, coordinator reliability, storage compaction, and GIS query performance. It also fixes GIS and JSON query accuracy issues, encrypted-storage access failures, and monitoring compatibility regressions.

Improvements

• Reduced redundant bulk-delete replay and timestamp-column pinning during delete application in QueryNode (#51754)
• Improved MixCoord shutdown ordering by retaining its shared etcd session until all child coordinators stopped (#51771)
• Reduced QueryNode distribution report payloads by sending incremental segment and channel updates to QueryCoord (#51881)
• Improved DataNode and QueryNode efficiency by reusing precomputed BM25 function outputs while preserving BM25 statistics collection (#51927)
• Improved DataCoord compaction by enabling storage-version compaction by default (#51946)
• Optimized GIS queries by enabling split and fusion optimization by default, reducing query latency by up to 9.31x in measured cases (#52009)

Bug fixes

• Fixed incorrect GIS filtering and boost rescore results for queries using offset input, large segments, or growing segments (#50751, #51487)
• Fixed incorrect JSON query results and integer precision loss in mixed-type IN, NOT IN, and combined filter expressions (#51556, #51627)
• Fixed RESTful v2 Function DDL requests continuing to execute after parameter validation failed (#51699)
• Fixed stats and compaction text-index builds failing to access encrypted storage because worker tasks lacked cipher context (#51759)
• Fixed geometry queries on growing segments failing when visible rows spanned multiple chunks (#51882)
• Fixed changed Proxy metric status labels causing existing dashboards and alerts to stop matching failed or rejected requests (#51909)

v3.0.0

Release date: July 29, 2026

Milvus 3.0.0 is officially released! Building on the lake-native architecture introduced in 3.0-beta, this release completes what the beta started: External Collection covers more lakehouse workflows; schema supports online add / backfill / drop; the sparse index is rebuilt around SINDI; StructArray and faceted search round out the retrieval engine; FAISS passthrough, and TEXT extend index and modality choices; and Woodpecker runs as a standalone service.

If you are new to the 3.0 line, the Core 3.0 features recall section below summarizes the capabilities introduced in 3.0-beta; the 3.0-beta release notes have the full write-ups.

What's new in 3.0.0 (since 3.0-beta)

External Collection: more complete lakehouse workflows

3.0-beta introduced External Collection: reference lake files in place, build indexes, and search them without copying data into Milvus. This release extends it toward complete lakehouse retrieval workflows. External fields can now feed function output fields such as BM25 sparse vectors, MinHash signatures, and text embeddings, so text and model-derived retrieval fields are built inside Milvus without copying the source table. Refresh also supports additive schema evolution: when the external table gains new columns, Milvus patches the affected segments instead of rebuilding the collection.

This release also adds a milvus-table external format that treats Milvus Snapshot metadata and Storage V3 manifests as an external source, so a collection snapshot can itself be served as an external table — batch and serving systems get a shared, manifest-backed view of the same data.

For more information, refer to Create an External Collection and Snapshots.

Flexible schema: add, backfill, and drop columns online

Schemas do not stay static in production — embedding models get replaced, features iterate, fields get deprecated — and these used to mean full-collection rebuilds with downtime or double-writes. 3.0.0 closes the loop: columns can be added, filled, and dropped while serving continues.

Backfill works in both directions. External backfill handles values computed outside Milvus: add a column, snapshot the collection as a consistent starting point, run the job offline, write the values back, and Milvus indexes the new column incrementally — an embedding-model upgrade across hundreds of millions of rows becomes a hot path with no downtime. Inner backfill covers kernel-derived values: attach a BM25 or MinHash function to an existing collection and its output field is computed over existing data automatically.

For more information, refer to Add Fields to an Existing Collection.

Sparse index overhaul: SINDI, Block-Max WAND, and Block-Max MaxScore

Milvus 3.0 upgrades the sparse vector index across the board. It introduces new search algorithms — SINDI, Block-Max WAND, and Block-Max MaxScore — along with inverted-list compression, configurable quantization, and per-workload search-algorithm selection. mmap loading, serialization, and BM25 scoring are also optimized, cutting index storage and loading overhead for large-scale sparse vector and full-text search. In internal benchmarks, the compressed BM25 index is roughly 3x smaller than the 2.6 sparse index at comparable recall, and SINDI reaches up to about 10x the QPS of MaxScore on learned sparse embeddings. Once the new index version is enabled (see Compatibility and behavior notes), SINDI is the default for sparse IP search, and MaxScore is the default for BM25.

StructArray coverage

StructArray now supports null values, bitmap indexes, dynamic field addition on live collections, and partial update of struct fields through upsert, with REST and bulk-import coverage to match.

Element-level search adds hybrid search across vector sub-fields with configurable per-entity collapse (max / sum / avg / top-k variants), plus range search and group-by within it. Nested filtering covers element_filter predicates, the MATCH_ANY / MATCH_ALL / MATCH_LEAST / MATCH_MOST / MATCH_EXACT quantifiers, positional sub-field access such as tags[0][name], and array_length() on the struct column.

For more information, refer to StructArray and StructArray Operators.

Search Aggregation and faceted search

Query Aggregation from the beta computes exact statistics over filtered data; 3.0.0 adds faceting on the search path. Specify a facet field at search time and Milvus returns the top facet values, each represented by its best-matching member in ANN ranking and annotated with aggregates such as COUNT and AVG — the faceted-search sidebar (brand, price range, attributes) in one request, instead of over-fetching and counting client-side.

Function Chain reranking

Reranking is now composable through the Function Chain API, which executes an ordered, typed pipeline as part of a single search request. A chain can combine early L0 rescoring on QueryNode with L2 post-reduction reranking on Proxy, supporting score transformation and combination, model-based reranking, sorting, and candidate trimming without client-side orchestration. This release also adds native XGBoost scoring for L0 reranking using UBJ models registered as FileResources, along with Hugging Face Inference Providers for server-managed text embedding and sentence-similarity reranking.

TEXT long-text fields

TEXT fields make long text first-class, with storage-side length limits removed: they support text_match, phrase_match, and BM25. Values under 64 KB stay inline; larger values go to partition-level LOB files in Vortex format, with the column storing only (file_id, offset) references. LOB files are shared across segments, so compaction moves references instead of rewriting text. For RAG this means retrieving vectors and source text from the same store in one IO — no external blob store to operate.

FAISS index passthrough

A new FAISS index type accepts arbitrary Faiss index-factory strings through the faiss_index_name parameter — IVF64,Flat, HNSW16,Flat, OPQ16,IVF64,PQ16x4 — with search parameters passed through, so Faiss recipes reproduce directly on Milvus.

Vortex and Lance format support

The storage layer gains two open columnar formats: Vortex as the next-generation internal format — adaptive encodings (dictionary, RLE, bit-packing, float-specific compression), zero-copy decompression, optimized for mixed vector + scalar workloads — and Lance alongside Parquet for open-ecosystem interchange. Vortex is set to become the default internal format, with filter pushdown and a local variant on the roadmap.

Woodpecker standalone deployment

Woodpecker, the WAL at the core of the streaming write path, can now be deployed as an independent service instead of embedded in other nodes — independent scaling, fault isolation, and observability, like any other microservice. This matters most for large clusters and high-write workloads.

Core 3.0 features recall

The features below were introduced in 3.0-beta and are part of 3.0.0; see the beta notes for the full write-ups.

• External Collection — query lakehouse data (Parquet, Lance, Iceberg, Vortex) in place: zero-copy, read-only, synced through incremental refresh.
• Snapshot — point-in-time read-only collection views by segment reference, with near-zero marginal storage.
• Storage V3 (Loon) — manifest-based columnar storage on object storage; the foundation for Snapshot and External Collection.
• Query / Search ORDER BY — server-side multi-field sorting with per-field ASC / DESC.
• Query Aggregation — COUNT / SUM / AVG / MIN / MAX with group-by, evaluated server-side.
• EmbList + DiskANN — on-disk multi-vector indexing for StructArray embedding lists, with acceleration paths such as Muvera and Lemur.
• MinHash function (doc-in, doc-out) — server-side MinHash signatures plus MINHASH_LSH for near-duplicate detection.
• Nullable vectors — NULL on all six vector types; search skips NULL rows, and AddField extends to vector fields.
• Entity TTL — per-row expiration driven by a TIMESTAMPTZ field.
• FileResource — cluster-managed dictionaries, synonym lists, and stop-word lists for analyzers, BM25, and Text Match.
• Force Merge — operator-triggered segment compaction, in synchronous or asynchronous mode.

Compatibility and behavior notes

• Storage V3 (Loon) is disabled by default. Features that depend on it — such as Snapshot and TEXT fields — require enabling it manually via common.storage.useLoonFFI. Storage V3 will be enabled by default in a later release.
• 2.6 → 3.0 compatibility and rollback are guaranteed — a 3.0 deployment can be rolled back to 2.6. However, once you enable or use features that change the serialized data format (for example Storage V3), rollback is no longer possible.
• New index versions are opt-in for now. Newly introduced index algorithms require manually raising the target index version (dataCoord.targetVecIndexVersion to 10, dataCoord.targetScalarIndexVersion to 4) before they take effect; a later release will enable...

v2.6.21

Release date: July 28, 2026

We are excited to announce the release of Milvus v2.6.21! This release improves task scheduling, concurrent future registration, and policy listing efficiency. It also strengthens query readiness, WAL switching, index reconstruction, compaction resilience, and GPU CAGRA search correctness.

Improvements

• Improved concurrent future registration scalability by sharding the active future manager and increasing its registration buffer (#50900)
• Improved load balancing for import, compaction, index, and statistics tasks across DataNodes by selecting the least-loaded node during scheduling (#51101)
• Reduced redundant grantee scans when listing policies containing legacy grants (#51422)

Bug fixes

• Fixed an issue where single-field group_by_fields search parameters were silently ignored, allowing unsupported BinaryVector group-by searches to return ordinary top-k results (#51159)
• Fixed an issue where collections could be reported as load-ready before their delegators were able to serve queries (#51298)
• Fixed an issue where Milvus could continue using a stale message queue type after switching WAL backends (#51552)
• Fixed text index reconstruction failures for nullable VARCHAR fields when rebuilding from scalar index data (#51630)
• Fixed an issue where DataNode could crash and enter CrashLoopBackOff when sort compaction encountered a missing binlog object (#51685)
• Fixed an issue where QueryNode could crash while releasing segments if the target worker was unavailable (#51701)
• Fixed incorrect cosine normalization for INT8 vectors in GPU CAGRA searches by upgrading Knowhere to v2.6.18 (#51766)

client/v3.0.0-beta

This is the first beta release of the Milvus Go SDK v3, targeting Milvus 3.0. It is compared against client/v2.6.5.

This is a beta release. APIs and protocol details may change before v3.0.0 GA.

Highlights

• Migrates the Go module to github.com/milvus-io/milvus/client/v3.
• Decouples the standalone client from Milvus server-side pkg modules, substantially reducing server-only transitive dependencies.
• Adds collection snapshot management and asynchronous restore workflows.
• Adds read-only external collections with manual refresh support.
• Adds search aggregation, search by primary-key IDs, query ordering, and namespace-scoped operations.
• Adds client-side telemetry and structured RPC error inspection.

Breaking Changes and Migration

• Module path: Update all imports from:

  github.com/milvus-io/milvus/client/v2

  to:

  github.com/milvus-io/milvus/client/v3

• Proto types: Applications directly using generated Milvus messages must migrate from milvus-proto/go-api/v2 to milvus-proto/go-api/v3. Although many high-level builders retain
  familiar APIs, v2 and v3 protobuf types are not interchangeable.

• Installation:

  go get github.com/milvus-io/milvus/client/v3@v3.0.0-beta

• Go version: The module’s go directive is Go 1.24.9. The client README recommends Go 1.24.12 or later.

• Telemetry behavior: Client telemetry is enabled by default. Set ClientConfig.TelemetryConfig.Enabled to false to disable heartbeat and metrics reporting.

New Features

• Collection snapshots: Added APIs to create, drop, list, and describe collection-scoped snapshots. Snapshots can be restored asynchronously to new collections, with APIs for querying
  and listing restore jobs. Snapshot data can also be pinned and unpinned to control garbage collection. (#44361, #48143)

• External collections: Added schema builders for external data sources and external-field mappings:

  • Schema.WithExternalSource
  • Schema.WithExternalSpec
  • Field.WithExternalField

  External collections can be searched and queried using standard client APIs and refreshed through RefreshExternalCollection, GetRefreshExternalCollectionProgress, and
  ListRefreshExternalCollectionJobs. (#46886, #47492, #49531)

• Search aggregation: Added bucket aggregation builders supporting multi-field keys, nested aggregations, top hits, ordering, and avg, sum, count, min, and max metrics. Results are
  returned through ResultSet.AggregationBuckets. (#50448)

• Search by primary-key IDs: Added NewSearchByIDsOption and AnnRequest.WithIDs for using existing entities as vector-search inputs. Int64 and VarChar primary keys are supported.
  (#47633)

• Namespace-scoped operations: Added WithNamespace support to Search, Hybrid Search, Query, iterators, Insert, Upsert, and Delete options. (#50153)

• Query ordering: Added QueryOption.WithOrderByFields, accepting expressions such as price:desc and name:asc. An explicit query limit is required when ordering is used. (#51173, #51220)

• Client telemetry: Added configurable collection of request counts, errors, and latency metrics, including P99 latency, recent-error tracking, periodic server heartbeats, and server-
  pushed command handling. (#47523, #47542)

• Structured RPC errors: Added public RPCError, common error sentinels, ErrorCode, and IsRetryableError. RPC errors with matching Milvus codes can now be inspected using errors.Is.

• Dynamic StructArray fields: Added Client.AddCollectionStructField and NewAddCollectionStructFieldOption, including validation and preservation of parent nullable and max_capacity
  metadata. (#50276)

• RBAC descriptions: Added user and role descriptions, role-description updates through AlterRole, and force-drop support for roles. (#50184, #50186, #47071)

• Import two-phase commit: Added REST wrappers for committing or aborting bulk-import jobs through CommitImport and AbortImport. (#50177)

• Message salvage API: Added the high-level Client.DumpMessages streaming wrapper for replication and recovery workflows. (#50343, #50574)

• MinHash: Added FunctionTypeMinHash support to the Go SDK function API. (#45322)

Improvements and Bug Fixes

• Default gRPC keepalive, reconnect, and receive-size options are now always applied before user-provided DialOptions. (#49186)
• Row-based Insert and Upsert builders now preserve row-based processing when chaining partition, namespace, partial-update, and Array-operation options.
• Client-local error, retry, crypto, concurrency, property, and type helpers replace the dependency on Milvus server packages.
• Updated the v3 protobuf, gRPC, protobuf runtime, and supporting Go dependencies.

Known Limitations

• This SDK release is intended for Milvus 3.0 beta and is not guaranteed to be compatible with Milvus 2.6 servers.
• ExportSnapshot and RestoreExternalSnapshot expose preview API contracts in this release, but the server implementation currently returns Unimplemented.
• Flush a collection before creating a snapshot if growing-segment data must be included.
• External collections are read-only; Insert, Upsert, Delete, Import, partition management, and schema alteration are not supported.
• Primary keys must remain unique across namespaces within the same collection because delete and upsert tombstones remain collection-scoped.
• Search aggregation cannot be combined with legacy group-by, offsets, or search iterators. Bracketed JSON-path expressions are not yet supported.
• Search by primary-key IDs is not supported in Hybrid Search or Search Iterator.

v2.6.20

Release date: July 14, 2026

We are excited to announce the release of Milvus v2.6.20! This release improves query scheduling and batching, index loading, filtering performance, streaming rebalancing, and observability. It also resolves correctness and reliability issues across JSON filtering, streaming recovery, text indexing, analyzer configuration, and GPU_CAGRA operations.

Improvements

• Added named C++ thread-pool activity metrics and Grafana monitoring (#50299)
• Improved QueryCoord scheduling by decoupling task dispatch from distribution polling to allow independent scheduling intervals (#50774, #50777)
• Improved QueryNode query batching by increasing the default NQ grouping limits for larger merged query batches (#50859, #50898)
• Improved index-loading resilience by safely completing pending range reads after partial failures (#50937)
• Optimized VARCHAR primary-key population when loading sealed segments (#51063)
• Improved filter execution performance by skipping null-bitmap processing for all-valid results (#51067)
• Improved channel balancing by enabling the channel-level score balancer by default and introducing a safer default threshold for channel-exclusive mode (#51132)
• Improved streaming rebalancing to trigger immediately when the primary resource group configuration changed (#51147)
• Upgraded Knowhere to v2.6.17 to prevent GPU_CAGRA operations from failing with bad_optional_access under the default ef configuration (#51209)

Bug fixes

• Fixed incorrect JSON path filter results for missing, null, or type-mismatched values (#50722, #50723)
• Fixed an issue where Marisa string indexes could fail to upload or load when the local temporary directory was missing (#50772)
• Fixed an issue where stale streaming writes could retry indefinitely after their target collection or partition was dropped (#50849, #50895)
• Fixed an issue where cluster-level load configuration could override user-specified collection replica settings without force override enabled (#50860)
• Fixed an issue where analyzer runtime settings and YAML updates were not applied to the Rust analyzer layer (#50998)
• Fixed an issue where StorageV2 text index builds could use incorrect paths for existing segment insert logs (#51002)
• Fixed an issue where DumpMessages omitted transaction data messages and produced incomplete exports (#51102)
• Fixed an issue where ARRAY containment expressions could return incorrect results for float literals (#51130)
• Fixed an issue where filters on missing nested JSON values, failed JSON casts, or out-of-range array elements could return incorrect results instead of UNKNOWN (#51135)
• Fixed an issue where streaming recovery could omit physical channels recorded in collection metadata and leave required WAL topics unavailable after startup (#51144)

v2.6.19

Release date: July 1, 2026

We are excited to announce the release of Milvus v2.6.19! This release improves text indexing, JSON handling, GPU runtime compatibility, RBAC metadata, and search result serialization. It also fixes correctness and stability issues across WAL recovery, scalar expressions, nullable fields, ArrayOfVector, group-by search, and DataCoord GC.

Improvements

• Added configurable concurrency for function runner text tokenization (#50115)
• Improved mix compaction by building text indexes inline to avoid slow QueryNode fallback index creation (#50160)
• Upgraded GPU Docker images to CUDA 12.9.1 for Ubuntu 22.04 builds and runtime (#50250)
• Added a configuration option for maximum array capacity (#50265)
• Improved S3 PutObject compatibility with OpenSSL FIPS mode by forcing CRC32C checksums (#50360, #50477)
• Added RBAC role description support across clients, APIs, and role metadata (#50526, #50535)
• Improved error handling by standardizing on merr with system and input error classification across Milvus (#50545)
• Optimized null predicate evaluation for sealed chunked fields (#50586)
• Improved JSON field handling by enabling JSON shredding by default (#50706)
• Reduced search result serialization overhead by adding an optional zero-copy path for passing search results (#50713, #50756)

Bug fixes

• Fixed an issue where RBAC grantee identifiers could collide due to truncated ID hashes (#50236)
• Fixed an issue where Kafka and RMQ WAL recovery could fail to restore checkpoints with negative sentinel message IDs (#50242)
• Fixed an issue where scalar-index-backed expression queries could return incorrect results due to cursor misalignment (#50266)
• Fixed an issue where CPU-adapted GPU CAGRA indexes could still require GPU resources during loading (#50385)
• Fixed an issue where ST_WITHIN queries on nullable GEOMETRY fields could crash standalone during concurrent schema evolution (#50437)
• Fixed an issue where AlterCollection could reject requests due to unchanged collection descriptions (#50502, #50539)
• Fixed an issue where describe_user could return empty ghost role names after repeated grant and revoke operations (#50544)
• Fixed an issue where DataCoord garbage collection could incorrectly delete text stats files that already stored full paths (#50599, #50629)
• Fixed an issue where invalid StructArray vector dimensions or element counts could be accepted (#50601)
• Fixed an issue where group-by search could return duplicate or mismatched group values when results had tied scores (#50621)
• Fixed an issue where queries using nullable fields could return incorrect results after expression rewriting (#50627)
• Fixed an issue where importing ArrayOfVector float64 data from Parquet could fail or parse vector values incorrectly (#50635)
• Fixed an issue where highlighted search results could become misaligned for nullable or empty string fields (#50637)
• Fixed an issue where ArrayOfVector EmbList indexes could be built with insufficient rows or vectors (#50727, #50765)

v2.6.18

Release date: June 5, 2026

We are excited to announce the release of Milvus v2.6.18! This release adds element-level search on Struct fields and nullable vector support, improves QueryNode and QueryCoord scheduling and stability under heavy load, and brings HTTP/2 to the Proxy REST server. It also fixes numerous correctness and stability issues across import, schema evolution, indexing, compaction, and metadata handling.

Features

Nullable vector

Vector fields can now be declared nullable, so you can insert entities whose embedding is missing or not yet generated without filling in a placeholder. NULL vectors take no extra storage and are skipped automatically during search. For more information, refer to Nullable Fields.

Element-level search on Struct fields

You can now run vector search on Struct Array fields at the granularity of individual elements instead of the whole row, with each result reporting the matched element's offset within the array. This lets a query retrieve the specific element that best matches rather than scoring the row as a whole. For more information, refer to Vector search in a StructArray field.

Improvements

• Added support for importing Arrow FixedSizeList data from Parquet into non-nullable array and dense vector fields (#49870)
• Improved QueryNode read-task scheduling and recovery behavior under heavy load with deadline-aware admission, cleanup, grouping, and metrics (#49900, #49926)
• Added HTTP/2 support for the proxy REST server, including h2c and ALPN-based TLS listeners (#49964)
• Extended Arrow IO thread pool configuration to DataNode to improve compaction and import throughput (#50100)
• Limited QueryNode delegator post-load concurrency to reduce CPU spikes during segment loading (#49769)
• Optimized QueryCoord collection filtering in ChannelDistManager and reduced temporary allocations in distribution lookups (#49927)
• Upgraded the Pulsar Go client to v0.19.0 and replaced pulsarctl admin usage with pulsaradmin (#49948)
• Optimized ReplicaManager locking to reduce cross-collection contention in QueryCoord (#49950, #49956)
• Improved REST timeout handling to safely discard late handler writes after request timeouts (#50006)
• Optimized garbage collection for dropped segment index files and metadata (#50172)

Bug fixes

• Fixed an issue where using unsupported field types as clustering keys could cause node panics (#48263)
• Fixed an issue where the stored_index_files_size metric included inactive index files (#49380)
• Fixed an issue where preempted writers could skip segment IDs by upgrading Woodpecker to v0.1.13-hotfix (#49670)
• Fixed an issue where requery requests were not pinned to the preferred replica (#49830)
• Fixed an issue where bulk imports could fail when file readers encountered a premature EOF (#49867)
• Fixed an issue where partial updates could drop dynamic field data after schema evolution (#49913)
• Fixed an issue where sealed segments could load incorrectly when non-nullable vector field data was missing (#49918)
• Fixed an issue where schema reopen could leave stale indexing references and cause indexing failures or crashes (#49935, #49937)
• Fixed an issue where dropping a collection in streaming mode could follow an incorrect cleanup order (#49962)
• Fixed an issue where BM25 sparse vector function outputs were incorrectly treated as loadable raw field data (#49975)
• Fixed an issue where QueryCoord could build query targets from dropped channel checkpoints (#50026)
• Fixed an issue where transient object storage failures could cause delta log writes in sync tasks to fail without retrying (#50030)
• Fixed an issue where retried import tasks could leave stale row counts and cause sort compaction failures (#50070)
• Fixed an issue where forced segment assignment could be incorrectly limited by the balance batch size (#50152)
• Fixed an issue where target-size manual compaction could select ineligible segments (#50159)
• Fixed an issue where replicated AlterLoadConfig operations could keep retrying after a channel was dropped and block metadata cleanup (#50162)
• Fixed an issue where sliced indexes could load incorrect sidecar files and affect indexed query behavior (#50167)
• Fixed an issue where ST_DWITHIN could panic when validating non-POINT WKT input (#50205)

Highlights

• Adds Go SDK support for nullable vector columns across dense, binary, sparse, and int8 vector types.
• Adds Array field partial update helpers for ARRAY_APPEND and ARRAY_REMOVE in upsert requests.
• Validates that vector fields added to existing collections are nullable before sending AddCollectionField requests.
• Bumps the Go SDK version constant to 2.6.5 and updates milvus-proto/go-api/v2 to v2.6.17.

New Features

• Nullable vector columns: Added nullable column constructors for vector fields: NewNullableColumnFloatVector, NewNullableColumnBinaryVector, NewNullableColumnFloat16Vector, NewNullableColumnBFloat16Vector, NewNullableColumnInt8Vector, and NewNullableColumnSparseFloatVector. These constructors accept compact non-null vector values plus validData, and validate that the values length matches the valid row count. (#49848)

• Nullable vector response decoding: FieldDataColumn now decodes nullable vector field data using ValidData for FloatVector, BinaryVector, Float16Vector, BFloat16Vector, SparseFloatVector, and Int8Vector. Null rows are preserved in the returned column while compact wire-format vector payloads are expanded back to row-aligned columns. (#49848)

• Array partial update operations: Added upsert helpers WithArrayAppend(fieldName), WithArrayRemove(fieldName), and WithFieldPartialOp(fieldName, op) for Array field partial updates. Non-REPLACE field ops are serialized into UpsertRequest.FieldOps and automatically enable partial_update for both column-based and row-based upserts. (#49328)

Bug Fixes

• AddCollectionField vector validation: AddCollectionField now validates options before sending the RPC and rejects vector fields added to existing collections unless the field is marked nullable=true, preventing invalid schema changes from reaching the server. (#49848)

• All-null sparse vector handling: Sparse vector column serialization now handles empty value sets by emitting dimension 0, allowing all-null nullable sparse vector columns to round-trip without panics or invalid dimension calculations. (#49848)

• Nullable column row counts: Added Column.ValidCount() support so nullable columns can report the number of non-null rows separately from total row count. Struct-array columns return their total length. (#49848)

Contributors

• @marcelo-cjl
• @weiliu1031

v2.6.17

Release date: May 22, 2026

We are excited to announce the release of Milvus v2.6.17! This release introduces Array field partial update operators, improves load/search isolation, and resolves several stability and query routing issues.

Improvements

• Added ARRAY_APPEND and ARRAY_REMOVE partial update operators for Array fields, exposed through both gRPC and REST upsert APIs (#49328, #49724)
• Improved load/search isolation by using separate C++ executor pools and converting SegmentLoad and ReopenSegment to async futures with proper context cancellation (#49764)

Bug fixes

• Fixed an issue where filter expression templates could not be used with string field predicates (#49703)
• Fixed an issue where stale segment distribution updates after delegator close could corrupt query routing (#49727)
• Fixed an issue where releasing a collection could leave stale replica state due to premature metadata cleanup in QueryCoord (#49730)
• Fixed an issue where transient shard errors caused replicas to be blacklisted, leading to unnecessary query failures and degraded availability (#49740, #49776)
• Fixed missing GetReplicateConfiguration RPC forwarding in the proxy service (#49810)
• Fixed a potential use-after-free crash when closing the packed writer multiple times or during compaction cleanup paths (#49816)

v2.6.16

Release date: May 14, 2026

We are excited to announce the release of Milvus v2.6.16! This release delivers major stability and performance improvements across L0 compaction, streaming node resource isolation, and proxy query failover, along with critical fixes for delete consistency, replica scaling, and rolling upgrade scenarios.

Improvements

• Increased the default L0 compaction deltalog max count from 30 to 1000 to reduce compaction backlog under high-delete workloads (#47214, #49122)
• Introduced streaming node resource group isolation, allowing replicas to be assigned strictly within their configured resource groups, plus a new RESTful config inspection endpoint (#48632)
• Rewrote sync manager's key lock dispatcher with per-key FIFO queues and semaphore backpressure for non-blocking submission and graceful shutdown (#49101)
• Added fast-fail retry capping and delegator stall detection so proxy queries failover to a healthy QueryNode immediately instead of burning the full backoff budget on a dead node (#49103)
• Allowed simultaneous pchannel increase and cluster/topology changes in replication config validation (#49214)
• Reduced proxy tail latency and memory pressure during traffic storms by fast-failing Enqueue before TSO/ID allocation and using a non-blocking edge-triggered task notifier (#49259)
• Added a $partial_update field to the proxy access log for Upsert requests, exposing both explicit and implicitly promoted partial-update flags (#49361)
• Accelerated TermExpr IN evaluation with a SIMD (AVX2/AVX512) batch filter, significantly improving query performance for IN predicates (#49427)
• Bumped Go SDK to v2.6.4 with full struct-array support (vector sub-fields, EmbeddingList search, schema validation), gRPC authority configuration, and preserved default gRPC dial options when custom DialOptions are provided (#49443)
• Upgraded lz4_flex to 0.11.6 in the Tantivy binding to remediate CVE-2026-32829 (#49507)
• Bypassed Knowhere search-pool scheduling for vector iterators to reduce per-Next overhead in iterator-heavy group-by search paths (#49547)
• Exposed Arrow IO thread pool capacity as a refreshable paramtable knob to relieve HIGH-pool stalls under heavy storage v2 read load (#49554, #49561)
• Parallelized text match index loading on QueryNode to speed up segment load for collections with text indexes (#49608)
• Bumped milvus-storage to fix non-contiguous I/O issues when reading row groups (#49613)
• Sealed growing segments under L0 compaction pressure to avoid prolonged write blocking (#49688)

Bug fixes

• Fixed silent delete loss caused by L0 compaction missing target segments due to inherited incorrect positions from imported data, and corrected DmlPosition aggregation in mix/clustering compaction (#47154, #47187, #48910)
• Fixed an issue where collections with inverted indexes failed to load due to incorrect handling of sliced index files (#48542)
• Fixed an issue where queries on nullable array fields with bitmap indexes could return incorrect results due to missing null value persistence (#49073)
• Fixed an issue where queries using NOT over templated expressions (e.g. not (field in {vals})) returned wrong results or triggered QueryNode assertion failures (#49184)
• Made config writes synchronously visible in the same process and ensured QueryCoord compliance reports Ready only after leaked segments/channels are released, preventing premature node termination during scale-down (#49212)
• Fixed an issue where L0 deltas could be incorrectly skipped, causing stale or incorrect query results (#49228)
• Fixed an internal error when using IS NULL / IS NOT NULL with ARRAY element access; the expression is now rejected at parse time with a clear validation error (#49244)
• Fixed built-in RBAC privilege groups drifting from defaults by no longer shipping them in milvus.yaml; runtime now falls through to in-code constants when not explicitly overridden (#49276)
• Fixed a collection-wide query outage triggered by replica-count changes; QueryCoord now honors withUnserviceableShards so the proxy can route through serviceable leaders while the new replica is loading (#49305, #49311)
• Fixed insert starvation that could occur when sync futures were blocked during write buffer eviction (#49331)
• Fixed an issue where schema fields like EnableNamespace were silently dropped during DDL broadcasts from rootcoord, causing downstream components to see zero values after any DDL operation (#49364)
• Improved L0 compaction to fast-finish when no matching L1/L2 segments are found (#49376)
• Fixed expression rewriter to honor the disabled expression optimization config (#49430)
• Fixed an issue where segment reopen tasks could stall in QueryCoord by routing them through the existing load segment dispatch path (#49466)
• Fixed an issue where collection alias lookups missed the proxy meta cache, causing unnecessary metadata fetches (#49513, #49548)
• Fixed streaming node resource group handling during rolling upgrades so replicas remain correctly assigned when old and new nodes coexist (#49552)
• Fixed a memory leak that occurred when search requests failed validation after placeholder parsing succeeded (#49612)
• Fixed an issue where node shutdown could hang indefinitely when WAL release was blocked (#49625)
• Fixed query visibility issues during rolling upgrades for streaming resource groups (#49629)
• Improved WAL recovery to fail fast on timetick append errors instead of hanging (#49636)
• Fixed JSON stats index build failure when binlogs were missing (#49673)
• Fixed vector index version resolution during rolling upgrades when QueryNodes did not report MaximumIndexVersion (#49675)