Milvus Feature Trails

Feature trailActive

AI Agent Tooling and Integration

Milvus continues to evolve its integration with AI agents and tooling. This post demonstrates a practical approach to building hybrid document processing and search systems by combining LangExtract for structured data extraction with Milvus for semantic and keyword-based retrieval. The system leverages Milvus to store both vector embeddings and extracted metadata, enabling intelligent hybrid queries. This builds upon existing AI agent tooling by providing a concrete example of how to integrate external decision-making models like Jev into agentic search pipelines, comparing their performance against general-purpose LLMs for tasks like stopping decisions, memory reranking, and multi-hop graph retrieval. The evaluation highlights trade-offs in latency, cost, and recall for different agentic tasks.

15 posts · 2021–2026

Timeline

20212026

Feature trailActive

External Collection for Lake-Resident Data

Milvus 3.0 introduces External Collections, enabling Milvus to build and serve indexes directly on data residing in external data lakes (Parquet, Iceberg, Lance, Vortex) without copying it into Milvus-managed storage. This enables a "Vector Lakebase" architecture, unifying AI data serving with open lake storage. The feature maps external fields to Milvus schemas, defines indexes, and uses a "Refresh" operation to prepare the data for Milvus search and query APIs. Loon (Storage v3) is introduced as a new storage engine designed for dynamic data, offering efficient handling of data that is constantly changing, such as streaming data or frequently updated datasets. Loon aims to provide a unified storage solution for both batch and real-time data, optimizing for ingestion, querying, and indexing performance in dynamic environments.

1 post · 2021–2026

Timeline

20212026

Feature trailActive

StructArray for Entity- and Element-Level Search

Milvus 3.0 introduces StructArray for entity- and element-level search, enabling complex data modeling and filtering. This post details the addition of the Array of Structs field type and the MAX_SIM metric, allowing all embeddings for a single entity to be stored in a single record and enabling Milvus to score and return the entity holistically. This eliminates the need for application-layer deduplication, grouping, bucketing, and reranking logic for multi-vector entities. Examples include Wiki. This post elaborates on the practical application of Array of Structs and MAX_SIM for entity-level retrieval, demonstrating how to store multiple vectors and associated metadata within a single record and how the MAX_SIM metric holistically scores entities based on the best match across all their constituent vectors. It provides concrete examples for e-commerce product search and knowledge base retrieval, highlighting the elimination of application-layer deduplication and reranking.

1 post · 2025–2026

Timeline

20252026

Feature trailActive

Query Aggregation and Search Aggregation

Milvus 3.0 introduces Query Aggregation for exact statistics (count, sum, avg, min, max) with GROUP BY over filtered, visible rows, and Search Aggregation for organizing ANN candidates into buckets with per-bucket metrics and representative hits. Server-side ORDER BY is also added for sorting query results or ANN candidates by scalar fields. These features move complex post-processing logic into the retrieval engine, reducing data movement and improving accuracy for large-scale applications.

1 post · 2026

Timeline

Feature trailActive

Regex Filtering

Milvus 3.0 introduced native regex filtering (`=~`, `!~`) for string fields, moving complex pattern matching from application-side post-processing into the database query path. This post introduces JSON Shredding, which further accelerates JSON queries by transforming row-based JSON documents into highly optimized columnar storage. Milvus analyzes JSON keys to classify them into typed, dynamic, or shared categories, storing them in dedicated or dynamic columns (Arrow/Parquet) or a compact binary-JSON column with an inverted index for shared keys. This enables schema-free agility with columnar performance for semi-structured data, significantly improving query performance for both typed and sparse keys.

1 post · 2023–2026

Timeline

20232026

Feature trailActive

AI Data Storage Engine

Milvus 3.0 introduces External Collections, enabling Milvus to build and serve indexes directly on data residing in external data lakes (Parquet, Iceberg, Lance, Vortex) without copying it into Milvus-managed storage. This enables a "Vector Lakebase" architecture, unifying AI data serving with open lake storage. The feature maps external fields to Milvus schemas, defines indexes, and uses a "Refresh" operation to prepare the data for Milvus search and query APIs. Loon (Storage v3) is introduced. This post demonstrates integrating DeepSeek v3-0324 with Milvus for RAG, showcasing the model's advanced reasoning and coding capabilities and providing a practical example of building a RAG pipeline with Milvus Lite and an OpenAI-compatible API.

