Qdrant ベクトルDB運用完全ガイド — コレクション設計からRAG連携まで

from qdrant_client import QdrantClient
from qdrant_client.models import Distance, VectorParams, HnswConfigDiff, OptimizersConfigDiff
from qdrant_client.models import ScalarQuantization, ScalarQuantizationConfig, ScalarType

client = QdrantClient(host="localhost", port=6333)

client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,              # OpenAI text-embedding-3-small の次元数
        distance=Distance.COSINE,
    ),
    hnsw_config=HnswConfigDiff(
        m=16,                   # グラフ接続数
        ef_construct=128,       # インデックス構築時の探索幅
    ),
    optimizers_config=OptimizersConfigDiff(
        indexing_threshold=20000,
    ),
    quantization_config=ScalarQuantization(
        scalar=ScalarQuantizationConfig(type=ScalarType.INT8, quantile=0.99, always_ram=True),
    ),
)

# Scalar Quantization: float32 → int8（メモリ4倍削減）
# 一般的なテキスト検索に適合、recall損失 < 1%

# Binary Quantization: float32 → 1-bit（メモリ32倍削減）
# 非常にアグレッシブ。高次元（1536+）でのみ使用。oversamplingが必要
from qdrant_client.models import BinaryQuantization, BinaryQuantizationConfig

client.update_collection(
    collection_name="documents",
    quantization_config=BinaryQuantization(
        binary=BinaryQuantizationConfig(
            always_ram=True,
        ),
    ),
)

from qdrant_client.models import PointStruct
import openai

def get_embedding(text: str) -> list[float]:
    resp = openai.embeddings.create(model="text-embedding-3-small", input=text)
    return resp.data[0].embedding

# 単件upsert
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(
            id=1,
            vector=get_embedding("QdrantはRustで書かれたベクトルDBです。"),
            payload={"title": "Qdrant入門", "category": "database", "tenant_id": "team-alpha"},
        ),
    ],
)

# バッチupsert — 100件ずつ処理
BATCH_SIZE = 100
for i in range(0, len(points), BATCH_SIZE):
    client.upsert(collection_name="documents", points=points[i : i + BATCH_SIZE])

from qdrant_client.models import SearchParams

results = client.search(
    collection_name="documents",
    query_vector=get_embedding("ベクトルデータベースのパフォーマンス最適化"),
    limit=10,
    score_threshold=0.7,
    search_params=SearchParams(
        hnsw_ef=128,       # 検索時のef値（精度調整）
        exact=False,       # Trueにするとbrute-force（正確だが遅い）
    ),
    with_payload=True,
    with_vectors=False,    # ベクトル自体は返さない（レスポンスサイズ削減）
)

for result in results:
    print(f"ID: {result.id}, Score: {result.score:.4f}")
    print(f"  Title: {result.payload['title']}")

curl -X POST "http://localhost:6333/collections/documents/points/search" \
  -H "Content-Type: application/json" \
  -d '{
    "vector": [0.1, 0.2, ...],
    "limit": 10,
    "with_payload": true,
    "params": {
      "hnsw_ef": 128
    }
  }'

from qdrant_client.models import PointIdsList, FilterSelector, Filter, FieldCondition, MatchValue

# ペイロードの更新
client.set_payload(collection_name="documents", payload={"category": "vector-database"}, points=[1, 2, 3])

# IDベースのポイント削除
client.delete(collection_name="documents", points_selector=PointIdsList(points=[10, 11, 12]))

# フィルタベースの削除
client.delete(
    collection_name="documents",
    points_selector=FilterSelector(
        filter=Filter(must=[FieldCondition(key="category", match=MatchValue(value="deprecated"))])
    ),
)

from qdrant_client.models import PayloadSchemaType, TextIndexParams, TokenizerType

# キーワードインデックス（完全一致）
client.create_payload_index(collection_name="documents", field_name="category", field_schema=PayloadSchemaType.KEYWORD)

# 整数インデックス（範囲検索）
client.create_payload_index(collection_name="documents", field_name="page_count", field_schema=PayloadSchemaType.INTEGER)

# テキストインデックス（全文検索 — 多言語トークナイザ）
client.create_payload_index(
    collection_name="documents",
    field_name="content",
    field_schema=TextIndexParams(type="text", tokenizer=TokenizerType.MULTILINGUAL, min_token_len=2, max_token_len=20),
)

from qdrant_client.models import Filter, FieldCondition, MatchValue, Range

