Skip to main content ホーム クリエイター dabit3 sonic-agent qdrant-vector-search
qdrant-vector-search High-performance vector similarity search engine for RAG and semantic search. Use when building production RAG systems requiring fast nearest neighbor search, hybrid search with filtering, or scalable vector storage with Rust-powered performance.
インストールへ移動 Skills Marketplace コミュニティが作成したAIスキルを発見・探索
Codex または Claude でインストール この Prompt をコピーして Codex、Claude、または他のアシスタントに貼り付けると、Skill ページを確認してインストールできます。
直接コマンドでは確認用 Prompt が省略されます。実行前にソースを確認してください。
npx skills add https://github.com/dabit3/sonic-agent --skill qdrant-vector-searchコマンドは1行のまま表示されます。コピー前に横へスクロールして全体を確認してください。
ローカルで確認しますか？SkillsMP が現在取得できるファイルをダウンロードできます。
Zipをダウンロード ダウンロード中... name qdrant-vector-search description High-performance vector similarity search engine for RAG and semantic search. Use when building production RAG systems requiring fast nearest neighbor search, hybrid search with filtering, or scalable vector storage with Rust-powered performance. version 1.0.0 author Orchestra Research license MIT dependencies ["qdrant-client>=1.12.0"] platforms ["linux","macos","windows"] metadata {"sonic":{"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 performanceRich filtering : Filter by any payload field during searchMultiple vectors : Dense, sparse, multi-dense per pointQuantization : Scalar, product, binary for memory efficiencyDistributed : Raft consensus, sharding, replicationREST + gRPC : Both APIs with full feature parity
Use alternatives instead:
Chroma : Simpler setup, embedded use casesFAISS : Maximum raw speed, research/batch processingPinecone : Fully managed, zero ops preferredWeaviate : GraphQL preference, built-in vectorizers
Quick start
Installation
pip install qdrant-client
docker run -p 6333:6333 -p 6334:6334 qdrant/qdrant
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
client = QdrantClient(host="localhost" , port=6333 )
client.create_collection(
collection_name="documents"
384
"documents"
id
1
0.1
0.2
"title"
"Doc 1"
"category"
"tech"
id
2
0.3
0.4
"title"
"Doc 2"
"category"
"science"
"documents"
0.15
0.25
"must"
"key"
"category"
"match"
"value"
"tech"
10
for
in
print
f"ID: {point.id } , Score: {point.score} , Payload: {point.payload} "
Core concepts
Points - Basic data unit from qdrant_client.models import PointStruct
point = PointStruct(
id =123 ,
vector=[0.1 , 0.2 , 0.3 , ...],
payload={
"title" : "Document title" ,
"category" : "tech" ,
"timestamp" : 1699900000 ,
"tags" : ["python" , "ml" ]
}
)
client.upsert(
collection_name="documents" ,
points=[point1, point2, point3],
wait=True
)
Collections - Vector containers from qdrant_client.models import VectorParams, Distance, HnswConfigDiff
client.create_collection(
collection_name="documents" ,
vectors_config=VectorParams(
size=384 ,
distance=Distance.COSINE
),
hnsw_config=HnswConfigDiff(
m=16 ,
ef_construct=100 ,
full_scan_threshold=10000
),
on_disk_payload=True
)
info = client.get_collection("documents" )
print (f"Points: {info.points_count} , Vectors: {info.vectors_count} " )
Distance metrics Metric Use Case Range COSINEText embeddings, normalized vectors 0 to 2 EUCLIDSpatial data, image features 0 to ∞ DOTRecommendations, unnormalized -∞ to ∞ MANHATTANSparse features, discrete data 0 to ∞
Search operations
Basic search
results = client.search(
collection_name="documents" ,
query_vector=[0.1 , 0.2 , ...],
limit=10 ,
with_payload=True ,
with_vectors=False
)
Filtered search from qdrant_client.models import Filter, FieldCondition, MatchValue, Range
results = client.search(
collection_name="documents" ,
query_vector=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
)
results = client.search(
collection_name="documents" ,
query_vector=query_embedding,
query_filter={
"must" : [
{"key" : "category" , "match" : {"value" : "tech" }},
{"key" : "price" , "range" : {"gte" : 10 , "lte" : 100 }}
]
},
limit=10
)
Batch search from qdrant_client.models import SearchRequest
results = client.search_batch(
collection_name="documents" ,
requests=[
SearchRequest(vector=[0.1 , ...], limit=5 ),
SearchRequest(vector=[0.2 , ...], limit=5 , filter ={"must" : [...]}),
SearchRequest(vector=[0.3 , ...], limit=10 )
]
)
RAG integration
With sentence-transformers from sentence_transformers import SentenceTransformer
from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, Distance, PointStruct
encoder = SentenceTransformer("all-MiniLM-L6-v2" )
client = QdrantClient(host="localhost" , port=6333 )
client.create_collection(
collection_name="knowledge_base" ,
vectors_config=VectorParams(size=384 , distance=Distance.COSINE)
)
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)
def retrieve (query: str , top_k: int = 5 ) -> list [dict ]:
query_vector = encoder.encode(query).tolist()
results = client.search(
collection_name="knowledge_base" ,
query_vector=query_vector,
limit=top_k
)
return [{"text" : r.payload["text" ], "score" : r.score} for r in results]
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
client.create_collection(
collection_name="hybrid_search" ,
vectors_config={
"dense" : VectorParams(size=384 , distance=Distance.COSINE),
"sparse" : VectorParams(size=30000 , distance=Distance.DOT)
}
)
client.upsert(
collection_name="hybrid_search" ,
points=[
PointStruct(
id =1 ,
vector={
"dense" : dense_embedding,
"sparse" : sparse_embedding
},
payload={"text" : "document text" }
)
]
)
results = client.search(
collection_name="hybrid_search" ,
query_vector=("dense" , query_dense),
limit=10
)
Sparse vectors (BM25, SPLADE) from qdrant_client.models import SparseVectorParams, SparseIndexParams, SparseVector
client.create_collection(
collection_name="sparse_search" ,
vectors_config={},
sparse_vectors_config={"text" : SparseVectorParams(index=SparseIndexParams(on_disk=False ))}
)
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
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 ,
always_ram=True
)
)
)
results = client.search(
collection_name="quantized" ,
query_vector=query,
search_params={"quantization" : {"rescore" : True }},
limit=10
)
Payload indexing from qdrant_client.models import PayloadSchemaType
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
)
Production deployment
Qdrant Cloud from qdrant_client import QdrantClient
client = QdrantClient(
url="https://your-cluster.cloud.qdrant.io" ,
api_key="your-api-key"
)
Performance tuning
client.update_collection(
collection_name="documents" ,
hnsw_config=HnswConfigDiff(ef_construct=200 , m=32 )
)
client.update_collection(
collection_name="documents" ,
optimizer_config={"indexing_threshold" : 20000 }
)
Best practices
Batch operations - Use batch upsert/search for efficiencyPayload indexing - Index fields used in filtersQuantization - Enable for large collections (>1M vectors)Sharding - Use for collections >10M vectorsOn-disk storage - Enable on_disk_payload for large payloadsConnection pooling - Reuse client instances
Common issues Slow search with filters:
client.create_payload_index(
collection_name="docs" ,
field_name="category" ,
field_schema=PayloadSchemaType.KEYWORD
)
client.create_collection(
collection_name="large_collection" ,
vectors_config=VectorParams(size=384 , distance=Distance.COSINE),
quantization_config=ScalarQuantization(...),
on_disk_payload=True
)
client = QdrantClient(
host="localhost" ,
port=6333 ,
timeout=30 ,
prefer_grpc=True
)
References
Resources 