187 posts · 2019–2026

Timeline

20192026

Feature trailActive

Milvus Snapshots

Milvus Snapshots provide named, read-only versions of collections by recording references to existing data, index, and metadata files without copying the dataset. This enables lightweight recovery points, fast restores by reusing index files, cross-cluster movement via direct metadata URI access, and stable views for batch jobs via External Collection and Spark connector integration. Snapshots are cost-effective to create but incur storage costs based on retention and file divergence from the live collection. They do not include data in growing segments unless flushed prior to creation. Restore operations are asynchronous and non-destructive, creating new collections. Export is a fallback for when direct storage access is not possible.

1 post · 2023–2026

Timeline

20232026

Feature trailActive

Data Migration Tooling

Milvus 2.6 introduces a hot-cold tiered storage architecture for cost-effective scaling to hundreds of billions of vectors, intelligently managing data placement based on access patterns. It also features a new Streaming Node for real-time vector processing with direct integration to streaming platforms and Woodpecker, making new data searchable immediately. RaBitQ 1-bit quantization significantly reduces memory footprint (up to 97%) while improving query throughput (up to 4x) without compromising accuracy. This post details the integration of RaBitQ, a novel 1-bit vector compression technique, into Milvus, enabling it to serve 3x more queries with lower memory costs while maintaining comparable accuracy. It discusses implementation tradeoffs, hardware acceleration using AVX-512 instructions, and query optimizations.

3 posts · 2021–2026

Timeline

20212026

Feature trailActive

Multi-source File-like Search (MFS)

MFS provides a unified, file-like interface for agents to search and browse across heterogeneous data sources (code, docs, tickets, databases, SaaS tools, object stores). It combines semantic search with progressive disclosure (tree, ls, cat) to enable agents to efficiently retrieve and verify context, reducing token costs and improving accuracy. Provence and X Provence are introduced as lightweight context pruning models that can be integrated into RAG pipelines to filter irrelevant information before it reaches the LLM, improving response quality and reducing latency. Open Tag is an example application built on MFS, enabling an agent to review PRs and other work artifacts in Slack. This post details tools that enable context pruning and its evaluation.

2 posts · 2025–2026

Timeline

20252026

Feature trailActive

Force Merge Compaction

Milvus introduces Force Merge Compaction, an asynchronous operation that consolidates small, sealed segments into fewer, larger ones. This is particularly beneficial for static, read-heavy collections where a high segment count leads to increased query fan-out overhead. By reducing the number of segments, Force Merge can significantly improve search QPS and reduce latency. The operation is triggered via the `compact()` API with a `target_size` parameter, allowing operators to control the consolidation towards a target size, potentially exceeding the per-segment cap. Experiments show significant QPS gains (76-87%) and latency reduction (p99 down ~33%) on static datasets. It is recommended for quiet windows and when write activity has ceased.

1 post · 2022–2026

Timeline

20222026

Feature trailActive

Milvus Management Console (Attu)

Attu 3.0 Beta is a significant rebuild of the Milvus management console, evolving into a comprehensive operations console. Key advancements include multi-cluster management, persistent local state, an integrated AI Agent with over 50 Milvus tools for natural language operations and diagnostics, a redesigned hierarchical data browser (database -> collection -> partition), built-in Prometheus metrics dashboards, an API Playground, GUI-based backup and restore with cloud storage support, and simplified RBAC workflows.

3 posts · 2022–2026

Timeline

20222026

Feature trailActive

IVF Vector Index

Milvus 2.0 introduced the IVF vector index, a widely used algorithm for Approximate Nearest Neighbor (ANN) search. This post details its inner workings, including K-means clustering for partitioning vectors into buckets, vector assignment to inverted lists, and optional compression encoding (SQ8, PQ). It also outlines the search process: calculating distances to centroids, selecting nearest clusters based on `nprobe`, and performing exact or approximate comparisons within those clusters. Milvus 2.0 also introduced HNSWlib integration for ANN search, offering a graph-based approach with hierarchical layers and navigable small worlds for efficient similarity searches in high-dimensional spaces. HNSWlib provides features like sublinear search time, dynamic updates, and memory efficiency, making it suitable for medium-scale applications. However, for higher scalability requirements or enterprise-level features, purpose-built vector databases like Milvus are recommended.

1 post · 2019–2026

Timeline

20192026

