{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-milvus-io--milvus","slug":"milvus-io--milvus","name":"milvus","type":"mcp","url":"https://milvus.io","page_url":"https://unfragile.ai/milvus-io--milvus","categories":["rag-knowledge"],"tags":["anns","cloud-native","diskann","distributed","embedding-database","embedding-similarity","embedding-store","faiss","golang","hnsw","image-search","llm","nearest-neighbor-search","rag","vector-database","vector-search","vector-similarity","vector-store"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-milvus-io--milvus__cap_0","uri":"capability://search.retrieval.distributed.vector.similarity.search.with.approximate.nearest.neighbor.indexing","name":"distributed vector similarity search with approximate nearest neighbor indexing","description":"Executes k-NN searches across distributed query nodes using pluggable ANNS algorithms (HNSW, DiskANN, FAISS) with query planning, segment pruning, and result reranking. The Query Coordinator distributes search requests to multiple QueryNodes via ShardDelegator, which loads indexed segments into memory and executes filtered vector searches in parallel, then merges and reranks results before returning to client.","intents":["I need to search billions of embeddings and get the top-k most similar vectors in milliseconds","I want to filter vectors by metadata before computing similarity to reduce search space","I need to scale vector search across multiple machines without managing sharding myself","I want to use different indexing algorithms (HNSW vs DiskANN) and switch between them without rewriting code"],"best_for":["teams building RAG systems with large document collections","AI applications requiring real-time semantic search at scale","developers migrating from single-machine FAISS to distributed systems"],"limitations":["Search latency increases with result reranking complexity; no built-in GPU acceleration for reranking","Segment pruning effectiveness depends on metadata cardinality; high-cardinality filters may require scanning all segments","ANNS algorithms trade recall for speed; exact nearest neighbor search not supported","Cross-shard result merging adds ~50-200ms latency depending on number of QueryNodes"],"requires":["Vector embeddings pre-computed and normalized (float32 or binary format)","Milvus cluster with at least one QueryNode and one DataNode","Collection schema defined with vector field and optional scalar fields for filtering","Index built on vector field before search (HNSW, DiskANN, or FAISS)"],"input_types":["vector embeddings (float32 arrays, 1-65536 dimensions)","search parameters (k, metric type: L2/IP/COSINE)","optional filter expressions (scalar metadata predicates)"],"output_types":["ranked list of entity IDs with similarity scores","optional scalar field values for matched entities"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_1","uri":"capability://data.processing.analysis.schema.driven.data.insertion.with.streaming.and.batch.persistence","name":"schema-driven data insertion with streaming and batch persistence","description":"Accepts insert/upsert operations through Proxy service, validates against collection schema, routes data through streaming system (WAL-backed channels), buffers in DataNode write buffers, and persists to object storage via flush pipeline. The system maintains insert ordering guarantees through message channels and supports both streaming inserts (low-latency) and batch bulk imports with automatic segment creation and compaction.","intents":["I need to insert millions of embeddings with associated metadata into the vector database","I want streaming inserts to be immediately searchable without waiting for batch flushes","I need to bulk import data from external sources (Parquet, JSON) with automatic schema validation","I want upsert semantics where duplicate primary keys update existing records instead of duplicating"],"best_for":["data engineering teams building ETL pipelines into vector databases","real-time AI applications requiring low-latency data ingestion","teams migrating from traditional databases to vector-native architectures"],"limitations":["Insert throughput limited by DataNode buffer size and flush frequency; tuning required for >100k inserts/sec","Upsert operations require primary key lookup, adding ~10-50ms latency vs pure insert","Bulk import requires data in supported formats (Parquet, JSON); custom formats need preprocessing","Schema changes (adding/removing fields) require collection recreation; no online schema evolution"],"requires":["Collection created with schema defining all fields (vector, scalar, primary key)","Data matching schema types (float32 vectors, int64/varchar primary keys, scalar metadata)","Milvus cluster with DataNode and RootCoordinator running","For bulk import: data files in Parquet or JSON format with matching schema"],"input_types":["insert/upsert requests with entity data (vectors + scalars)","bulk import files (Parquet, JSON)","primary key values for upsert operations"],"output_types":["insert IDs (auto-generated or provided)","acknowledgment of successful persistence","error details for failed inserts"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_10","uri":"capability://automation.workflow.dynamic.configuration.management.with.runtime.updates","name":"dynamic configuration management with runtime updates","description":"Manages Milvus configuration through a hierarchical system supporting YAML files, environment variables, and runtime updates via API. Configuration changes (service parameters, component parameters) can be applied at runtime without restart through the configuration system, with changes propagated to affected components. The system validates configuration values and maintains backward compatibility across versions.","intents":["I want to tune database parameters (cache size, compaction thresholds) without restarting","I need different configurations for different environments (dev, staging, prod)","I want to understand which parameters affect my query performance","I need to roll back configuration changes if they cause issues"],"best_for":["production deployments requiring parameter tuning without downtime","teams managing multiple Milvus clusters with different configurations","operators needing visibility into active configuration"],"limitations":["Runtime configuration changes not persisted to disk; reverted on restart unless saved to config file","Some parameters require component restart to take effect; not all changes are truly dynamic","Configuration validation is basic; invalid values may cause runtime errors","No configuration versioning or audit trail of changes"],"requires":["Milvus cluster running","Configuration file (YAML) or environment variables set","API access for runtime configuration updates"],"input_types":["configuration parameters and values","configuration file (YAML)"],"output_types":["configuration acknowledgment","current active configuration"],"categories":["automation-workflow","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_11","uri":"capability://data.processing.analysis.metadata.management.and.schema.validation","name":"metadata management and schema validation","description":"The Root Coordinator maintains collection schemas, field definitions, and metadata in a catalog (backed by etcd or other persistent storage). Schema validation happens at Proxy layer for all operations, enforcing field types, vector dimensions, and primary key constraints. The system supports schema versioning and caching at Proxy for fast validation without coordinator roundtrips. Metadata includes collection statistics, partition info, and index metadata used for query planning.","intents":["I want to define a schema with vectors, scalars, and primary keys","I need to validate that my data matches the schema before insertion","I want to understand collection statistics for query optimization","I need to manage multiple collections with different schemas"],"best_for":["teams building structured data pipelines with schema enforcement","applications requiring schema versioning and evolution","systems needing metadata-driven query optimization"],"limitations":["Schema changes require collection recreation; no online schema evolution","Metadata caching at Proxy may be stale; cache invalidation adds latency","No schema validation for custom types; only built-in types supported","Collection statistics not real-time; may lag behind actual data"],"requires":["Root Coordinator running with persistent metadata storage","Schema defined with field names, types, and vector dimensions","Primary key field specified"],"input_types":["schema definition (field names, types, dimensions)","collection configuration"],"output_types":["schema validation results","collection metadata","collection statistics"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_12","uri":"capability://safety.moderation.quota.and.rate.limiting.with.resource.governance","name":"quota and rate limiting with resource governance","description":"Enforces quotas and rate limits at the Proxy service layer to prevent resource exhaustion and ensure fair resource allocation. The system supports per-user, per-collection, and global quotas for operations (inserts, searches, deletes) and resource consumption (memory, disk, network). Rate limiting uses token bucket algorithm with configurable limits, and quota violations trigger backpressure (request queueing or rejection) rather than silent failures.","intents":["I want to prevent one user from consuming all database resources","I need to enforce fair resource sharing in multi-tenant deployments","I want to understand resource consumption per user or collection","I need to implement SLA-based rate limiting for different customer tiers"],"best_for":["multi-tenant SaaS deployments requiring resource isolation","systems with heterogeneous workloads needing fair scheduling","teams implementing usage-based billing"],"limitations":["Quota enforcement at Proxy layer; no kernel-level resource limits","Rate limiting based on operation count, not actual resource consumption; CPU/memory not directly limited","Quota changes require Proxy cache invalidation; may take seconds to propagate","No support for quota bursting or time-window averaging"],"requires":["Proxy service running with quota enforcement enabled","Quota limits configured per user/collection/global","Rate limiting parameters (tokens per second, bucket size)"],"input_types":["quota configuration (limits per user/collection)","rate limiting parameters"],"output_types":["quota enforcement decisions (allow/reject/queue)","resource consumption metrics"],"categories":["safety-moderation","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_2","uri":"capability://data.processing.analysis.multi.field.filtering.with.scalar.metadata.predicates","name":"multi-field filtering with scalar metadata predicates","description":"Evaluates complex filter expressions (AND/OR/NOT combinations of scalar predicates) during query execution in the Segcore engine using expression parsing and field-level filtering. Filters are pushed down to QueryNodes before vector search, reducing the search space by eliminating segments and entities that don't match metadata conditions, with support for comparison operators (==, !=, <, >, <=, >=) and range queries on int/float/varchar fields.","intents":["I need to search vectors only within a specific date range or category","I want to combine vector similarity with exact metadata matching (e.g., find similar documents from a specific source)","I need to exclude certain entities from search results based on scalar field values","I want to filter by multiple conditions simultaneously (e.g., category='news' AND date > '2024-01-01')"],"best_for":["RAG systems filtering documents by source, date, or category before semantic search","e-commerce search combining vector similarity with price/availability filters","multi-tenant systems isolating data by tenant ID during search"],"limitations":["Filter evaluation happens after segment pruning; high-cardinality filters may require scanning all segments","Complex nested expressions (deeply nested AND/OR) add query planning overhead","No support for full-text search predicates; only scalar field comparisons","Filter selectivity not optimized; no cost-based query planning for filter ordering"],"requires":["Scalar fields defined in collection schema (int64, float, varchar types)","Filter expression using supported operators and field names","Optional: indexes on frequently-filtered scalar fields for faster pruning"],"input_types":["filter expression string (e.g., 'category == \"news\" AND date > 1704067200')","field names and comparison values"],"output_types":["filtered entity IDs matching both vector similarity and scalar predicates","scalar field values for matched entities"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_3","uri":"capability://data.processing.analysis.multi.algorithm.vector.indexing.with.pluggable.knowhere.engine","name":"multi-algorithm vector indexing with pluggable knowhere engine","description":"Builds and maintains vector indexes using the Knowhere abstraction layer supporting HNSW (graph-based), DiskANN (disk-optimized), FAISS (CPU-optimized), and other ANNS algorithms. Index building happens asynchronously on DataNodes during segment compaction, with configurable parameters per algorithm (M, ef for HNSW; cache_size for DiskANN). Indexes are memory-mapped on QueryNodes for efficient loading and querying without full memory materialization.","intents":["I want to choose between HNSW for low-latency search and DiskANN for memory efficiency","I need to rebuild indexes with different parameters to optimize for my query patterns","I want to use GPU-accelerated indexing for faster index construction","I need to understand index memory footprint and tune it for my hardware constraints"],"best_for":["teams optimizing vector search performance for specific hardware (CPU vs GPU, memory-constrained)","applications with variable query patterns requiring algorithm switching","large-scale deployments where index memory footprint is critical"],"limitations":["Index building blocks writes during compaction; no online index updates without rebuild","Algorithm switching requires index rebuild; no seamless migration between HNSW and DiskANN","GPU acceleration requires CUDA-capable hardware and additional dependencies","Index memory overhead varies by algorithm; HNSW typically 1.5-2x data size, DiskANN lower"],"requires":["Vector field defined in collection schema","Index type selected (HNSW, DiskANN, FAISS, etc.)","Index parameters configured (M, ef_construction for HNSW; cache_size for DiskANN)","Sufficient disk space for index files during build"],"input_types":["index type and algorithm parameters","vector data to index"],"output_types":["built index files stored in object storage","index metadata (algorithm, parameters, build time)"],"categories":["data-processing-analysis","memory-knowledge"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_4","uri":"capability://automation.workflow.distributed.segment.lifecycle.management.with.compaction","name":"distributed segment lifecycle management with compaction","description":"Manages segment creation, loading, and compaction across DataNodes and QueryNodes through the Data Coordinator. Segments progress through states (growing → sealed → compacted) with automatic compaction triggered by size thresholds or time-based policies. The compaction system merges small segments, applies deletes via L0 segments, and rebuilds indexes, while QueryNodes load compacted segments on-demand with ShardDelegator managing segment distribution and rebalancing.","intents":["I want the database to automatically manage segment sizes and merge small segments for efficiency","I need to understand how deletes are applied without rewriting entire segments","I want to control compaction frequency and resource usage during compaction","I need visibility into segment metadata and compaction status for debugging"],"best_for":["production deployments requiring automatic resource optimization","teams with high delete rates needing efficient delete propagation","systems with variable write patterns requiring adaptive compaction"],"limitations":["Compaction is asynchronous and may lag behind writes; no synchronous compaction option","Compaction resource usage not throttled; may impact query performance during heavy compaction","L0 segment-based delete propagation adds query overhead; deletes not immediately reflected in all segments","Segment rebalancing across QueryNodes may cause temporary search latency spikes"],"requires":["DataNode and QueryCoordinator running","Compaction policies configured (size thresholds, time intervals)","Sufficient disk space for temporary compaction files"],"input_types":["compaction policy configuration","segment metadata and size thresholds"],"output_types":["compacted segment files","updated segment metadata","compaction execution logs"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_5","uri":"capability://safety.moderation.rbac.and.authentication.with.role.based.access.control","name":"rbac and authentication with role-based access control","description":"Enforces role-based access control (RBAC) at the Proxy service layer, validating user credentials and checking permissions for each operation (insert, search, delete, etc.) against defined roles and resource-level policies. The Root Coordinator maintains RBAC metadata including users, roles, and privilege mappings, with support for custom role definitions and granular permissions on collections and partitions.","intents":["I need to restrict database access to specific users and roles","I want to grant different permissions to different teams (read-only vs read-write)","I need to audit who accessed which collections and when","I want to revoke access immediately without restarting the database"],"best_for":["multi-tenant deployments requiring strict access isolation","enterprise systems with compliance requirements (SOC2, HIPAA)","teams with shared infrastructure needing fine-grained permissions"],"limitations":["RBAC checked at Proxy layer; no encryption of data at rest by default","Role changes require Proxy cache invalidation; may take seconds to propagate","No field-level access control; permissions are collection/partition level only","Audit logging not built-in; requires external monitoring integration"],"requires":["Milvus cluster with authentication enabled","User credentials (username/password or API key)","Roles defined in Root Coordinator metadata"],"input_types":["user credentials","role definitions","permission assignments"],"output_types":["access granted/denied decisions","audit log entries"],"categories":["safety-moderation","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_6","uri":"capability://data.processing.analysis.consistency.model.with.timestamp.safe.tsafe.guarantees","name":"consistency model with timestamp-safe (tsafe) guarantees","description":"Provides configurable consistency levels (strong, bounded, eventual) through timestamp-safe (TSafe) tracking in the streaming system. The system maintains safe timestamps per channel indicating which messages have been processed and persisted, allowing clients to specify consistency requirements at query time. Strong consistency waits for all writes before the query timestamp to be applied; bounded consistency allows staleness up to a specified time window; eventual consistency returns immediately with latest available data.","intents":["I need strong consistency for critical operations like financial transactions","I want eventual consistency for exploratory search to minimize latency","I need to balance consistency and latency based on use case","I want to understand what data is visible at a given timestamp"],"best_for":["applications with mixed consistency requirements (strong for writes, eventual for reads)","systems where latency-consistency tradeoff is critical","teams building multi-region deployments with eventual consistency"],"limitations":["Strong consistency adds query latency waiting for TSafe advancement; typically 100-500ms overhead","Bounded consistency window must be tuned; too small causes frequent waits, too large reduces freshness","TSafe tracking per channel adds coordination overhead; not suitable for extremely high-throughput scenarios","No causal consistency; concurrent writes may not have defined ordering"],"requires":["Streaming system running with WAL-backed channels","Consistency level specified in query request","For bounded consistency: staleness tolerance configured"],"input_types":["consistency level (strong/bounded/eventual)","staleness tolerance (for bounded consistency)"],"output_types":["query results with consistency guarantees","timestamp metadata indicating data freshness"],"categories":["data-processing-analysis","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_7","uri":"capability://automation.workflow.load.balancing.and.segment.distribution.across.query.nodes","name":"load balancing and segment distribution across query nodes","description":"The Query Coordinator implements load balancing strategies to distribute segments across QueryNodes based on resource utilization, query patterns, and segment size. ShardDelegator on each QueryNode manages local segment loading and delegates cross-shard queries to other nodes. The system supports multiple load balancing policies (round-robin, least-loaded, custom) and automatically rebalances segments when nodes join/leave or resource imbalance is detected.","intents":["I want queries distributed evenly across QueryNodes to avoid hotspots","I need the system to automatically rebalance when I add new QueryNodes","I want to understand which segments are loaded on which nodes","I need to control segment placement for data locality or compliance"],"best_for":["large deployments with multiple QueryNodes requiring load distribution","systems with heterogeneous hardware where load balancing is critical","teams needing visibility into segment placement for debugging"],"limitations":["Rebalancing is asynchronous and may lag behind node changes; no synchronous rebalancing","Load balancing decisions based on historical metrics; may not adapt to sudden query pattern changes","No support for custom placement policies beyond built-in strategies","Segment movement during rebalancing may cause temporary query latency increase"],"requires":["Multiple QueryNodes in cluster","Query Coordinator running","Load balancing policy configured"],"input_types":["load balancing policy selection","segment metadata and sizes","QueryNode resource metrics"],"output_types":["segment-to-node assignments","load balancing metrics","rebalancing execution logs"],"categories":["automation-workflow","planning-reasoning"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_8","uri":"capability://tool.use.integration.grpc.and.http.api.interfaces.with.client.sdks","name":"grpc and http api interfaces with client sdks","description":"Exposes Milvus functionality through gRPC service definitions (high-performance binary protocol) and HTTP REST endpoints (for web clients and simpler integrations). The Proxy service implements both protocols, routing requests to appropriate coordinators and nodes. Official SDKs (Python, Go, Java, Node.js) wrap these APIs with type-safe interfaces, connection pooling, and automatic retry logic, while custom clients can use raw gRPC or HTTP.","intents":["I want to integrate Milvus into my Python/Go/Java application with a native SDK","I need to query Milvus from a web browser or JavaScript application using HTTP","I want to use gRPC for low-latency, high-throughput client-server communication","I need to implement a custom client in a language without official SDK support"],"best_for":["teams building applications in Python, Go, Java, or Node.js","web applications requiring HTTP REST API","high-performance systems requiring gRPC's binary protocol"],"limitations":["HTTP API has higher latency than gRPC due to JSON serialization; not suitable for high-throughput scenarios","SDK connection pooling must be configured per application; no automatic connection sharing across processes","gRPC requires protobuf knowledge for custom implementations; HTTP is more accessible","SDK versions may lag behind server releases; compatibility matrix must be checked"],"requires":["Milvus server running with gRPC and/or HTTP ports exposed","Official SDK installed (pip install pymilvus, go get github.com/milvus-io/milvus-sdk-go, etc.)","For custom clients: gRPC protobuf definitions or HTTP endpoint documentation"],"input_types":["API requests (insert, search, delete, etc.)","connection parameters (host, port, credentials)"],"output_types":["API responses (search results, insert IDs, status)","error messages and status codes"],"categories":["tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-milvus-io--milvus__cap_9","uri":"capability://automation.workflow.streaming.wal.and.message.channel.based.data.flow","name":"streaming wal and message channel-based data flow","description":"Implements a streaming system with write-ahead logging (WAL) and message channels for reliable data propagation. Data flows through named channels (one per shard) with messages persisted to WAL before acknowledgment, enabling recovery and replay. StreamingCoord manages channel lifecycle and consumer groups, while StreamingNodes handle WAL persistence and message delivery. The system guarantees message ordering per channel and supports both streaming consumption (low-latency) and batch consumption (high-throughput).","intents":["I want to ensure no data loss even if the database crashes during writes","I need to replay data from a specific timestamp for recovery or debugging","I want streaming inserts to be immediately visible in search without waiting for batch flushes","I need to understand message ordering guarantees for my application"],"best_for":["production systems requiring durability and recovery guarantees","real-time applications with low-latency data ingestion","teams building audit trails or event sourcing on top of Milvus"],"limitations":["WAL persistence adds write latency; typically 10-50ms per insert depending on storage","Message channel throughput limited by WAL write speed; tuning required for >100k inserts/sec","Replay from old timestamps requires sufficient WAL retention; old messages may be garbage collected","No support for exactly-once semantics; at-least-once delivery only"],"requires":["StreamingCoord and StreamingNode running","Persistent storage for WAL (local disk or object storage)","Message channel configuration (retention period, consumer groups)"],"input_types":["insert/upsert/delete operations","timestamp for replay"],"output_types":["message acknowledgment with timestamp","replayed messages for recovery"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":53,"verified":false,"data_access_risk":"high","permissions":["Vector embeddings pre-computed and normalized (float32 or binary format)","Milvus cluster with at least one QueryNode and one DataNode","Collection schema defined with vector field and optional scalar fields for filtering","Index built on vector field before search (HNSW, DiskANN, or FAISS)","Collection created with schema defining all fields (vector, scalar, primary key)","Data matching schema types (float32 vectors, int64/varchar primary keys, scalar metadata)","Milvus cluster with DataNode and RootCoordinator running","For bulk import: data files in Parquet or JSON format with matching schema","Milvus cluster running","Configuration file (YAML) or environment variables set"],"failure_modes":["Search latency increases with result reranking complexity; no built-in GPU acceleration for reranking","Segment pruning effectiveness depends on metadata cardinality; high-cardinality filters may require scanning all segments","ANNS algorithms trade recall for speed; exact nearest neighbor search not supported","Cross-shard result merging adds ~50-200ms latency depending on number of QueryNodes","Insert throughput limited by DataNode buffer size and flush frequency; tuning required for >100k inserts/sec","Upsert operations require primary key lookup, adding ~10-50ms latency vs pure insert","Bulk import requires data in supported formats (Parquet, JSON); custom formats need preprocessing","Schema changes (adding/removing fields) require collection recreation; no online schema evolution","Runtime configuration changes not persisted to disk; reverted on restart unless saved to config file","Some parameters require component restart to take effect; not all changes are truly dynamic","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.8107544087131014,"quality":0.35,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.25,"quality":0.25,"ecosystem":0.15,"match_graph":0.23,"freshness":0.12}},"observed_outcomes":{"matches":0,"success_rate":0,"avg_confidence":0,"top_intents":[],"last_matched_at":null},"maintenance":{"status":"active","updated_at":"2026-05-24T12:16:22.062Z","last_scraped_at":"2026-05-03T13:58:26.976Z","last_commit":"2026-05-02T03:10:08Z"},"community":{"stars":44104,"forks":3985,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=milvus-io--milvus","compare_url":"https://unfragile.ai/compare?artifact=milvus-io--milvus"}},"signature":"JX/Znk2elL333rY1JR7Vyy76O/dWtu6rK/NoA434eUkRN9FCXWA8d8V6sCzh3SQ99jDZ90tYpEtgBH0+BcsoAQ==","signedAt":"2026-06-22T01:53:45.262Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/milvus-io--milvus","artifact":"https://unfragile.ai/milvus-io--milvus","verify":"https://unfragile.ai/api/v1/verify?slug=milvus-io--milvus","publicKey":"https://unfragile.ai/api/v1/trust-passport-public-key","spec":"https://unfragile.ai/trust","schema":"https://unfragile.ai/schema.json","docs":"https://unfragile.ai/docs"}}