# カテゴリが"database"でページ数が10以上のドキュメントの類似度検索
results = client.search(
    collection_name="documents",
    query_vector=get_embedding("ベクトルインデックスの最適化"),
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="database"),
            ),
            FieldCondition(
                key="page_count",
                range=Range(gte=10),
            ),
        ],
        must_not=[
            FieldCondition(
                key="status",
                match=MatchValue(value="archived"),
            ),
        ],
    ),
    limit=5,
)

from qdrant_client.models import SparseVector, SparseVectorParams, Prefetch, FusionQuery, Fusion

# dense + sparseベクトル設定でコレクション作成
client.create_collection(
    collection_name="hybrid_docs",
    vectors_config={"dense": VectorParams(size=1536, distance=Distance.COSINE)},
    sparse_vectors_config={"sparse": SparseVectorParams()},
)

# Reciprocal Rank Fusionベースのハイブリッド検索
results = client.query_points(
    collection_name="hybrid_docs",
    prefetch=[
        Prefetch(query=get_embedding("ベクトル検索のパフォーマンス"), using="dense", limit=20),
        Prefetch(query=SparseVector(indices=[1, 42, 1337], values=[0.9, 0.3, 0.7]), using="sparse", limit=20),
    ],
    query=FusionQuery(fusion=Fusion.RRF),
    limit=10,
)

from langchain_openai import OpenAIEmbeddings, ChatOpenAI
from langchain_qdrant import QdrantVectorStore
from langchain.chains import RetrievalQA
from langchain.text_splitter import RecursiveCharacterTextSplitter

# 1. ドキュメント分割
text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=500,
    chunk_overlap=50,
    separators=["\n\n", "\n", ". ", " ", ""],
)
chunks = text_splitter.split_documents(documents)

# 2. ベクトルストア作成
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vectorstore = QdrantVectorStore.from_documents(
    documents=chunks,
    embedding=embeddings,
    url="http://localhost:6333",
    collection_name="rag_documents",
    force_recreate=True,
)

# 3. RAGチェーン構築
retriever = vectorstore.as_retriever(
    search_type="similarity_score_threshold",
    search_kwargs={
        "k": 5,
        "score_threshold": 0.7,
    },
)

llm = ChatOpenAI(model="gpt-4o", temperature=0)

qa_chain = RetrievalQA.from_chain_type(
    llm=llm,
    chain_type="stuff",
    retriever=retriever,
    return_source_documents=True,
)

# 4. 質問応答
response = qa_chain.invoke({"query": "QdrantのHNSWインデックスパラメータはどう調整しますか？"})
print(response["result"])

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader, Settings
from llama_index.vector_stores.qdrant import QdrantVectorStore
from llama_index.embeddings.openai import OpenAIEmbedding
from llama_index.llms.openai import OpenAI
import qdrant_client

# 1. Qdrantクライアント & ベクトルストア
qclient = qdrant_client.QdrantClient(host="localhost", port=6333)

vector_store = QdrantVectorStore(
    client=qclient,
    collection_name="llamaindex_docs",
)

# 2. 設定
Settings.embed_model = OpenAIEmbedding(model="text-embedding-3-small")
Settings.llm = OpenAI(model="gpt-4o", temperature=0)
Settings.chunk_size = 512
Settings.chunk_overlap = 50

# 3. ドキュメント読み込みとインデキシング
documents = SimpleDirectoryReader("./data").load_data()

index = VectorStoreIndex.from_documents(
    documents,
    vector_store=vector_store,
)

# 4. クエリエンジン
query_engine = index.as_query_engine(
    similarity_top_k=5,
)

response = query_engine.query("Qdrantでフィルタリングとベクトル検索を同時に行う方法は？")
print(response)

# メトリクスの確認
curl http://localhost:6333/metrics

# 主要メトリクス
# qdrant_grpc_responses_total        — gRPCリクエスト数
# qdrant_rest_responses_total        — RESTリクエスト数
# qdrant_collection_points_total     — コレクション別ポイント数
# qdrant_collection_search_latency   — 検索レイテンシー

# スナップショットの作成と一覧取得
client.create_snapshot(collection_name="documents")
snapshots = client.list_snapshots(collection_name="documents")
for snap in snapshots:
    print(f"Name: {snap.name}, Size: {snap.size}")

# REST APIでスナップショットをダウンロード
curl -o snapshot.tar "http://localhost:6333/collections/documents/snapshots/snapshot-2026-03-09.snapshot"

# 全ストレージスナップショット（全コレクション含む）
curl -X POST "http://localhost:6333/snapshots"

# gRPC使用を推奨
client = QdrantClient(
    host="localhost",
    port=6333,
    grpc_port=6334,
    prefer_grpc=True,
)