Feature trailActive

Local AI Agent Storage and Configuration

Milvus Lite provides a lightweight, local version of Milvus for prototyping and experimentation. It allows users to create collections for storing various types of data, such as trading decisions, preferences, and market patterns. Data is embedded using models like OpenAI's text-embedding-3-small and stored in separate collections based on its type. An agent can then leverage similarity search to retrieve relevant historical data and inform decision-making. The system also includes mechanisms for local storage and configuration, enabling seamless transition to larger Milvus deployments.

1 post · 2024–2026

Timeline

20242026

Feature trailActive

Robot Long-Term Memory

Milvus powers the long-term memory tier for robot task execution systems, storing semantic information as vector embeddings for retrieval via vector similarity search, often combined with metadata filtering (hybrid search). This enables robots to adapt to environmental changes and improve future task performance. The integration with LangChain 1.0 further enhances this by providing a production-ready framework for building agents with persistent, intelligent memory, leveraging Milvus for efficient storage and retrieval. This post details how OpenAgents, a framework for distributed multi-agent collaboration, integrates with Milvus to provide a scalable, high-performance long-term memory layer for AI agent networks. Milvus enables fast semantic search, billion-scale horizontal scalability, and multi-tenant isolation through Partition Key, allowing agents to store, retrieve, and reuse knowledge effectively. The integration is achieved through custom Mods that call Milvus APIs directly, storing embedded agent messages, tool outputs, and interaction logs. Developers can customize embedding models, storage schemas, and retrieval strategies. A demo showcases a developer-support community where specialist agents collaborate using Milvus for memory, remembering past answers, reusing explanations, and improving over time.

1 post · 2023–2026

Timeline

20232026

Feature trailActive

LLM Model Comparison and Integration

Milvus continues to evolve its capabilities by integrating with and comparing various large language models. This post details Matryoshka embeddings, a technique for creating multi-scale representations within a single vector, enabling efficient similarity searches by leveraging smaller subsets of dimensions for initial searches and progressively larger subsets for reranking. This approach allows for a balance between precision and computational cost, and Milvus seamlessly supports models trained with this technique.

2 posts · 2024–2026

Timeline

20242026

Feature trailActive

Multilingual Full-Text Search

Milvus 2.5 enhances full-text search capabilities by introducing the `Function` object and `FunctionType.BM25` for generating sparse vectors from text fields. This allows for hybrid search by combining traditional semantic search with keyword-based full-text search, improving recall for keyword-specific queries. The system supports lexical parsing and tokenization for string fields, enabling efficient full-text indexing and retrieval. Milvus 2.5 also introduces Text Match filters and significant improvements to the underlying lexical search engine, offering a competitive alternative to traditional search engines like Elasticsearch for AI-native applications.

6 posts · 2024–2026

Timeline

20242026

Feature trailActive

ScaNN Index Integration

Milvus integrates the ScaNN index, a highly optimized Approximate Nearest Neighbor (ANN) search algorithm that builds upon IVFPQ. ScaNN enhances performance by employing a score-aware quantization objective to preserve ranking quality and a SIMD-optimized 4-bit PQ FastScan path to reduce memory bottlenecks. This integration allows Milvus to achieve significantly higher query throughput and a much smaller memory footprint, particularly for recall-insensitive workloads like recommendation systems.

1 post · 2026

Timeline

Feature trailActive

Milvus CDC Standby Cluster Replication

Milvus introduces built-in Change Data Capture (CDC) for primary-standby replication, enabling cluster-level and cross-region high availability. This feature streams Write-Ahead Log (WAL) entries from a primary cluster to a standby cluster, allowing for near real-time data synchronization. The standby cluster can be promoted in case of primary cluster failure, minimizing downtime and data loss. This complements node-level replication and periodic backups for a layered HA strategy. The initial implementation supports single CDC replica and does not support BulkInsert.

1 post · 2026

Timeline

Feature trailActive

Role-Based Access Control (RBAC)

Milvus's Role-Based Access Control (RBAC) system provides granular control over data access. This post details strategies for implementing multi-tenancy in RAG systems using Milvus, focusing on database-level, collection-level, and partition-level approaches. It highlights database-level multi-tenancy as often suitable for enterprise RAG knowledge bases serving distinct business units, offering strong logical isolation. For enhanced security, it introduces physical resource isolation by mapping logical components (databases, collections) to physical resources (Resource Groups, Query Nodes) to guarantee performance and prevent interference between tenants.

