milvus-2.3.14

v2.3.14

Release date: Apr 29, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.14	2.3.7	2.3.6	2.3.6	2.3.5

This release focuses on improving system performance, reliability, and observability with key features. It supports RESTful APIs to execute rolling upgrades, implements task-driven collection observation, allows for configurable intervals for garbage collection (GC), and enhances the check logic.

Furthermore, it fixes bugs in RESTful v2, resolving issues such as parameter parsing errors and ineffective parameter handling. Critical bug fixes related to deadlocks and data accuracy have also been included. Additionally, performance improvements have been made when handling large numbers of segments.

Overall, these updates aim to provide a more secure, efficient, and reliable user experience.

Improvements

• Added configuration items to skip Auto ID and Partition Key checks to improve check speed.(#32671)
• Implemented the collection observer of QueryCoordV2 task-driven.(#32615)
• Supported the get sdk type by user agent in access log.(#32554)
• Supported the use of different intervals for GC scan.(#32551)
• Removed the support for the always-true expression in delete expr.(#32495)
• Allowed users to disable search optimization.(#32143)
• Added restful api for devops to execute rolling upgrade.(#31846)

Bug fixes

• Fixed the bug that the calculation precision may be different between growing index and sealed index.(#32584)
• Fixed the bug that grow task stuck when node become stopping.(#32556)
• Fixed the issue that leader view may not update when segment version did not match.(#32517)
• Fixed the bug that value in elementTypeParams not be integer in restful api.(#32362)
• Fixed dbName parameter of describeAlias request not take effect and fixed the issue which will report lack of permission when not pass the whole privileges to describe collection in restful api. (#32162)
• Fixed cp lag metrics leakage by marking channel checkpoint dropped.(#32454)
• Fixed the bug where not update segment's version in syncDistribution.(#32320)
• Fixed a bug that coordinator register blocked on ProcessActiveStandby.(#32133)
• Fixed a bug that the reduce didn't handle offset without limit and reduceStopForBest correctly.(#32087)
• Fixed a bug that not validata PlaceholderGroups before combine them.(#32045)
• Fixed a bug where acquire index meta's lock for each segment.(#31798)
• Fixed a bug that Rootcoord's stop may block in quota_center's stop.(#31824)

milvus-2.4.0

v2.4.0

Release date: April 17, 2024

Milvus version	Python SDK version
2.4.0	2.4.0

We are excited to announce the official launch of Milvus 2.4.0. Building upon the solid foundation of the 2.4.0-rc.1 release, we have focused on addressing critical bugs reported by our users, while preserving the existing functionality. In addition, Milvus 2.4.0 introduces a range of optimizations aimed at enhancing system performance, improving observability through the incorporation of various metrics, and streamlining the codebase for increased simplicity.

Improvements

• Support for MinIO TLS connections (#31396, #31618)
• AutoIndex support for scalar fields (#31593)
• Hybrid search refactoring for consistent execution paths with regular search (#31742, #32178)
• Accelerated filtering through bitset and bitset_view refactoring (#31592, #31754, #32139)
• Import tasks now support waiting for data index completion (#31733)
• Enhanced Import compatibility (#32121), task scheduling (#31475), and limits on imported file size and number (#31542).
• Code simplification efforts including interface standardization for type checking (#31945, #31857), removal of deprecated code and metrics (#32079, #32134, #31535, #32211, #31935), and normalization of constant names (#31515)
• New metrics for QueryCoord current target channel check point lag latency (#31420)
• New db label for common metrics(#32024)
• New metrics regarding the count of deleted, indexed, and loaded entities, with the inclusion of labels such as collectionName and dbName (#31861)
• Error handling improvements for mismatched vector types (#31766)
• Support for throwing errors instead of crashing when index cannot be built (#31845)
• Support for invalidating the database meta cache when dropping databases (#32092)
• Interface refactoring for channel distribution (#31814) and leader view management (#32127)
• Refactor channel dist manager interface(#31814) and Refactor leader view manager interface(#32127)
• Batch processing (#31632), adding mapping information (#32234, #32249), and avoiding usage of lock (#31787) to accelerate frequently invoked operations

Breaking Changes

• Discontinued grouping search on binary vectors (#31735)
• Discontinued grouping search with hybrid search(#31812)
• Discontinued HNSW index on binary vectors (#31883)

Bug Fixes

• Enhanced data type and value checks for queries and insertions to prevent crashes (#31478, #31653, #31698, #31842, #32042, #32251, #32204)
• RESTful API bug fixes (#32160)
• Improved prediction of inverted index resource usage (#31641)
• Resolution of connection issues with etcd when authorization is enabled (#31668)
• Security update for nats server (#32023)
• Stored inverted index files into a local storage path of QueryNode instead of /tmp (#32210)
• Addressed datacoord memory leaks for collectionInfo (#32243)
• Fixes for fp16/bf16 related bugs potentially causing system panic (#31677, #31841, #32196)
• Resolved issues with grouping search returning insufficient results (#32151)
• Adjustment of search with iterators to handle offsets in the Reduce step more effectively and ensure adequate results with "reduceStopForBest" enabled (#32088)

milvus-2.3.13

v2.3.13

Release date: Apr 7, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.13	2.3.7	2.3.5	2.3.6	2.3.5

This release aims to enhance system performance, reliability and observability with key features like improved index information retrieval, secure Minio connections via TLS, and new metrics for better monitoring.

This release has enriched the RESTful interfaces, allowing users to perform operations related to Partition and Index. Additionally, this release includes some critical bug fixes related to deadlocks and data integrity. Check the RESTful API reference for more details.

These updates aim to provide a more secure, efficient, and reliable user experience.

Improvements

• Optimized DescribeIndex performance by implementing bulk index information retrieval(#31239)(#31429)
• Improved access efficiency to formatted keys by caching the formatted key of param item(#31402)
• Add metrics for querycoord current target cp lag(#31463)
• Implemented TLS support for Minio connections(#31292)(#31619)
• Speed up target recovery after QueryCoord restart(#31449)
• Added new metrics for entities statistics(#31511)
• Implementing the API of the resultful(#30430)
• Save collection targets by batches(#31655)
• Added validation checks for the legality of field data types(#31699)

Bug Fixes

• Fixed the issue in CurrentTargetFirst/NextTargetFirst where it would generate unexpected task behavior(#31419)
• Fixed the bug that does not cause the shard leader to fail when search fails(#31450)
• Fixed a bug where nodes were marked as unreachable when get client failure(#31451)
• Fixed client error handling to enable retries for certain types of unrecoverable errors instead of directly returning them(#31452)
• Fixed an issue where the balance channel would freeze due to deadlocks(#31455)
• Fixed a bug where nodeID was not checked when updating channel checkpoints(#31508)
• Fixed the incorrect use of double buffering for entry size exceeding the max size(#31549)
• Fixed a bug where delegator's filtering removed all delete messages, making deleted messages temporarily accessible(#31587)
• Fixed a bug where the proxy's context was canceled prematurely during session revocation(#31595)
• Fixed the target observer updates manual and automatic tasks were not mutually exclusive(#31603)
• Fixed a bug where channel metadata was updated even when nodeID did not match(#31665)
• Fixed a bug where compaction tasks were not cleaned up when releasing channels(#31694)
• Fixed a bug where the injection was invalid when the queue was empty(#31819)
• Fixed a bug where channel meta mergeFlushSegment was not idempotent cause data loss(#31837)
• Fixed the bug that Datacoord session disconnects before revoking it(#31747)

milvus-2.4.0-rc.1

v2.4.0-rc.1

Release date: March 20, 2024

Milvus version	Python SDK version
2.4.0-rc.1	2.4.0

This release introduces several scenario-based features:

• New GPU Index - CAGRA: Thanks to NVIDIA's contribution, this new GPU index offers a 10x performance boost, especially for batch searches. For details, refer to GPU Index.

• Multi-vector and Hybrid Search: This feature enables storing vector embeddings from multiple models and conducting multi-vector searches. For details, refer to Multi-vector Search.

• Sparse Vectors: Ideal for keyword interpretation and analysis, sparse vectors are now supported for processing in your collection. For details, refer to Sparse Vectors.

• Grouping Search: Categorical aggregation enhances document-level recall for Retrieval-Augmented Generation (RAG) applications. For details, refer to Grouping Search.

• Inverted Index and Fuzzy Matching: These capabilities improve keyword retrieval for scalar fields. For details, refer to Index Scalar Fields and Filtered Search.

New Features

GPU Index - CAGRA

We would like to express our sincere gratitude to the NVIDIA team for their invaluable contribution to CAGRA, a state-of-the-art (SoTA) GPU-based graph index that can be used online.

Unlike previous GPU indices, CAGRA demonstrates overwhelming superiority even in small batch queries, an area where CPU indices traditionally excel. In addition, CAGRA's performance in large batch queries and index construction speed, domains where GPU indices already shine, is truly unparalleled.

Example code can be found in example_gpu_cagra.py.

Sparse Vector (Beta)

In this release, we are introducing a new type of vector field called sparse vector. Sparse vectors are different from their dense counterparts as they tend to have several magnitude higher number of dimensions with only a handful being non-zero. This feature offers better interpretability due to its term-based nature and can be more effective in certain domains. Learned sparse models such as SPLADEv2/BGE-M3 have proven to be very useful for common first-stage ranking tasks. The main use case for this new feature in Milvus is to allow efficient approximate semantic nearest neighbor search over sparse vectors generated by neural models such as SPLADEv2/BGE-M3 and statistics models such as the BM25 algorithm. Milvus now supports effective and high-performance storage, indexing, and searching (MIPS, Maximum Inner Product Search) of sparse vectors.

Example code can be found in hello_sparse.py.

Multi Embedding & Hybrid Search

Multi-vector support is the cornerstone for applications that require multi-model data processing or a mix of dense and sparse vectors. With multi-vector support, now you can:

• Store vector embeddings generated for unstructured text, image, or audio samples from multiple models.
• Conduct ANN searches that include multiple vectors of each entity.
• Customize search strategies by assigning weights to different embedding models.
• Experiment with various embedding models to find the optimal model combination.

Multi-vector support allows storing, indexing, and applying reranking strategies to multiple vector fields of different types, such as FLOAT_VECTOR and SPARSE_FLOAT_VECTOR, in a collection. Currently, two reranking strategies are available: Reciprocal Rank Fusion (RRF) and Average Weighted Scoring. Both strategies combine the search results from different vector fields into a unified result set. The first strategy prioritizes the entities that consistently appear in the search results of different vector fields, while the other strategy assigns weights to the search results of each vector field to determine their importance in the final result set.

Example code can be found in hybrid_search.py.

Inverted Index and Fuzzy Match

In previous releases of Milvus, memory-based binary search indexes and Marisa Trie indexes were used for scalar field indexing. However, these methods were memory-intensive. The latest release of Milvus now employs the Tantivy-based inverted index, which can be applied to all numeric and string data types. This new index dramatically improves scalar query performance, reducing the query of keywords in strings by ten times. In addition, The inverted index consumes less memory, thanks to additional optimizations in data compression and Memory-mapped storage (MMap) mechanism of the internal indexing structure.

This release also supports fuzzy matches in scalar filtering using prefixes, infixes, and suffixes.

Example code can be found in inverted_index_example.py and fuzzy_match.py.

Grouping Search

You can now aggregate the search results by the values in a specific scalar field. This helps RAG applications to implement document-level recall. Consider a collection of documents, each document splits into various passages. Each passage is represented by one vector embedding and belongs to one document. To find the most relevant documents instead of scattering passages, you can include the group_by_field argument in the search() operation to group results by the document ID.

Example code can be found in example_group_by.py.

Float16 and BFloat16 Vector DataType

Machine learning and neural networks often use half-precision data types, such as Float16 and BFloat16. While these data types can improve query efficiency and reduce memory usage, they come with a tradeoff of reduced accuracy. With this release, Milvus now supports these data types for vector fields.

Example code can be found in float16_example.py and bfloat16_example.py.

Upgraded Architecture

L0 Segment

This release includes a new segment called L0 Segment, designed to record deleted data. This segment periodically compacts stored deleted records and splits them into sealed segments, reducing the number of data flushes required for small deletions and leaving a small storage footprint. With this mechanism, Milvus completely separates data compactions from data flushes, enhancing the performance of delete and upsert operations.

Refactored BulkInsert

This release also introduces improved bulk-insert logic. This allows you to import multiple files in a single bulk-insert request. With the refactored version, both the performance and stability of bulk insert have seen significant improvements. The user experience has also been enhanced, such as fine-tuned rate limiting and more user-friendly error messages. In addition, you can easily access the bulk-insert endpoints through Milvus' RESTful API.

Memory-mapped Storage

Milvus uses memory-mapped storage (MMap) to optimize its memory usage. Instead of loading file content directly into memory, this mechanism maps the file content into memory. This approach comes with a tradeoff of performance degradation. By enabling MMap for an HNSW-indexed collection on a host with 2 CPUs and 8 GB RAM, you can load 4x more data with less than 10% performance degradation.

In addition, this release also allows dynamic and fine-grained control over MMap without the need to restart Milvus.

For details, refer to MMap Storage.

Others

Milvus-CDC

Milvus-CDC is an easy-to-use companion tool to capture and synchronize incremental data between Milvus instances, allowing for easy incremental backup and disaster recovery. In this release, Milvus-CDC has improved stability, and its Change Data Capture (CDC) functionality now becomes generally available.

To learn more about Milvus-CDC, refer to GitHub repository and Milvus-CDC Overview.

Refined MilvusClient Interfaces

MilvusClient is an easy-to-use alternative to the ORM module. It adopts a purely functional approach to simplify interactions with the server. Instead of maintaining a connection pool, each MilvusClient establishes a gRPC connection to the server.
The MilvusClient module has implemented most of the functionalities of the ORM module.
To learn more about the MilvusClient module, visit pymilvus and the reference documents.

milvus-2.3.12

v2.3.12

Release date: Mar 15, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.12	2.3.7	2.3.4	2.3.6	2.3.5

Milvus v2.3.12 is a bug-fix release that resolves data loss in some edge cases and includes several other minor fixes. The enhancements address the high memory usage of coordinators in instances with a large number of segments and the ARM image page size issue.

It is highly recommended to upgrade to this latest version to prevent data loss.

Bug Fixes

• [Critical] Fixed a bug that some insert data would be lost when deleteBuf memory policy is triggered (#31159)
• Fixed a bug that some duplicated segments couldn't be released after channel balancing (#31126)
• Fixed a bug that the balance checker of the Querycoord used the wrong param item for check interval (#31141)
• Fixed a bug that database info could be incorrect when describing collection with ID (#31177)

Improvements

• Change pagesize to 64k for AARCH64 platform (#31114)
• Introduce an internal API to list indexes meta and reduce memory usage during load collection (#31150)(#31163)

milvus-2.3.11

v2.3.11

Release date: Mar 8, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.11	2.3.6	2.3.4	2.3.5	2.3.5

Milvus v2.3.11 brings improvements and bug fixes aimed at enhancing performance, security, and stability. The improvements include optimized data loading, enhanced security with TLS support for Kafka connections, memory optimization, and more. Additionally, bug fixes address issues such as search/query failures, incorrect data types in outputs, and disk estimation errors. We encourage you to update to this latest version to take advantage of these enhancements and fixes.

Improvements

• Optimized JSON loading by reducing 1x memory copy (#30864)
• Implemented TLS support for Kafka connections (#30466 #30925)
• Optimized monitoring: Remove time tick delay metrics when nodes go offline (#30879)
• Optimized memory usage and loading speed for variable length data (#30900)
• Implemented support for varchar autoID in bulk insert operations (#30913)
• Added support for rate limiting for flush operations at the collection level (#29568)
• Improved compatibility for the watch DM channel request (#30954)
• Enhanced stability when reading S3 objects (#30976)
• Reduced contention for locks in the DescribeIndex operation (#30975)
• Optimized automatic balancing in QueryCoord (#30725)
• Enabled Milvus containers to run as a non-root user (#30937)
• Enhanced lock granularity in DataCoord meta (#30986)
• Enhanced memory estimation during loading by adding a load memory factor (#30999)
• Reduced memory consumption for DataNode when dealing with multiple collections (#30991)
• Optimized the connection manager in the proxy to prevent out-of-memory errors (#31009)

Bug Fixes

• Fixed search/query failed caused by passing an incorrect context and missing error handling (#30818)
• Fixed incorrect data types in the output when using the RESTful query interface (#30738)
• Fixed incorrect disk estimation when loading disk index (or index with mmap enabled) (#30948)
• Fixed the issue where redundant segments with older versions may never be released (#30953)
• Fixed the issue where incorrect disk limits may be read (#30966)
• Fixed a series of issues with the RESTful interface, such as incorrect int64 precision and failed insertion (#30873)
• Fixed panic during rolling upgrade caused by compatibility issues (#30656)
• Fixed an issue where flush and compaction were stalled due to uncleared compaction tasks in the Datanode (#30972)
• Fixed frequent lock contention in the GetCompactionTo operation, which caused channel checkpoints lag (#30965)
• Fixed the issue where Datanode failed to update channel checkpoints with multiple collections (#31024 #31082)
• Fixed insertion failures caused by frequent contention for locks (#31026)
• Fixed proxy panic caused by missing error handling (#31086)

milvus-2.3.10

v2.3.10

Release date: Feb 23, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.10	2.3.6	2.3.4	2.3.5	2.3.5

Milvus v2.3.10 is a critical patch release that follows Milvus v2.3.9, featuring several essential bug fixes. A significant fix in this release addresses the issue of missing data in hybrid search results when utilizing partition keys (issue #30607).

Users who have encountered hybrid search issues in release v2.3.5 through v2.3.9, especially those using partition key features, are highly recommended to upgrade to version v2.3.10 promptly.

Critical Bug Fixes

• Missing data in hybrid search results when utilizing partition keys (issue #30607).
• Prevented flush blockages by skipping the filling of segmentID in indexBuildCh (#30749).

Bug Fixes

• Prevented accidental deletion of original data by avoiding the use of absolute paths in ChunkCache (#30679).
• Enforced the use of virtual host for Tencent Cloud object storage (#30685).
• Updated disk usage metrics following segment release (#30707).
• Released loaded growing segments if WatchDmlChannel fails (#30745).
• Resolved a panic caused by using a nil interface in the gRPC client (#30755).

milvus-2.3.9

v2.3.9

Release date: Feb 19, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.9	2.3.6	2.3.4	2.3.5	2.3.5

Milvus 2.3.9 is a critical patch release succeeding Milvus 2.3.8, incorporating a number of vital bug fixes. Key among these is the resolution of the DiskANN construction failure issue. We strongly advise users experiencing disk index construction problems in version 2.3.8 to upgrade to version 2.3.9 without delay.

Critial Bug Fixes

• Fixed DiskANN construction failure in Milvus version 2.3.8 (#30640).
• Addressed loading failures due to inability to replace the primary key index (#30578).
• Added collectionName to the response of the ListAliases API (#30533).

milvus-2.3.8

v2.3.8

Release date: Feb 7, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.8	2.3.6	2.3.4	2.3.5	2.3.5

Milvus v2.3.8 is a minor patch release following Milvus v2.3.7. This release includes several enhancements and bug fixes. These improvements are designed to enhance system stability and observability. One of the key bug fixes is to prevent BulkInsert from getting stuck after a node restart.

Improvements

• Improved error messaging for dimension mismatch in search vectors (#30316)
• Integrated Milvus build process details, including commit information and dependency identifiers, into monitoring metrics (#29666)
• Streamlined loading strategy for segment Binlog files to optimize performance (#30348)
• Expanded BulkInsert feature to accommodate auto-incrementing primary keys for VarChar types (#30448)
• Enhanced memory estimation algorithm during data loading to prevent out-of-memory (OOM) errors (#30475)
• Eliminated extraneous log messages for cleaner logging (#30478)
• Updated to Knowhere version 2.2.4 for improved functionality (#30513)

Critical Bug Fixes

• Fixed panic error caused by watching multiple channels in the Datanodes (#30136)
• Corrected reading of index parameters from the configuration file (#30353)
• Ensured effectiveness of the db_name parameter for DescribeAlias and ListAliases operations (#30453)
• Resolved proxy startup hang-up due to improper port occupation handling (#30416)
• Refactored BulkInsert Flush process to prevent hang-ups after restart (#30439)

milvus-2.3.7

v2.3.7

Release date: Jan 29, 2024

Milvus version	Python SDK version	Java SDK version	Go SDK version	Node.js SDK version
2.3.7	2.3.6	2.3.4	2.3.5	2.3.5

Milvus v2.3.7 marks a minor yet impactful update, concentrating on boosting overall functionality and stability. In this release, we have refactored the business logic for a graceful stop to prevent any data loss, introduced support for array and JSON data types through RESTFul APIs, and amped up the speed of index loading. Alongside these enhancements, we've made several tweaks to optimize system performance and resource management. Additionally, this release addresses critical bug fixes as well as issues like memory leaks, load timeouts, and service unavailability, ensuring a more reliable and stable user experience.

Features

• Limit Collection Counts

  A Milvus instance allows up to 65,536 collections. However, too many collections may result in performance issues. Therefore, it is recommended to limit the number of collections created in a Milvus instance. Read more on Limit Collection Counts.

• Chunk Cache

  The chunk cache mechanism enables Milvus to pre-load data into cache memory on the local hard disk of the query nodes before it is needed. This mechanism significantly improves vector retrieval performance by reducing the time it takes to load data from disk to memory. Read more on Configure Chunk Cache

Improvements

• Transform specific magic numbers into configurable options (#30070).
• Remove heartbeat delay logic for ShardLeader to prevent misjudging its availability (#30085).
• When allocating channels, shuffle ShardLeader candidates to avoid load imbalance (#30089).
• Enhance RESTful support by adding functionality for arrays and JSON (#30077).
• Add a counter monitoring for rate-limited requests (#30132).
• Accelerate index loading through concurrent methods (#30018).
• Remove the step of DataNode subscribing to the message stream during the Import phase to avoid Import timeouts (#30133).
• Introduce association logic between privileges to simplify the authorization process (#30154).
• Implement unified restrictions on the number of Collections, Partitions, and Shards (#30017).
• Incorporate proactive pre-warming logic for ChunkCache to mitigate the issue of high latency when retrieving raw vectors during cold start queries (#30289)
• Optimize the load balancing algorithm by assigning weight to growing segments (#30293)
• Remove unnecessary business logic for conversions between partition names and IDs to reduce latency in the data retrieve stage when processing search requests (#30255)

Critical Bug Fixes

• Fixed a memory leak caused by incorrect usage of OpenTelemetry in the Segcore (#30068).
• Addressed the issue of slow disk index loading by dynamically patching the index parameters (#30116).
• Resolved the problem of changes made through the "alter collection" command not being persisted (#30156).
• Fixed the issue where read request rate limiting ultimately leads to the unavailability of the read service (#30196).
• Resolve the deadlock issue when getting the configuration (#30319)
• Fix incorrect usage of the Goroutine pool on CGO calls (#30275)
• Add a timeout mechanism to the graceful stop process to prevent potential cases of getting stuck(#30320)