v3.0.1

Release date: September 9, 2026

We are excited to announce the release of Milvus v3.0.1! This release adds REST v2 snapshot management, expanded reranking capabilities, and TEXT field support in the Go client and RESTful API, alongside performance improvements and fixes for Storage V3, data consistency, and security.

Features improvements

• Added REST v2 APIs for collection-scoped native snapshot management and asynchronous restoration (#52118, #52172)
• Added a configurable result-count threshold to control Take output path selection for search and query operations (#52437)
• Added TEXT field support to the Go client and RESTful API (#52450)
• Added configurable initial and maximum read IOPS rates for External Tables (#52503)
• Added an opt-in setting for external collection refresh jobs to wait until all segments are indexed before reporting completion, without delaying data publication (#52712)
• Added L1 reranking support to search function chains (#52745)
• Added weighted RRF reranking with optional per-ANN-request weights across FunctionScore, REST, legacy hybrid search, and the Go client (#52891, #52926)

Stability improvements

• Improved memory safety in geometry RTree indexes and caches, and handling of unparseable WKB and empty-geometry queries (#51312)
• Improved memory management by restoring process-wide transient-memory budgeting and correcting memory estimates for concurrent Storage V2/V3 field loading and scalar V3 index loading (#51405)
• Reduced download bottlenecks and memory usage during external-collection index builds by parallelizing reads and streaming raw vector data to disk (#51651)
• Improved Woodpecker throughput for small-batch, high-concurrency workloads by batching client appends and exposing synchronization settings (#51810)
• Improved record-reader ownership and lifetime consistency, empty-blob handling, and read-error reporting across storage and compaction paths (#51891)
• Improved grouping hash-probe efficiency with a four-way interleaved pipeline and safeguards for collisions and rehash boundaries (#51977)
• Reduced insert processing overhead by skipping WAL insert-body parsing for collections without BM25 or MinHash output fields (#51986)
• Improved storage failure reporting and retry handling by preserving transient and permanent error classifications across execution layers (#51990)
• Improved spatial query performance by enabling GIS coarse/refine splitting and same-column predicate fusion by default (#52008)
• Improved text-indexing and JSON-shredding task scheduling with shared backlog-based admission control and alternating submission priority (#52010)
• Added mmap support for sealed segment offset mappings, with dedicated loading options and disk resource accounting (#52035)
• Optimized Storage V2 data loading by running per-column chunk memory estimation on demand (#52037)
• Added server-side AutoIndex support for indexes bound to new function output fields, allowing add_function_field requests to omit index parameters or specify AUTOINDEX (#52109)
• Reduced QueryNode distribution report payloads through incremental reporting with full-report fallback, and reduced memory allocations during metrics collection (#52111, #52119)
• Improved password hashing strength by increasing the bcrypt cost from 4 to 10, with credential rotation required to upgrade existing hashes (#52145)
• Reduced redundant decoding during Parquet imports by reading only the required leaf columns for struct array subfields (#52224)
• Improved force-merge grouping with multi-round size-based planning and deprecated the legacy planning threshold setting (#52242)
• Upgraded cgosymbolizer to prevent Milvus processes running as PID 1 from hanging after native faults (#52299)
• Improved row-count validation for semantic highlighting inputs (#52409)
• Improved import retry control with configurable backoff for write retries (#52414, #52415, #52427)
• Improved analysis task lifecycle management by reclaiming stale statistics versions and persisting terminal states (#52416, #52417)
• Improved segment lifecycle coordination by waiting for segment release after lock timeouts (#52422)
• Improved storage sorting for data compaction with a k-way merge (#52429)
• Reduced nullable-field validity buffer expansion by preserving packed masks across chunk access, expression evaluation, and JSON statistics (#52451)
• Improved protection of sensitive credentials, API keys, RBAC password hashes, and external collection source details by preventing their exposure in logs or error messages (#52487, #52664, #52710)
• Improved partial-update concurrency control with optimistic CAS validation and safe retries for eligible conflicts (#52495)
• Improved growing segment read snapshot stability and schema snapshot lifetime management (#52572)
• Reduced redundant scans of authorization metadata during backups (#52612)
• Improved nullable vector ID mapping by moving it into the index layer, unifying logical ID handling and supporting mmap-backed mappings for sealed indexes (#52657)
• Improved synchronization between Sonic JIT compilation and Go plugin loading in CPU and GPU builds (#52738)
• Improved Proxy write-path channel resolution through the metadata cache, eliminating redundant coordinator RPCs and improving error classification (#52739)
• Reduced recall calculation time from approximately 3.08 seconds to 18.5 milliseconds at topk=100000 in the reported benchmark (#52763)
• Optimized nullable-field filtering by reusing validity bitmaps, reducing redundant null-offset storage, and accelerating bitset copies (#52801, #52823, #52825)
• Improved hybrid scalar indexes on nested struct subfields by using STL_SORT when distinct element counts reach the bitmap cardinality limit (#52849)
• Improved the efficiency of segment ID filtering in the metadata cache (#52855)
• Reduced memory allocations in hash helper functions (#52857)
• Optimized sorting of merged rerank results by eliminating per-comparison map lookups (#52885)
• Improved memory safety when handling JSON default values and non-NUL-terminated string views (#52906)
• Improved C++ build times with scoped unity compilation, improved compiler caching, and reduced redundant compilation work (#52995)
• Improved filesystem metrics coverage and freshness by collecting metrics from cached filesystems at scrape time while preserving existing metric names and labels (#53026)
• Added a refreshable growingBuildThreadRate setting to configure threads per growing segment interim index build while retaining the single-threaded default (#53033)
• Added mmap field-data writeback support to 3.0 through a backport, with the disabled-by-default queryNode.mmap.writeback o...

Release note is coming soon...## v2.6.23

Release date: August 28, 2026

We are excited to announce the release of Milvus v2.6.23! This release strengthens security and reliability, reduces query and compaction overhead, and improves streaming operations.

Improvements

• Hardened geometry RTree indexes and caches against double frees, invalid memory access, and out-of-bounds writes (#51103)
• Improved Tantivy build portability by discovering Cargo through CMake and tracking actual library artifacts in build dependencies (#51585)
• Batched QueryCoord metadata updates for streaming QueryNode replica recovery and cleanup to reduce transaction overhead while preserving consistency (#52110)
• Pinned the Linux OpenBLAS pthread recipe and enabled runtime CPU dispatch to avoid generic ARMv8 kernels on AWS Graviton4 and Neoverse-V2 (#52129)
• Strengthened newly generated password hashes by increasing bcrypt cost from 4 to 10, with credential rotation required to replace existing legacy hashes (#52146)
• Upgraded cgosymbolizer to prevent processes running as PID 1 from hanging after native faults (#52300)
• Preserved original message-pack boundaries for insert and upsert processing while retaining bounded batching for delete-only packs (#52364)
• Strengthened access control by enforcing the GetStatistics privilege for partition statistics requests (#52466)
• Prevented sensitive credentials and values from appearing in logs and error messages (#52488)
• Aligned interim index creation with the target index version (#52492)
• Reduced memory allocations and comparison overhead during compaction with a k-way merge implementation (#52496)
• Reduced memory overhead for nullable fields by preserving packed validity bitmaps during data access and query execution (#52576, #52627)
• Improved storage thread pool scaling during task bursts while avoiding unnecessary worker creation when idle capacity was sufficient (#52718)
• Moved BM25 function execution before WAL append and improved function runner lifecycle handling while preserving legacy-message compatibility (#52753)
• Accelerated recall calculation by approximately 166× in the reported topk=100,000 benchmark by replacing nested loops with a hash set (#52761)
• Optimized nullable-field query hot paths with shared validity bitmaps and improved index memory accounting (#52824)
• Reduced redundant vector copies in string and JSON query paths and preserved pinned string-view lifetimes (#52826)
• Added the X-Milvus-Trace-Id header to REST v1 and v2 responses to correlate requests with server logs (#52850)
• Removed the /expr runtime introspection endpoint, its web executor, and the associated configuration and expression library dependency to reduce security exposure (#52912)
• Improved synchronization between Sonic JIT registration and Go plugin loading and adjusted linker flags for Go 1.26 compatibility in CPU and GPU builds (#52919)

Bug fixes

• Fixed an issue where a standby MixCoord could exit after promotion because of an invalid etcd authentication token (#51926)
• Fixed an issue where standalone shutdown could hang while waiting for data migration, with a configurable migration timeout defaulting to 10 seconds (#52026)
• Fixed an issue where sealed segment balancing stopped progressing with Streaming Service enabled (#52148, #52168)
• Fixed an issue where REST v2 hybrid searches ignored partitionNames and searched the entire collection (#52183)
• Fixed an issue where searches, queries, and statistics requests could be routed to the previous collection after an alias was repointed (#52334)
• Fixed issues with ArrayOfVector and timezone-aware searches, optimized struct-array Parquet imports, and improved garbage collection and segment release reliability (#52455)
• Fixed out-of-range errors when highlighting nullable or dynamic text fields and added configurable backoff for import write retries (#52456)
• Fixed an issue where Milvus 2.6 accepted the unsupported Text data type (#52485)
• Fixed an issue where newly built encrypted V3 packed scalar and text-match indexes could not be decrypted or loaded (#52508, #52516, #52560)
• Fixed missing results in grouped vector searches after deletions and reinserts left leading chunks empty (#52663)
• Fixed an issue where streaming gRPC requests could bypass authentication on the external proxy port (#52858)

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