4 posts · 2022–2026

Timeline

20222026

Feature trailActive

Data Addressing in Storage Systems

Milvus continues to evolve its storage and indexing strategies to reduce memory costs and improve performance at scale. Building on DiskANN, AISAQ further minimizes DRAM footprint by storing all search-critical data on disk and optimizing data placement to minimize I/O operations. This enables billion-scale vector search with significantly lower memory usage while maintaining practical performance. DiskANN is available as the DISKANN index type, leveraging SSDs for cost-effective, large-scale vector search.

1 post · 2021–2026

Timeline

20212026

Feature trailActive

Purpose-Built Vector Database Comparison

Milvus continues to be a self-hosted, purpose-built vector database solution for large-scale, multi-tenant applications. This post highlights its distributed nature, independent scaling of ingestion, indexing, and query execution, and its ability to meet strict performance and availability targets. The architecture emphasizes strong tenant isolation through partitioning strategies, with a focus on balancing recall, index size, and performance through index selection (e.g., HNSW). The evaluation process used by Reddit demonstrates a rigorous approach to selecting a vector database based on specific organizational needs and engineering culture, including a strong preference for open-source solutions and robust metadata filtering capabilities.

2 posts · 2020–2026

Timeline

20202026

Feature trailActive

Business-Aware Vector Search Ranking

Milvus 2.6.2 introduces Boost Ranker, a lightweight, rule-based reranking feature that adjusts vector search results using scalar metadata fields. This allows for business context to be incorporated into search rankings without rebuilding indexes or changing embedding models. It operates entirely within Milvus, applying filters and weights to candidate results post-vector search. The feature supports boosting important results, demoting less relevant ones, and adding controlled randomness for diversity. It can be combined with other rankers like RRF or model-based rankers, and is configured via the Function API.

1 post · 2026

Timeline

Feature trailActive

Benchmarking and Performance Analysis

Milvus continues to evolve its benchmarking capabilities with VDBBench, an open-source tool designed to simulate production realities. VDBBench focuses on realistic datasets, production-focused metrics (P95/P99 latency, sustainable throughput, recall), and testing methodologies that reflect real-world scenarios like continuous ingestion, filtering, and streaming data. This aims to provide engineers with trustworthy data for infrastructure decisions, moving beyond traditional, often misleading, benchmarks. This post also details optimizations in the Milvus write path to reduce memory movement overhead.

18 posts · 2020–2026

Timeline

20202026

Feature trailActive

Geometry Field and RTREE Index for Geospatial Filtering

Milvus 2.6 introduces the Geometry Field and RTREE index, enabling the combination of geospatial filtering with vector similarity search. This allows for unified storage and querying of spatial data (Points, LineStrings, Polygons) using Well-Known Text (WKT) format and efficient spatial operators like st_contains, st_within, and st_dwithin. The RTREE index accelerates spatial filtering through Minimum Bounding Rectangles (MBRs) and a hierarchical pruning approach. This integration supports real-time hybrid search scenarios.

2 posts · 2025–2026

Timeline

20252026

Feature trailActive

S3-Compatible Object Storage Backend Evaluation

Milvus continues to support a variety of S3-compatible object storage backends. This post evaluates RustFS as a potential alternative to MinIO, detailing its architecture, compatibility with Milvus's storage requirements, and providing a hands-on guide for replacing MinIO with RustFS in a Milvus deployment. It highlights the importance of a reliable and evolving object storage layer for Milvus's decoupled architecture and explores RustFS's potential for memory safety and performance. The deployment guide covers setting up RustFS and configuring Milvus to use it.

1 post · 2026

Timeline

Feature trailActive

Hybrid GPU-CPU CAGRA Indexing

Milvus 2.6.1 introduces a hybrid GPU-CPU approach for CAGRA indexes, leveraging GPUs for accelerated graph construction and CPUs for cost-efficient, scalable query execution. This addresses the trade-offs between GPU-native CAGRA's build performance and its query-serving cost and scalability constraints. The `adapt_for_cpu` parameter allows flexible configuration for different operational scenarios, enabling scenarios like GPU-built CAGRA serialized and queried as HNSW on CPUs for cost-sensitive workloads.

1 post · 2025

Timeline

20252026

Feature trailActive

Milvus Milestones and Evolution

