{"passport":{"unfragile":{"@version":"1.0","version":"2026-05","artifact":{"id":"github-qdrant--qdrant","slug":"qdrant--qdrant","name":"qdrant","type":"platform","url":"https://qdrant.tech","page_url":"https://unfragile.ai/qdrant--qdrant","categories":["rag-knowledge"],"tags":["ai-search","ai-search-engine","embeddings-similarity","hnsw","hybrid-search","image-search","knn-algorithm","machine-learning","mlops","nearest-neighbor-search","neural-network","neural-search","recommender-system","search","search-engine","search-engines","similarity-search","vector-database","vector-search","vector-search-engine"],"pricing":{"model":"open_source","free":true,"starting_price":null},"status":"active","verified":false},"capabilities":[{"id":"github-qdrant--qdrant__cap_0","uri":"capability://search.retrieval.hnsw.based.approximate.nearest.neighbor.search.with.configurable.recall.latency.tradeoff","name":"hnsw-based approximate nearest neighbor search with configurable recall-latency tradeoff","description":"Implements Hierarchical Navigable Small World (HNSW) graph indexing for sub-linear time complexity nearest neighbor queries across dense vector spaces. The implementation uses a multi-layer graph structure where each layer is a navigable small world graph, enabling efficient approximate search by starting from the top layer and progressively descending. Supports configurable M (max connections per node) and ef (search expansion factor) parameters to tune the recall-latency tradeoff, allowing users to balance query speed against result accuracy without re-indexing.","intents":["Find semantically similar vectors in milliseconds across millions of embeddings","Tune search performance by adjusting recall vs latency without retraining","Scale vector search to billions of embeddings with sub-linear query time"],"best_for":["ML engineers building semantic search systems at scale","RAG pipeline builders needing sub-100ms retrieval latency","Recommendation system teams optimizing for both accuracy and speed"],"limitations":["HNSW graph construction is O(n log n) and memory-intensive; adding vectors to existing indices requires graph restructuring","Approximate search means recall is not 100% — some true nearest neighbors may be missed depending on ef parameter","Graph structure is immutable after segment creation; updates require segment compaction and rebuilding"],"requires":["Vector dimension size must be consistent across all vectors in a collection","Sufficient RAM to hold HNSW graph in memory (typically 10-50 bytes per vector depending on M parameter)","Rust runtime (Qdrant is written in Rust)"],"input_types":["dense float32/float64 vectors","vector dimension (integer)","HNSW parameters (M, ef_construct, ef_search)"],"output_types":["ranked list of point IDs with distances","distance scores (L2, cosine, dot product)"],"categories":["search-retrieval","vector-indexing"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_1","uri":"capability://search.retrieval.hybrid.dense.sparse.vector.search.with.combined.scoring","name":"hybrid dense-sparse vector search with combined scoring","description":"Enables simultaneous search across dense vectors (via HNSW) and sparse vectors (via inverted indices) with configurable weighted combination of results. The system maintains separate index structures for dense and sparse vectors within each segment, executes parallel searches, and merges results using a weighted scoring function that combines dense similarity scores with sparse BM25-style relevance scores. This allows semantic search (dense) and keyword matching (sparse) to be unified in a single query without requiring separate round-trips.","intents":["Combine semantic similarity with keyword matching in a single search query","Search documents where both meaning and exact terms matter (e.g., legal documents, technical specs)","Improve recall by capturing both semantic and lexical relevance without multiple queries"],"best_for":["Enterprise search teams needing both semantic and keyword relevance","RAG systems requiring high precision on domain-specific terminology","E-commerce and content discovery platforms balancing semantic and exact-match results"],"limitations":["Sparse vector indexing requires explicit tokenization/vocabulary management; no built-in NLP preprocessing","Weighted combination of dense and sparse scores requires manual tuning of weight parameters for each use case","Sparse vectors must be pre-computed by the client; Qdrant does not generate sparse representations"],"requires":["Both dense and sparse vector representations for each document","Sparse vectors in COO (coordinate) format with indices and values","Configuration of weight parameter to balance dense vs sparse score contribution"],"input_types":["dense float32 vectors","sparse vectors (index-value pairs)","weight parameter (float, 0.0-1.0)"],"output_types":["ranked list of point IDs with combined scores","breakdown of dense and sparse score components"],"categories":["search-retrieval","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_10","uri":"capability://automation.workflow.write.ahead.logging.with.configurable.durability.guarantees","name":"write-ahead logging with configurable durability guarantees","description":"Implements write-ahead logging (WAL) to ensure data durability and consistency, with configurable fsync policies to balance durability against write latency. Each write operation is logged to disk before being applied to in-memory indices, enabling recovery from crashes without data loss. Fsync policies range from immediate (fsync after every write, highest durability but highest latency) to batched (fsync every N writes, lower latency but higher data loss risk). WAL is used for both point-in-time recovery and segment compaction consistency.","intents":["Ensure data durability across node failures without data loss","Recover from crashes to the last committed state","Balance write latency against durability guarantees based on application requirements"],"best_for":["Production systems where data loss is unacceptable","Applications with strict durability requirements (financial, healthcare)","Teams tuning write latency vs durability tradeoffs"],"limitations":["Immediate fsync (highest durability) adds 5-20ms latency per write operation","Batched fsync reduces latency but increases data loss risk if node crashes between fsync operations","WAL disk I/O can become a bottleneck for very high write throughput (>10k writes/sec)"],"requires":["Persistent storage with reliable fsync semantics (SSD recommended)","Configuration of fsync policy (immediate, batch, or disabled)"],"input_types":["fsync policy (immediate, batch_size, or disabled)","write operations"],"output_types":["write acknowledgment (after WAL fsync)","recovery logs"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_11","uri":"capability://data.processing.analysis.batch.operations.with.transactional.semantics","name":"batch operations with transactional semantics","description":"Supports batch operations (upsert, delete, update) that are applied atomically within a single request, ensuring all operations in the batch succeed or all fail together. Batch operations are processed through the update pipeline and applied to segments in a single transaction, maintaining consistency across multiple point updates. This enables efficient bulk loading and updates without requiring separate requests for each operation.","intents":["Bulk load vectors and payloads efficiently in a single request","Update multiple points atomically without partial failures","Reduce network round-trips for bulk operations"],"best_for":["Bulk data loading scenarios (initial indexing, periodic updates)","Applications requiring atomic multi-point updates","Teams optimizing for throughput in bulk operations"],"limitations":["Batch size is limited by available memory; very large batches (>100k points) may cause memory pressure","Batch operations are not distributed across shards; each shard processes its batch independently","Transactional semantics apply only within a single batch; cross-batch atomicity is not guaranteed"],"requires":["Batch size within memory limits (typically <100k points per batch)","Points in batch must be formatted according to API schema"],"input_types":["list of upsert/delete/update operations","batch size"],"output_types":["operation results (success/failure per operation)","batch processing time"],"categories":["data-processing-analysis","automation-workflow"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_12","uri":"capability://search.retrieval.qdrant.edge.library.for.embedded.vector.search.on.edge.devices","name":"qdrant edge library for embedded vector search on edge devices","description":"Provides a lightweight embedded library (Qdrant Edge) that runs vector search directly on edge devices (mobile, IoT, embedded systems) without requiring a server connection. The library is a minimal Rust implementation of Qdrant's core search functionality (HNSW search, filtering, quantization) compiled to WebAssembly or native binaries for edge platforms. Edge library supports pre-built indices that are downloaded from the server and cached locally, enabling offline search with periodic synchronization.","intents":["Enable vector search on mobile and edge devices without server dependency","Reduce latency for search operations by running locally on the device","Support offline search with periodic synchronization to the server"],"best_for":["Mobile applications requiring offline search capability","IoT devices with limited connectivity","Edge computing scenarios where latency is critical"],"limitations":["Edge library has reduced functionality compared to server (no distributed features, limited filtering)","Pre-built indices must be downloaded and cached; large indices (>1GB) may not fit on device storage","Synchronization between edge and server is manual; no automatic conflict resolution"],"requires":["WebAssembly runtime or native compilation target for edge platform","Pre-built indices in Qdrant format","Sufficient device storage for index caching (typically 100MB-1GB)"],"input_types":["pre-built vector indices","query vectors"],"output_types":["search results (ranked point IDs and distances)"],"categories":["search-retrieval","tool-use-integration"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_13","uri":"capability://tool.use.integration.inference.service.integration.for.embedding.generation","name":"inference service integration for embedding generation","description":"Provides optional inference service integration that generates embeddings from raw text/images using configurable embedding models (e.g., OpenAI, Hugging Face, local models). The inference service is decoupled from the vector database; clients can use it to generate embeddings before inserting into Qdrant, or Qdrant can be configured to call the inference service during upsert operations. This enables end-to-end workflows where raw documents are inserted and embeddings are generated automatically.","intents":["Generate embeddings from raw text without separate embedding service","Automate embedding generation during document insertion","Support multiple embedding models without changing application code"],"best_for":["RAG systems where embedding generation is part of the pipeline","Applications using multiple embedding models (e.g., text and image embeddings)","Teams wanting to abstract embedding generation from vector search"],"limitations":["Inference service integration is optional; clients can still generate embeddings separately","Embedding generation latency adds to upsert latency (typically 100-500ms per document)","Inference service must be deployed separately; Qdrant does not include embedding models"],"requires":["Inference service endpoint (OpenAI API, Hugging Face, local model server)","API credentials for inference service","Configuration mapping document fields to embedding models"],"input_types":["raw text or image data","embedding model specification"],"output_types":["generated embeddings","upserted points with embeddings"],"categories":["tool-use-integration","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_2","uri":"capability://data.processing.analysis.payload.based.filtering.with.multiple.field.index.types","name":"payload-based filtering with multiple field index types","description":"Provides structured filtering on document metadata (payloads) using field-specific index types (keyword, integer range, geo-spatial, full-text) that are selected automatically or manually based on field type and query patterns. Each field maintains its own index structure (e.g., B-tree for ranges, inverted index for keywords, R-tree for geo) stored alongside vector indices in segments. Filters are applied during search to prune candidates before distance computation, reducing the search space and improving query latency for selective filters.","intents":["Filter search results by metadata (e.g., date range, category, location) without separate database queries","Combine vector similarity with structured constraints (e.g., 'find similar documents from 2024 in category X')","Reduce search latency by filtering before expensive distance computations"],"best_for":["RAG systems needing to filter documents by metadata before semantic search","E-commerce platforms combining product embeddings with price/category/location filters","Multi-tenant systems filtering by tenant ID or access control metadata"],"limitations":["Index type selection is automatic based on field type; manual index type specification requires collection recreation","Full-text search on payloads uses simple tokenization without stemming or lemmatization","Geo-spatial queries support only point-in-polygon and distance-based filters, not complex geometric operations"],"requires":["Payload schema definition at collection creation time (or dynamic schema with performance trade-offs)","Metadata fields must be included in every point's payload","Filter expressions in Qdrant's filter DSL (JSON-based)"],"input_types":["filter expressions (JSON)","field names and types (string, integer, float, bool, geo, datetime)"],"output_types":["filtered set of point IDs","combined vector similarity + filter match results"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_3","uri":"capability://data.processing.analysis.vector.quantization.with.configurable.precision.loss","name":"vector quantization with configurable precision loss","description":"Reduces memory footprint and improves search speed by quantizing dense vectors to lower precision (int8, uint8, or binary) while maintaining configurable recall through quantization-aware distance calculations. Supports both product quantization (PQ) and scalar quantization (SQ) approaches, where vectors are decomposed into subspaces or scaled to lower bit-widths. Quantized vectors are stored in segments alongside original vectors (or as the only copy), and distance computations use quantization-aware metrics that account for precision loss.","intents":["Reduce memory usage by 4-16x for billion-scale vector collections","Speed up distance computations by operating on smaller data types","Deploy vector search on resource-constrained environments (edge devices, mobile)"],"best_for":["Teams deploying vector search on edge devices or mobile with limited RAM","Large-scale deployments (>100M vectors) where memory cost dominates infrastructure spend","Real-time search systems where latency is critical and 95%+ recall is acceptable"],"limitations":["Quantization introduces recall loss; typical recall drops 2-5% compared to full-precision search","Quantization parameters (bit-width, codebook size) must be set at collection creation; changing them requires re-quantization","Quantization is lossy; original vectors cannot be perfectly reconstructed from quantized versions"],"requires":["Collection configuration specifying quantization type (product or scalar) and bit-width","Sufficient training data to build quantization codebooks (typically 10k-100k vectors)","Acceptance of 2-5% recall loss in exchange for 4-16x memory reduction"],"input_types":["dense float32 vectors","quantization type (product_quantization or scalar_quantization)","bit-width (8, 4, 2, or 1 for binary)"],"output_types":["quantized vector representations","distance scores computed on quantized vectors"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_4","uri":"capability://automation.workflow.distributed.search.across.shards.with.automatic.replica.failover","name":"distributed search across shards with automatic replica failover","description":"Distributes vector collections across multiple shards (horizontal partitioning) and maintains replica sets for fault tolerance, with automatic failover when shard replicas become unavailable. The system uses Raft consensus to maintain consistency across replicas and automatically detects peer failures through heartbeat monitoring. Queries are routed to available shard replicas, and if a primary replica fails, the system promotes a secondary replica without manual intervention. Shard transfers and resharding are orchestrated through the Raft-based consensus layer.","intents":["Scale vector search beyond single-machine memory limits by partitioning data across nodes","Ensure high availability with automatic failover when nodes fail","Rebalance data across nodes without downtime during cluster expansion"],"best_for":["Production deployments requiring 99.9%+ uptime","Teams managing multi-node clusters with 10M+ vectors","Organizations needing to scale horizontally as data grows"],"limitations":["Raft consensus adds latency to write operations (typically 50-200ms for consensus rounds)","Shard transfers are bandwidth-intensive and can impact query latency during resharding","Replica consistency is eventual; reads may return stale data if replicas lag behind primary"],"requires":["Multi-node deployment (minimum 3 nodes for Raft quorum)","Network connectivity between all nodes with <100ms latency for reliable consensus","Persistent storage on each node for Raft logs and shard data"],"input_types":["shard configuration (number of shards, replication factor)","peer addresses and ports"],"output_types":["shard distribution across peers","replica health status","failover events"],"categories":["automation-workflow","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_5","uri":"capability://automation.workflow.segment.based.storage.with.automatic.compaction.and.optimization","name":"segment-based storage with automatic compaction and optimization","description":"Organizes data within each shard into immutable segments that are created during writes and automatically compacted/optimized based on size and update patterns. Each segment contains vectors, indices (HNSW, field indices), and metadata stored in a columnar format optimized for sequential access. The segment lifecycle manager monitors segment sizes and fragmentation, triggering compaction when segments become too small or fragmented, merging multiple segments into larger optimized segments. This design enables efficient incremental updates without full index rebuilds while maintaining query performance.","intents":["Efficiently handle continuous data ingestion without degrading query performance","Automatically optimize storage layout as data evolves","Balance write throughput with query latency through background compaction"],"best_for":["Systems with continuous data ingestion (streaming updates)","Applications where query performance must remain stable despite frequent updates","Teams wanting automatic storage optimization without manual tuning"],"limitations":["Compaction is a background process that consumes CPU and I/O; during heavy compaction, query latency may increase by 10-30%","Segment optimization is triggered heuristically; users cannot directly control compaction timing","Segments are immutable; updates require creating new segments and marking old data as deleted"],"requires":["Sufficient disk space for temporary segment copies during compaction (typically 1.5-2x collection size)","Background I/O capacity for compaction without impacting query performance"],"input_types":["vector data and payloads","compaction thresholds (configurable)"],"output_types":["optimized segment layout","compaction metrics (segments merged, space reclaimed)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_6","uri":"capability://automation.workflow.snapshot.based.backup.and.recovery.with.point.in.time.consistency","name":"snapshot-based backup and recovery with point-in-time consistency","description":"Creates consistent snapshots of collections at specific points in time, capturing all segments, indices, and metadata needed to restore the collection to that exact state. Snapshots are stored as compressed archives containing segment data and can be transferred between nodes for recovery or cloning. The snapshot mechanism uses write-ahead logging to ensure consistency; snapshots capture the state after all writes up to a specific log position, enabling point-in-time recovery without data loss.","intents":["Create backups of vector collections for disaster recovery","Clone collections to new nodes or environments without re-indexing","Recover from data corruption or accidental deletions to a known-good state"],"best_for":["Production deployments requiring disaster recovery capabilities","Teams needing to migrate collections between environments","Organizations with compliance requirements for data backup and recovery"],"limitations":["Snapshot creation requires reading entire collection into memory/disk; for large collections (>10GB), this can take minutes","Snapshots are full copies; incremental snapshots are not supported, so backup storage grows linearly with collection size","Recovery from snapshot requires stopping writes to the collection during restore"],"requires":["Sufficient disk space to store snapshot archives (equal to collection size)","Network bandwidth for snapshot transfer between nodes","Write-ahead logging enabled (default)"],"input_types":["collection name","snapshot destination (local path or remote storage)"],"output_types":["snapshot archive (compressed tar/zip)","snapshot metadata (timestamp, point-in-time log position)"],"categories":["automation-workflow","data-processing-analysis"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_7","uri":"capability://tool.use.integration.multi.protocol.api.support.with.rest.and.grpc.endpoints","name":"multi-protocol api support with rest and grpc endpoints","description":"Exposes vector database operations through both REST (HTTP/JSON) and gRPC (Protocol Buffers) APIs with identical functionality, allowing clients to choose based on performance and integration requirements. REST API is built on actix-web framework and gRPC on tonic framework, both routing to the same underlying dispatcher and collection management layer. This dual-protocol approach enables easy integration with web applications (REST) while supporting high-performance services (gRPC) without maintaining separate code paths.","intents":["Integrate Qdrant with web applications and REST-based microservices","Build high-performance services using gRPC for lower latency and bandwidth","Support multiple client languages through language-specific gRPC code generation"],"best_for":["Teams with mixed tech stacks needing both REST and gRPC support","Web applications requiring JSON-based APIs","Microservices architectures where gRPC performance is critical"],"limitations":["REST API has higher latency (typically 5-10ms overhead vs gRPC) due to JSON serialization","gRPC requires HTTP/2 support; some legacy infrastructure may not support it","Both APIs have identical feature sets, so no capability differences between protocols"],"requires":["HTTP/1.1 support for REST API","HTTP/2 support for gRPC API","Client libraries for chosen protocol (curl/requests for REST, gRPC client libraries for gRPC)"],"input_types":["REST: JSON payloads","gRPC: Protocol Buffer messages"],"output_types":["REST: JSON responses","gRPC: Protocol Buffer messages"],"categories":["tool-use-integration","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_8","uri":"capability://data.processing.analysis.gpu.accelerated.vector.operations.for.dense.search","name":"gpu-accelerated vector operations for dense search","description":"Offloads computationally intensive vector operations (distance calculations, HNSW graph traversal) to GPU when available, using CUDA for NVIDIA GPUs. GPU acceleration is transparent to clients; the system automatically detects GPU availability and routes eligible operations to GPU kernels while falling back to CPU for unsupported operations or when GPU is unavailable. Distance calculations benefit most from GPU acceleration (10-50x speedup for large batches), while HNSW traversal benefits less due to irregular memory access patterns.","intents":["Speed up batch search queries by 10-50x using GPU acceleration","Reduce CPU load for high-throughput search workloads","Enable real-time search on large collections (>100M vectors) with sub-100ms latency"],"best_for":["High-throughput search systems processing thousands of queries per second","Batch search workloads where GPU acceleration provides maximum benefit","Teams with GPU infrastructure (NVIDIA GPUs with CUDA support)"],"limitations":["GPU acceleration is only available for distance calculations; HNSW graph traversal remains CPU-bound","GPU memory is limited; batch sizes are constrained by GPU VRAM (typically 8-40GB)","GPU acceleration requires NVIDIA GPUs with CUDA support; AMD and Intel GPUs are not supported"],"requires":["NVIDIA GPU with CUDA Compute Capability 3.5 or higher","CUDA Toolkit 11.0+ installed on the system","Sufficient GPU VRAM for batch processing (minimum 2GB, recommended 8GB+)"],"input_types":["dense float32 vectors","batch size (number of queries)"],"output_types":["distance scores computed on GPU","ranked results"],"categories":["data-processing-analysis","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0},{"id":"github-qdrant--qdrant__cap_9","uri":"capability://automation.workflow.collection.aliasing.for.zero.downtime.index.updates","name":"collection aliasing for zero-downtime index updates","description":"Allows multiple collection names to point to the same underlying data, enabling zero-downtime updates by creating a new collection, indexing data, and atomically switching the alias to the new collection. Aliases are stored in the distributed consensus layer (Raft) and switches are atomic across the cluster. This pattern enables blue-green deployments where the old collection remains available until the new one is fully indexed, then traffic is switched via alias update.","intents":["Update vector indices without downtime by switching aliases","Implement blue-green deployments for collections","Maintain multiple versions of a collection for A/B testing"],"best_for":["Production systems requiring zero-downtime updates","Teams implementing blue-green deployment patterns","Organizations needing to test new indices before switching traffic"],"limitations":["Aliases require manual orchestration; no built-in automation for creating/indexing new collections","Both old and new collections consume storage until the old one is deleted","Alias switches are atomic but not instantaneous; clients may see brief inconsistency if they cache collection names"],"requires":["Distributed consensus layer (Raft) for atomic alias updates","Manual orchestration to create new collection and index data before switching"],"input_types":["alias name","collection name to point to"],"output_types":["alias update confirmation","list of collections pointed to by alias"],"categories":["automation-workflow","search-retrieval"],"confidence":0.5,"matches":0,"success_rate":0}],"trust":{"score":44,"verified":false,"data_access_risk":"high","permissions":["Vector dimension size must be consistent across all vectors in a collection","Sufficient RAM to hold HNSW graph in memory (typically 10-50 bytes per vector depending on M parameter)","Rust runtime (Qdrant is written in Rust)","Both dense and sparse vector representations for each document","Sparse vectors in COO (coordinate) format with indices and values","Configuration of weight parameter to balance dense vs sparse score contribution","Persistent storage with reliable fsync semantics (SSD recommended)","Configuration of fsync policy (immediate, batch, or disabled)","Batch size within memory limits (typically <100k points per batch)","Points in batch must be formatted according to API schema"],"failure_modes":["HNSW graph construction is O(n log n) and memory-intensive; adding vectors to existing indices requires graph restructuring","Approximate search means recall is not 100% — some true nearest neighbors may be missed depending on ef parameter","Graph structure is immutable after segment creation; updates require segment compaction and rebuilding","Sparse vector indexing requires explicit tokenization/vocabulary management; no built-in NLP preprocessing","Weighted combination of dense and sparse scores requires manual tuning of weight parameters for each use case","Sparse vectors must be pre-computed by the client; Qdrant does not generate sparse representations","Immediate fsync (highest durability) adds 5-20ms latency per write operation","Batched fsync reduces latency but increases data loss risk if node crashes between fsync operations","WAL disk I/O can become a bottleneck for very high write throughput (>10k writes/sec)","Batch size is limited by available memory; very large batches (>100k points) may cause memory pressure","builder identity is not verified yet","no observed match outcomes yet"],"rank_breakdown":{"adoption":0.4058424862117526,"quality":0.5,"ecosystem":0.6000000000000001,"match_graph":0.25,"freshness":0.75,"weights":{"adoption":0.3,"quality":0.25,"ecosystem":0.15,"match_graph":0.25,"freshness":0.05}},"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.063Z","last_scraped_at":"2026-05-03T13:58:32.037Z","last_commit":"2026-05-03T12:57:24Z"},"community":{"stars":30980,"forks":2230,"weekly_downloads":null,"model_downloads":null,"model_likes":null}},"distribution":{"claim_url":"https://unfragile.ai/submit?claim=qdrant--qdrant","compare_url":"https://unfragile.ai/compare?artifact=qdrant--qdrant"}},"signature":"gfu30BRpT8yXEBdflx811RtgQAYhHDNLeq6xTb7oatmM8pwR4PfrN/DewrzACktNKnMJryFZojywJH2N48aLCA==","signedAt":"2026-06-22T22:00:05.295Z","signedBy":"unfragile.ai","version":1},"_links":{"self":"https://unfragile.ai/api/v1/passport/qdrant--qdrant","artifact":"https://unfragile.ai/qdrant--qdrant","verify":"https://unfragile.ai/api/v1/verify?slug=qdrant--qdrant","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"}}