8장: Qdrant와 pgvector -- 특화 솔루션들

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct,
    Filter, FieldCondition, MatchValue, Range,
    PayloadSchemaType
)
 
client = QdrantClient(url="http://localhost:6333")
 
# 컬렉션 생성
client.create_collection(
    collection_name="articles",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)
 
# 페이로드 인덱스 생성 (필터링 성능 최적화)
client.create_payload_index(
    collection_name="articles",
    field_name="category",
    field_schema=PayloadSchemaType.KEYWORD
)
client.create_payload_index(
    collection_name="articles",
    field_name="published_year",
    field_schema=PayloadSchemaType.INTEGER
)
 
# 포인트 삽입
client.upsert(
    collection_name="articles",
    points=[
        PointStruct(
            id=1,
            vector=[0.1, 0.2, ...],
            payload={
                "title": "HNSW 알고리즘 분석",
                "category": "algorithm",
                "published_year": 2025,
                "tags": ["hnsw", "ann", "graph"],
                "author": {"name": "Kim", "org": "Lab"}
            }
        )
    ]
)
 
# 복합 필터 검색
results = client.query_points(
    collection_name="articles",
    query=[0.1, 0.2, ...],
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="algorithm")),
            FieldCondition(key="published_year", range=Range(gte=2024)),
        ],
        must_not=[
            FieldCondition(key="tags", match=MatchValue(value="deprecated"))
        ]
    ),
    limit=10
)

client.create_collection(
    collection_name="products",
    vectors_config={
        "title": VectorParams(size=384, distance=Distance.COSINE),
        "description": VectorParams(size=1536, distance=Distance.COSINE),
        "image": VectorParams(size=768, distance=Distance.COSINE),
    }
)
 
# 삽입: 하나의 포인트에 세 개의 벡터
client.upsert(
    collection_name="products",
    points=[
        PointStruct(
            id=1,
            vector={
                "title": [0.1, 0.2, ...],       # 제목 임베딩
                "description": [0.3, 0.1, ...],  # 설명 임베딩
                "image": [0.5, 0.4, ...]          # 이미지 임베딩
            },
            payload={"name": "벡터 DB 교재", "price": 35000}
        )
    ]
)
 
# 특정 벡터로 검색
results = client.query_points(
    collection_name="products",
    query=[0.1, 0.2, ...],
    using="description",    # 설명 벡터 기준으로 검색
    limit=10
)

-- pgvector 확장 활성화
CREATE EXTENSION IF NOT EXISTS vector;
 
-- 테이블 생성 (벡터 + 일반 컬럼 통합)
CREATE TABLE articles (
    id SERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT NOT NULL,
    category TEXT NOT NULL,
    published_at TIMESTAMP DEFAULT NOW(),
    embedding vector(1536)   -- 1536차원 벡터 컬럼
);
 
-- HNSW 인덱스 생성
CREATE INDEX ON articles
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 200);
 
-- 벡터 삽입
INSERT INTO articles (title, content, category, embedding)
VALUES (
    'HNSW 알고리즘 분석',
    '벡터 데이터베이스에서 가장 널리 사용되는...',
    'algorithm',
    '[0.1, 0.2, ...]'::vector
);

-- 코사인 유사도 기반 검색 + 필터링
SELECT
    id,
    title,
    1 - (embedding <=> '[0.1, 0.2, ...]'::vector) AS similarity
FROM articles
WHERE category = 'algorithm'
  AND published_at >= '2024-01-01'
ORDER BY embedding <=> '[0.1, 0.2, ...]'::vector
LIMIT 10;

import psycopg2
from pgvector.psycopg2 import register_vector
import numpy as np
 
conn = psycopg2.connect("postgresql://user:pass@localhost:5432/mydb")
register_vector(conn)
 
cur = conn.cursor()
 
# 벡터 삽입
embedding = np.random.randn(1536).astype(np.float32)
cur.execute(
    "INSERT INTO articles (title, content, category, embedding) VALUES (%s, %s, %s, %s)",
    ("테스트 문서", "내용...", "test", embedding)
)
 
# 트랜잭션: 벡터와 메타데이터 원자적 업데이트
try:
    cur.execute("BEGIN")
    cur.execute(
        "UPDATE articles SET embedding = %s WHERE id = %s",
        (new_embedding, article_id)
    )
    cur.execute(
        "UPDATE article_stats SET update_count = update_count + 1 WHERE article_id = %s",
        (article_id,)
    )
    cur.execute("COMMIT")
except Exception:
    cur.execute("ROLLBACK")
    raise
 
# 검색
query_vector = np.random.randn(1536).astype(np.float32)
cur.execute(
    """
    SELECT id, title, 1 - (embedding <=> %s) AS similarity
    FROM articles
    WHERE category = 'algorithm'
    ORDER BY embedding <=> %s
    LIMIT 10
    """,
    (query_vector, query_vector)
)
results = cur.fetchall()

-- pgvectorscale의 StreamingDiskANN 인덱스
CREATE INDEX ON articles
USING diskann (embedding vector_cosine_ops)
WITH (
    num_neighbors = 50,
    search_list_size = 100,
    max_alpha = 1.2,
    num_dimensions = 1536,
    num_bits_per_dimension = 2   -- RaBitQ 양자화
);