Milvus continues to evolve its architecture to address the complexities of manual sharding in vector databases. The focus remains on automated scaling, distributed architecture, and efficient query processing to enable seamless growth from millions to billions of vectors without operational burden. Key innovations include a segment-based architecture for data management and a two-layer routing system that dynamically distributes data across multiple nodes, eliminating the need for manual shard management. Milvus 2.5 introduced native hybrid search combining full-text and vector search. Milvus 2.6 delivered architectural improvements for cost and performance, including tiered storage, memory savings via RaBitQ 1-bit quantization, a redesigned full-text engine, Path Index for JSON-structured metadata, AiSAQ for billion-scale compression, Semantic + Geospatial Search with R-Tree, hybrid CAGRA+ Vamana indexing, a simplified data ingestion/retrieval workflow, and support for up to 100K collections in a single cluster.

3 posts · 2023–2025

Timeline

20232026

Feature trailCooling

Milvus Operator for Kubernetes Deployment

Milvus Operator simplifies the deployment and lifecycle management of Milvus clusters on Kubernetes, automating deployment, scaling, upgrades, and health checks. It abstracts away the complexity of managing individual Kubernetes resources and dependencies like etcd, Pulsar, and MinIO, allowing users to describe their desired Milvus state via Custom Resources. The Operator handles underlying orchestration and ensures reliability through continuous monitoring and self-healing.

4 posts · 2021–2025

Timeline

20212026

Feature trailCooling

Data Insertion and Persistence

Milvus 2.6 introduces Woodpecker, a cloud-native Write-Ahead Logging (WAL) system, replacing external dependencies like Kafka and Pulsar. Woodpecker features a Zero-Disk architecture, persisting logs in object storage and managing metadata with etcd. It offers high-throughput data ingestion, low-latency tail reads, pluggable storage backends, and flexible deployment modes. Benchmarks show significant performance improvements over Kafka and Pulsar, especially in cloud storage and local file systems. Milvus 2.3 introduces NATS as an alternative message queue for standalone deployments, offering improved performance for larger data packets compared to RocksMQ, and similar performance for smaller datasets.

3 posts · 2019–2025

Timeline

20192026

Feature trailCooling

Observability Platform

Milvus integrates with OpenTelemetry and Jaeger to provide end-to-end request tracing, enabling detailed performance analysis and debugging of AI-powered applications. This enhances the system's observability capabilities by allowing engineers to track requests from client applications through internal database operations.

1 post · 2025

Timeline

20252026

Feature trailCooling

ONNX Model Inference in Non-Python Languages

Milvus continues to expand its integration capabilities for AI models, enabling developers to deploy and utilize models beyond Python environments. This post introduces the use of ONNX for platform-agnostic model inference, allowing embedding and foundation models to be run directly from languages like Java, Golang, Rust, and C++. This addresses the need for local, privacy-compliant model execution without relying on Python servers. The workflow involves exporting models and tokenizers to the ONNX format using Python offline, and then leveraging ONNX Runtime and its extensions to perform inference in target languages. This capability enhances the flexibility and accessibility of integrating AI models with Milvus and other systems.

1 post · 2025

Timeline

20252026

Feature trailCooling

Vector Database for Similarity Search

Milvus continues to evolve as a purpose-built vector database for AI-native applications, moving beyond traditional SQL interfaces. The focus is on natural language and AI agent integration, enabling semantic understanding and intent-driven data retrieval. This evolution emphasizes native multimodal support, agent-friendly APIs, and optimized relevance over pure speed, positioning it as an intelligent data system for AI workloads. This post explains the fundamental concepts of vector databases, vector embeddings, and their core architectural components, including the storage, index, query, and service layers, and outlines the typical vector search workflow from data transformation to result retrieval. It also touches upon the mathematical foundations of vector similarity, including vector spaces, embeddings, and common distance metrics like Euclidean distance and cosine similarity, and highlights the limitations of simply adding a vector index to a traditional database.

1 post · 2020–2025

Timeline

20202026

Feature trailCooling

Embedding API Performance Benchmarking

Milvus provides a TextEmbedding Function interface that integrates popular embedding models, streamlining vector search pipelines. This feature enables direct comparison and benchmarking of various embedding API providers under realistic deployment scenarios, focusing on latency and network effects. The goal is to help developers optimize RAG systems and other AI applications by understanding the performance trade-offs of different embedding services. This post details the integration of dense and sparse embedding models, as well as rerankers, into PyMilvus, enabling local execution with Milvus Lite and demonstrating practical use cases.

