10장: 메타데이터 필터링과 고급 쿼리

from qdrant_client.models import PayloadSchemaType
 
# 키워드 인덱스 (정확한 일치)
client.create_payload_index(
    collection_name="products",
    field_name="category",
    field_schema=PayloadSchemaType.KEYWORD
)
 
# 정수 인덱스 (범위 쿼리)
client.create_payload_index(
    collection_name="products",
    field_name="price",
    field_schema=PayloadSchemaType.INTEGER
)
 
# 전문 검색 인덱스
client.create_payload_index(
    collection_name="products",
    field_name="description",
    field_schema=PayloadSchemaType.TEXT
)
 
# 지리 인덱스
client.create_payload_index(
    collection_name="stores",
    field_name="location",
    field_schema=PayloadSchemaType.GEO
)

import weaviate.classes.config as wc
 
client.collections.create(
    name="Product",
    properties=[
        wc.Property(
            name="category",
            data_type=wc.DataType.TEXT,
            indexFilterable=True,     # 필터 인덱스 활성화
            indexSearchable=False,    # BM25 검색 인덱스 비활성화
            skip_vectorization=True
        ),
        wc.Property(
            name="price",
            data_type=wc.DataType.NUMBER,
            indexFilterable=True,
            indexRangeFilters=True,   # 범위 쿼리 인덱스
            skip_vectorization=True
        ),
        wc.Property(
            name="description",
            data_type=wc.DataType.TEXT,
            indexFilterable=False,
            indexSearchable=True,     # BM25 검색 대상
        ),
    ]
)

# Qdrant: 복합 필터
from qdrant_client.models import Filter, FieldCondition, MatchValue, Range
 
complex_filter = Filter(
    must=[
        # AND 조건
        FieldCondition(key="category", match=MatchValue(value="electronics")),
        FieldCondition(key="in_stock", match=MatchValue(value=True)),
    ],
    should=[
        # OR 조건 (하나 이상 만족)
        FieldCondition(key="brand", match=MatchValue(value="Samsung")),
        FieldCondition(key="brand", match=MatchValue(value="Apple")),
    ],
    must_not=[
        # NOT 조건
        FieldCondition(key="status", match=MatchValue(value="discontinued")),
    ]
)
 
results = client.query_points(
    collection_name="products",
    query=query_vector,
    query_filter=complex_filter,
    limit=10
)

# Weaviate: 복합 필터
from weaviate.classes.query import Filter
 
results = articles.query.near_text(
    query="검색어",
    filters=(
        Filter.by_property("category").equal("electronics") &
        Filter.by_property("in_stock").equal(True) &
        (
            Filter.by_property("brand").equal("Samsung") |
            Filter.by_property("brand").equal("Apple")
        )
    ),
    limit=10
)

# Qdrant: 가격 범위 + 날짜 범위
range_filter = Filter(
    must=[
        FieldCondition(
            key="price",
            range=Range(gte=10000, lte=50000)
        ),
        FieldCondition(
            key="created_at",
            range=Range(gte="2024-01-01T00:00:00Z")
        ),
    ]
)

# Qdrant: 반경 내 검색
from qdrant_client.models import GeoRadius, GeoPoint
 
geo_filter = Filter(
    must=[
        FieldCondition(
            key="location",
            geo_radius=GeoRadius(
                center=GeoPoint(lat=37.5665, lon=126.9780),  # 서울 시청
                radius=5000  # 5km 반경
            )
        )
    ]
)
 
# 벡터 유사도 + 5km 반경 내 매장 검색
results = client.query_points(
    collection_name="stores",
    query=query_vector,
    query_filter=geo_filter,
    limit=10
)

# 삽입 시 테넌트 ID 포함
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(
            id=1,
            vector=[0.1, 0.2, ...],
            payload={
                "tenant_id": "tenant-a",
                "content": "문서 내용"
            }
        )
    ]
)
 
# 검색 시 테넌트 ID 필터
results = client.query_points(
    collection_name="documents",
    query=query_vector,
    query_filter=Filter(
        must=[FieldCondition(key="tenant_id", match=MatchValue(value="tenant-a"))]
    ),
    limit=10
)

# Weaviate: 네이티브 멀티테넌시
tenant_collection = collection.with_tenant("tenant-a")
results = tenant_collection.query.near_text(query="검색어", limit=10)
 
# Pinecone: 네임스페이스
results = index.query(
    vector=query_vector,
    top_k=10,
    namespace="tenant-a"
)

# 높은 카디널리티 (비효율적 필터)
# user_id: 100만 개 고유 값 -> 각 값에 해당하는 벡터가 극소수
# -> 멀티테넌시 패턴 사용 권장
 
# 적절한 카디널리티 (효율적 필터)
# category: 20개 고유 값 -> 각 카테고리에 수만 개 벡터
# -> 필터 인덱스 최적
 
# 낮은 카디널리티 (선택성 부족)
# is_active: 2개 값 (True/False) -> 필터 효과 미미
# -> 다른 필터와 조합하여 사용

import time
 
def benchmark_filter(client, collection, query_vector, filter_condition, n_runs=100):
    """필터 성능 벤치마크"""
    latencies = []
    for _ in range(n_runs):
        start = time.perf_counter()
        client.query_points(
            collection_name=collection,
            query=query_vector,
            query_filter=filter_condition,
            limit=10
        )
        latencies.append((time.perf_counter() - start) * 1000)
 
    latencies.sort()
    return {
        "p50_ms": latencies[len(latencies) // 2],
        "p95_ms": latencies[int(len(latencies) * 0.95)],
        "p99_ms": latencies[int(len(latencies) * 0.99)],
    }