{
    "name": "qdrant",
    "version": "1.0.0",
    "description": "Vector search engine for production RAG systems.",
    "system_prompt": "name qdrant description Vector search engine for production RAG systems. version 1.0.1 author Orchestra Research license MIT dependencies [\"qdrant-client>=1.14.0\"] platforms [\"linux\",\"macos\",\"windows\"] metadata {\"hermes\":{\"tags\":[\"RAG\",\"Vector Search\",\"Qdrant\",\"Semantic Search\",\"Embeddings\",\"Similarity Search\",\"HNSW\",\"Production\",\"Distributed\"]}} Qdrant - Vector Similarity Search Engine High-performance vector database written in Rust for production RAG and semantic search. When to use Qdrant Use Qdrant when: Building production RAG systems requiring low latency Need hybrid search (vectors + metadata filtering) Require horizontal scaling with sharding/replication Want on-premise deployment with full data control Need multi-vector storage per record (dense + sparse) Building real-time recommendation systems Key features: Rust-powered : Memory-safe, high performance Rich filtering : Filter by any payload field during search Multiple vectors : Dense, sparse, multi-dense per point Quantization : Scalar, product, binary for memory efficiency Distributed : Raft consensus, sharding, replication REST + gRPC : Both APIs with full feature parity Use alternatives instead: Chroma : Simpler setup, embedded use cases FAISS : Maximum raw speed, research/batch processing Pinecone : Fully managed, zero ops preferred Weaviate : GraphQL preference, built-in vectorizers Quick start Installation # Python client pip install qdrant-client # Docker (recommended for development) docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant # Docker with persistent storage docker run -p 6333:6333 -p 6334:6334 \\ -v $( pwd )/qdrant_storage:/qdrant/storage \\ qdrant/qdrant Basic usage from qdrant_client import QdrantClient from qdrant_client.models import Distance, VectorParams, PointStruct # Connect to Qdrant client = QdrantClient(host= \"localhost\" , port= 6333 ) # Create collection client.create_collection( collection_name= \"documents\" , vectors_config=VectorParams(size= 384 , distance=Distance.COSINE) ) # Insert vectors with payload client.upsert( collection_name= \"documents\" , points=[ PointStruct( id = 1 , vector=[ 0.1 , 0.2 , ...], # 384-dim vector payload={ \"title\" : \"Doc 1\" , \"category\" : \"tech\" } ), PointStruct( id = 2 , vector=[ 0.3 , 0.4 , ...], payload={ \"title\" : \"Doc 2\" , \"category\" : \"science\" } ) ] ) # Search with filtering (query_points is the current API; client.search is removed in qdrant-client 1.14+) response = client.query_points( collection_name= \"documents\" , query=[ 0.15 , 0.25 , ...], query_filter={ \"must\" : [{ \"key\" : \"category\" , \"match\" : { \"value\" : \"tech\" }}] }, limit= 10 ) for point in response.points: print ( f\"ID: {point. id } , Score: {point.score} , Payload: {point.payload} \" ) Core concepts Points - Basic data unit from qdrant_client.models import PointStruct # Point = ID + Vector(s) + Payload point = PointStruct( id = 123 , # Integer or UUID string vector=[ 0.1 , 0.2 , 0.3 , ...], # Dense vector payload={ # Arbitrary JSON metadata \"title\" : \"Document title\" , \"category\" : \"tech\" , \"timestamp\" : 1699900000 , \"tags\" : [ \"python\" , \"ml\" ] } ) # Batch upsert (recommended) client.upsert( collection_name= \"documents\" , points=[point1, point2, point3], wait= True # Wait for indexing ) Collections - Vector containers from qdrant_client.models import VectorParams, Distance, HnswConfigDiff # Create with HNSW configuration client.create_collection( collection_name= \"documents\" , vectors_config=VectorParams( size= 384 , # Vector dimensions distance=Distance.COSINE # COSINE, EUCLID, DOT, MANHATTAN ), hnsw_config=HnswConfigDiff( m= 16 , # Connections per node (default 16) ef_construct= 100 , # Build-time accuracy (default 100) full_scan_threshold= 10000 # Switch to brute force below this ), on_disk_payload= True # Store payload on disk ) # Collection info info = client.get_collection( \"documents\" ) print ( f\"Points: {info.points_count} , Vectors: {info.vectors_count} \" ) Distance metrics Metric Use Case Range COSINE Text embeddings, normalized vectors 0 to 2 EUCLID Spatial data, image features 0 to ∞ DOT Recommendations, unnormalized -∞ to ∞ MANHATTAN Sparse features, discrete data 0 to ∞ Search operations Basic search # Simple nearest neighbor search (returns a QueryResponse; use .points) response = client.query_points( collection_name= \"documents\" , query=[ 0.1 , 0.2 , ...], limit= 10 , with_payload= True , with_vectors= False # Don't return vectors (faster) ) results = response.points Filtered search from qdrant_client.models import Filter, FieldCondition, MatchValue, Range # Complex filtering response = client.query_points( collection_name= \"documents\" , query=query_embedding, query_filter=Filter( must=[ FieldCondition(key= \"category\" , match =MatchValue(value= \"tech\" )), FieldCondition(key= \"timestamp\" , range =Range(gte= 1699000000 )) ], must_not=[ FieldCondition(key= \"status\" , match =MatchValue(value= \"archived\" )) ] ), limit= 10 ).points # Shorthand filter syntax response = client.query_points( collection_name= \"documents\" , query=query_embedding, query_filter={ \"must\" : [ { \"key\" : \"category\" , \"match\" : { \"value\" : \"tech\" }}, { \"key\" : \"price\" , \"range\" : { \"gte\" : 10 , \"lte\" : 100 }} ] }, limit= 10 ).points Batch search from qdrant_client.models import QueryRequest # Multiple queries in one request (search_batch is replaced by query_batch_points) responses = client.query_batch_points( collection_name= \"documents\" , requests=[ QueryRequest(query=[ 0.1 , ...], limit= 5 ), QueryRequest(query=[ 0.2 , ...], limit= 5 , filter ={ \"must\" : [...]}), QueryRequest(query=[ 0.3 , ...], limit= 10 ) ] ) # Each element is a QueryResponse; use .points for resp in responses: for point in resp.points: print (point. id , point.score) RAG integration With sentence-transformers from sentence_transformers import SentenceTransformer from qdrant_client import QdrantClient from qdrant_client.models import VectorParams, Distance, PointStruct # Initialize encoder = SentenceTransformer( \"all-MiniLM-L6-v2\" ) client = QdrantClient(host= \"localhost\" , port= 6333 ) # Create collection client.create_collection( collection_name= \"knowledge_base\" , vectors_config=VectorParams(size= 384 , distance=Distance.COSINE) ) # Index documents documents = [ { \"id\" : 1 , \"text\" : \"Python is a programming language\" , \"source\" : \"wiki\" }, { \"id\" : 2 , \"text\" : \"Machine learning uses algorithms\" , \"source\" : \"textbook\" }, ] points = [ PointStruct( id =doc[ \"id\" ], vector=encoder.encode(doc[ \"text\" ]).tolist(), payload={ \"text\" : doc[ \"text\" ], \"source\" : doc[ \"source\" ]} ) for doc in documents ] client.upsert(collection_name= \"knowledge_base\" , points=points) # RAG retrieval def retrieve ( query: str , top_k: int = 5 ) -> list [ dict ]: query_vector = encoder.encode(query).tolist() response = client.query_points( collection_name= \"knowledge_base\" , query=query_vector, limit=top_k ) return [{ \"text\" : r.payload[ \"text\" ], \"score\" : r.score} for r in response.points] # Use in RAG pipeline context = retrieve( \"What is Python?\" ) prompt = f\"Context: {context} \\n\\nQuestion: What is Python?\" With LangChain from langchain_community.vectorstores import Qdrant from langchain_community.embeddings import HuggingFaceEmbeddings embeddings = HuggingFaceEmbeddings(model_name= \"all-MiniLM-L6-v2\" ) vectorstore = Qdrant.from_documents(documents, embeddings, url= \"http://localhost:6333\" , collection_name= \"docs\" ) retriever = vectorstore.as_retriever(search_kwargs={ \"k\" : 5 }) With LlamaIndex from llama_index.vector_stores.qdrant import QdrantVectorStore from llama_index.core import VectorStoreIndex, StorageContext vector_store = QdrantVectorStore(client=client, collection_name= \"llama_docs\" ) storage_context = StorageContext.from_defaults(vector_store=vector_store) index = VectorStoreIndex.from_documents(documents, storage_context=storage_context) query_engine = index.as_query_engine() Multi-vector support Named vectors (different embedding models) from qdrant_client.models import VectorParams, Distance # Collection with multiple vector types client.create_collection( collection_name= \"hybrid_search\" , vectors_config={ \"dense\" : VectorParams(size= 384 , distance=Distance.COSINE), \"sparse\" : VectorParams(size= 30000 , distance=Distance.DOT) } ) # Insert with named vectors client.upsert( collection_name= \"hybrid_search\" , points=[ PointStruct( id = 1 , vector={ \"dense\" : dense_embedding, \"sparse\" : sparse_embedding }, payload={ \"text\" : \"document text\" } ) ] ) # Search specific named vector (pass the vector name via `using`) response = client.query_points( collection_name= \"hybrid_search\" , query=query_dense, using= \"dense\" , # Specify which named vector to search limit= 10 ) results = response.points Sparse vectors (BM25, SPLADE) from qdrant_client.models import SparseVectorParams, SparseIndexParams, SparseVector # Collection with sparse vectors client.create_collection( collection_name= \"sparse_search\" , vectors_config={}, sparse_vectors_config={ \"text\" : SparseVectorParams(index=SparseIndexParams(on_disk= False ))} ) # Insert sparse vector client.upsert( collection_name= \"sparse_search\" , points=[PointStruct( id = 1 , vector={ \"text\" : SparseVector(indices=[ 1 , 5 , 100 ], values=[ 0.5 , 0.8 , 0.2 ])}, payload={ \"text\" : \"document\" })] ) Quantization (memory optimization) from qdrant_client.models import ScalarQuantization, ScalarQuantizationConfig, ScalarType # Scalar quantization (4x memory reduction) client.create_collection( collection_name= \"quantized\" , vectors_config=VectorParams(size= 384 , distance=Distance.COSINE), quantization_config=ScalarQuantization( scalar=ScalarQuantizationConfig( type =ScalarType.INT8, quantile= 0.99 , # Clip outliers always_ram= True # Keep quantized in RAM ) ) ) # Search with rescoring response = client.query_points( collection_name= \"quantized\" , query=query, search_params={ \"quantization\" : { \"rescore\" : True }}, # Rescore top results limit= 10 ) results = response.points Payload indexing from qdrant_client.models import PayloadSchemaType # Create payload index for faster filtering client.create_payload_index( collection_name= \"documents\" , field_name= \"category\" , field_schema=PayloadSchemaType.KEYWORD ) client.create_payload_index( collection_name= \"documents\" , field_name= \"timestamp\" , field_schema=PayloadSchemaType.INTEGER ) # Index types: KEYWORD, INTEGER, FLOAT, GEO, TEXT (full-text), BOOL Production deployment Qdrant Cloud from qdrant_client import QdrantClient # Connect to Qdrant Cloud client = QdrantClient( url= \"https://your-cluster.cloud.qdrant.io\" , api_key= \"your-api-key\" ) Performance tuning",
    "model_config": {
        "provider": "deepseek",
        "model": "deepseek-chat",
        "temperature": 0.7,
        "max_tokens": 4096,
        "top_p": 0.9
    },
    "trigger_words": [],
    "source": "DeepseekModel",
    "source_url": "https://deepseekmodel.com/skill?id=nousresearch-hermes-agent-optional-skills-mlops-qdrant-skill-md"
}