1 post · 2024–2025

Timeline

20242026

Feature trailCooling

MinHash LSH for Deduplication

Milvus 2.6 introduces native MinHash LSH indexing for efficient approximate deduplication of large datasets. This feature allows users to generate MinHash signatures, build MINHASH_LSH indexes with Jaccard similarity, and perform similarity searches directly within Milvus. It supports in-memory and mmap-based implementations, seamless SDK integration, and leverages Milvus's distributed architecture for scalability. This enables end-to-end deduplication workflows within Milvus, reducing operation overhead and costs, particularly for LLM training data. The integration was driven by a real-world need from a leading LLM company to deduplicate billions of documents, resulting in doubled processing speed and 3-5x cost savings compared to previous MapReduce-based approaches.

1 post · 2025

Timeline

20252026

Feature trailCooling

Milvus Deployment Modes

Milvus continues to evolve its deployment and configuration guidance, focusing on optimizing performance and operational control across various components. This post details critical configuration parameters within `milvus.yaml`, categorizing them into dependency, internal, and functional configurations. It provides specific recommendations for tuning `etcd`, `minio`, `mq`, `rootCoord`, `proxy`, `queryNode`, `dataCoord`, `log`, `security`, and `quotaAndLimits` to improve performance, stability, and security in production environments. Key areas of focus include managing partitions, access logs, memory-mapped I/O, segment sizes, GC tolerances, logging verbosity, authentication, and rate limiting.

9 posts · 2020–2025

Timeline

20202026

Feature trailCooling

Milvus SDK Evolution

Milvus SDK v2 introduces a unified API across Python, Java, Go, and Node.js, native asynchronous support, a performance-boosting Schema Cache, and a simplified MilvusClient interface. The RESTful API now offers near feature parity with gRPC. The Python SDK's MilvusClient streamlines collection creation, indexing, and loading into a single operation. The MCP Server is introduced for AI integration, enabling AI agents to interact with Milvus clusters.

4 posts · 2021–2025

Timeline

20212026

Feature trailCooling

Real-time Query

Milvus 2.0 architecture enables real-time data query by orchestrating data loading, management, and query execution across various components. Data is loaded to query nodes from both streaming (log broker) and historical (object storage) sources. Query nodes manage historical data in sealed segments and incremental data in growing segments, with mechanisms for load balancing and failover. Incremental data is filtered by partition using flowgraphs. Real-time queries are processed via query messages, which include service_ts, travel_ts, and guarantee_ts for precise temporal querying. Query results undergo local and global reduction to ensure accuracy and deduplication.

4 posts · 2020–2025

Timeline

20202026

Feature trailCooling

Developer Contribution Workflow

Milvus has established a comprehensive developer contribution workflow, detailing environment setup (local build, Docker), common troubleshooting steps for build issues (Homebrew, Docker, Python, Conan, LLVM), VS Code configuration for C++/Go integration, deployment modes (Lite, Standalone, Distributed) and their core components, running End-to-End (E2E) tests, and the process of submitting pull requests by linking them to issues and following contribution guidelines. This workflow aims to streamline the process for external developers to contribute to the Milvus project.

1 post · 2024

Timeline

20242026

Feature trailQuiet since 2024

Parquet File Import

Milvus 2.3.4 introduces support for importing data directly from Apache Parquet files. This feature streamlines data ingestion by leveraging Parquet's columnar storage, efficient compression, and broad language compatibility. Users can upload Parquet files to object storage and import them into Milvus using bulk insert operations. The BulkWriter tool also defaults to generating Parquet files. Future plans include segregating scalar and vector columns for larger imports to alleviate I/O pressure.

1 post · 2024

Timeline

20242026

Feature trailQuiet since 2024

Dynamic Log Level Control

Milvus introduces dynamic log level control via an HTTP interface on port 9091, allowing engineers to adjust logging verbosity (debug, info, warn, error, dpanic, panic, fatal) without service restarts. This mechanism leverages the Uber zap logger's http_handler.go module, enabling real-time performance debugging and issue identification.

1 post · 2022–2024

Timeline

20222026

Feature trailQuiet since 2024

Milvus 2023 Year in Review

Milvus has seen significant advancements in 2023, focusing on stability, performance, and memory efficiency. Key developments include zero-downtime rolling upgrades, a 3x performance improvement in production environments, a 5% recall improvement on the Beir dataset with hybrid search, and 10x memory savings through disk-based indexing and MMap support. The year also saw 20 releases driven by community feedback, enabling multi-tenancy for millions of tenants, and reaching 10 million Docker image pulls. Milvus continues to scale to billions of entities in a single collection, demonstrating its robust architecture for large-scale AI applications.

1 post · 2024

Timeline

20242026

Feature trailQuiet since 2023

Vector Database Comparison

This post compares Milvus as a specialized vector database against vector search libraries (like FAISS) and vector search plugins within traditional databases. It highlights the limitations of libraries (scalability, real-time import) and plugins (lack of full-stack approach, limited tunability) and positions Milvus as a more robust, scalable, and feature-rich solution for large-scale vector search applications. It emphasizes Milvus's user-friendly APIs, broader index support, and cloud-native features.

1 post · 2023

Timeline

20232026

Feature trailQuiet since 2023

Query Load Balancing

Milvus 2.0 architecture enables real-time data query by orchestrating data loading, management, and query execution across various components. QueryNode now supports plugins, expanding querying scenarios. The compaction algorithm has been improved for faster queries. The default number of collection shards has been reduced to one for better resource saving and querying performance. An improved query grouping algorithm increases Milvus's throughput by at least 20%. Milvus 2.2.8 also addresses red. Milvus's query coordinator distributes segments evenly to each query node according to RAM usage, triggering load balancing when memory usage exceeds thresholds or the difference between nodes is too large. Segments are transferred, and the source node releases them after successful loading on the destination.

1 post · 2022–2023

Timeline

20222026

Feature trailQuiet since 2022

Consistency

Milvus supports tunable consistency levels (Strong, Bounded, Session, Eventually) by leveraging a time tick mechanism and guarantee timestamps. This allows users to balance data visibility and search latency based on application requirements. The system automatically manages guarantee timestamps based on the chosen consistency level, simplifying user configuration.

2 posts · 2022

Timeline

20222026

Feature trailQuiet since 2022

In-Memory Replicas

Milvus 2.1 introduces in-memory replicas to enhance read throughput and system availability. This feature allows data segments to be loaded onto multiple query nodes, enabling parallel search requests and improving resilience to query node failures. Configuration involves specifying the replica number during collection loading, with limitations based on available memory. Milvus 2.1 also introduces a new routing protocol that significantly reduces retrieval latency for small datasets, bringing it down to 5ms. It fine-tunes its concurrency model with a new cost evaluation model and concurrency scheduler, merging small-nq queries for a 3.2x performance boost in high concurrency scenarios. Data loading is improved with Zstandard compression for binary logs and concurrent segment loading using goroutine pools. Milvus 2.1 adds support for variable-length string (VARCHAR) as a scalar data type, usable as primary keys and attribute filters, and introduces a scalar inverted index using MARISA-Tries for faster filtering on strings. It also offers the option to use Kafka as a message storage alongside Pulsar, and its Java SDK is now production-ready. Observability is enhanced with new monitoring metrics and optimized log keeping. Embedded Milvus is introduced for easier local development and prototyping.

1 post · 2022

Timeline

20222026

Feature trailQuiet since 2022

Milvus Cloud-Native Architecture

Milvus 2.0 introduces a cloud-native architecture with storage and computing separation, microservices, and a log-centric design. It unifies batch and stream processing using a Lambda architecture, supports hybrid search between scalar and vector data, offers tunable consistency, and implements time travel for data rollback. Key features include enhanced reliability through "fail cheap, fail small, fail often" principles, an ORM Python SDK, and supporting tools like Milvus Insight and Prometheus. This post discusses the limitations of consensus-based replication like Raft and proposes a log replication strategy for cloud-native and distributed databases, emphasizing replication as a service and the Russian doll principle. Milvus's tunable consistency is similar to follower reads in consensus-based replication, enhancing cluster throughput and reducing leader load.

2 posts · 2021–2022

Timeline

20212026

Feature trailQuiet since 2022

Milvus Quality Assurance Framework

Milvus has established a comprehensive Quality Assurance (QA) framework to ensure the reliability and quality of its vector database. This framework encompasses various testing modules, including unit tests, function tests, deployment tests, reliability tests, performance tests, and configuration tests. The QA process is integrated throughout the software development lifecycle, from design to release, with a robust issue management system for tracking and resolving bugs. The goal is to provide a systematic approach to testing that aligns with Milvus's cloud-native, distributed architecture.

1 post · 2022

Timeline

20222026

Feature trailQuiet since 2022

Bitset for Data Management

Milvus 2.0 introduces bitsets as a core mechanism to support Time Travel, attribute filtering, and data deletion. This enables efficient querying of historical data states, precise filtering based on metadata, and robust handling of deleted records within the vector database. The delete function in v0.7.0 introduced soft deletion for flushed data, saving deleted IDs in a separate DEL file and using a bitmap to filter them during read operations. Segments were introduced as the basic unit for managing raw files, index files, and DEL files. Future optimizations include using counting bloom filters for faster segment identification during deletion.

1 post · 2020–2022

Timeline

20202026

Feature trailQuiet since 2022

Data File Cleanup Mechanism

Milvus has evolved its data file cleanup mechanism. Previously, files marked for soft-delete were hard-deleted after a fixed 5-minute interval, which was unreliable and led to excessive disk usage. The improved strategy uses a reference counting mechanism where files are hard-deleted only when they are no longer in use by any active task and have been soft-deleted. This ensures reliable deletion and efficient disk usage.

1 post · 2019–2022

Timeline

20192026

Feature trailQuiet since 2021

Milvus CLI

Milvus CLI provides a command-line interface for interacting with Milvus, built using Python's Click library. It supports group commands, sub-groups, custom commands with options and flags, arguments, confirmation prompts, user input prompts, and choices for input validation. The CLI aims to provide a continuous connection to Milvus instances and manage data operations through a conversational interface.

1 post · 2021

Timeline

20212026

Feature trailQuiet since 2021

Compilation Optimization

Milvus has implemented significant compilation optimization strategies, including dependency decoupling, testing containerization, and leveraging compilation cache tools like CCache. These efforts have resulted in a 60% reduction in average compile times, improving code integration efficiency. Future work includes further parallelization of compilation.

1 post · 2021

Timeline

20212026

Feature trailQuiet since 2021

Partition Management for Vector Operations

Milvus 1.1.0 introduces the ability to specify partitions for `get_entity_by_id()` and `delete_entity_by_id()` operations, significantly improving performance for large datasets by allowing targeted data retrieval and deletion. A new `release_collection()` method was added to manually unload collections from memory, enhancing runtime memory management. Performance improvements were also made to `get_entity_by_id()`, Hnswlib index building, and IVF index training.

1 post · 2021

Timeline

20212026

Feature trailQuiet since 2020

CPU Instruction Set Performance

Milvus performance is evaluated across different CPU instruction sets (AVX-512 vs. AVX2) and various vector index types (IVF_FLAT, IVF_SQ8, HNSW). The tests demonstrate that Milvus consistently performs better on AVX-512 due to its 512-bit computation capabilities, although real-world gains are not always double. HNSW index shows superior retrieval speed, while IVF_SQ8 offers a good balance of speed and memory efficiency compared to IVF_FLAT.

1 post · 2020

Timeline

20202026

Feature trailQuiet since 2020

Query Task Scheduling

Milvus has evolved its query task scheduling mechanisms to optimize performance across diverse hardware environments. Initially, a Round Robin strategy was used for multi-GPU scheduling, but this proved suboptimal on hardware with varying GPU transmission speeds. The system was updated to incorporate estimated completion times, considering data loading and computation durations for each device, to make more informed scheduling decisions. Future work includes optimizing for more complex hardware like NUMA architectures and exploring query merging for identical table queries to further enhance performance.

1 post · 2020

Timeline

20202026

Feature trailQuiet since 2019

Metadata Management

Milvus has evolved its metadata management capabilities, including detailed field descriptions for Tables and TableFiles, support for partitioning with new fields like owner_table, partition_tag, and version, and enhanced file status tracking. This post details the fields within the metadata tables, including `id`, `table_id`, `state`, `dimension`, `created_on`, `flag`, `index_file_size`, `engine_type`, `nlist`, `metric_type` for the `Tables` table, and `owner_table`, `partition_tag`, `version` for TableFiles. It also provides instructions on how to view this metadata using SQLite or MySQL backends.

1 post · 2019

Timeline

20192026