4장: 벡터 데이터베이스 비교와 선택

전통 DB:    SELECT * FROM docs WHERE category = 'policy'
벡터 DB:    query_vector에 가장 가까운 상위 5개 벡터 반환

from pinecone import Pinecone, ServerlessSpec
 
pc = Pinecone(api_key="your-api-key")
 
# 인덱스 생성
pc.create_index(
    name="rag-knowledge-base",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(
        cloud="aws",
        region="us-east-1"
    )
)
 
index = pc.Index("rag-knowledge-base")
 
# 벡터 업서트
index.upsert(
    vectors=[
        {
            "id": "doc-001",
            "values": embedding_vector,
            "metadata": {
                "source": "company_policy.pdf",
                "section": "휴가 정책",
                "date": "2026-01-15"
            }
        }
    ],
    namespace="policies"
)
 
# 검색
results = index.query(
    vector=query_vector,
    top_k=5,
    include_metadata=True,
    namespace="policies",
    filter={"date": {"$gte": "2025-01-01"}}
)

import weaviate
from weaviate.classes.init import Auth
from weaviate.classes.query import MetadataQuery
 
client = weaviate.connect_to_weaviate_cloud(
    cluster_url="your-cluster-url",
    auth_credentials=Auth.api_key("your-api-key")
)
 
# 컬렉션 정의
collection = client.collections.create(
    name="Document",
    vectorizer_config=weaviate.classes.config.Configure.Vectorizer.text2vec_openai(
        model="text-embedding-3-small"
    ),
    properties=[
        weaviate.classes.config.Property(
            name="content", data_type=weaviate.classes.config.DataType.TEXT
        ),
        weaviate.classes.config.Property(
            name="source", data_type=weaviate.classes.config.DataType.TEXT
        ),
    ]
)
 
# 텍스트만 넣으면 자동으로 임베딩 생성
collection.data.insert(
    properties={
        "content": "재택근무는 주 2회까지 신청할 수 있습니다.",
        "source": "hr_policy.pdf"
    }
)
 
# 하이브리드 검색 (벡터 + BM25)
results = collection.query.hybrid(
    query="재택근무 신청 방법",
    limit=5,
    alpha=0.7,  # 0=순수 BM25, 1=순수 벡터
    return_metadata=MetadataQuery(score=True)
)

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct,
    Filter, FieldCondition, MatchValue
)
 
client = QdrantClient(url="http://localhost:6333")
 
# 컬렉션 생성
client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE
    )
)
 
# 벡터 업서트
client.upsert(
    collection_name="documents",
    points=[
        PointStruct(
            id=1,
            vector=embedding_vector,
            payload={
                "content": "연차는 입사일 기준으로 부여됩니다.",
                "source": "hr_policy.pdf",
                "category": "휴가",
                "year": 2026
            }
        )
    ]
)
 
# 필터링 검색
results = client.query_points(
    collection_name="documents",
    query=query_vector,
    limit=5,
    query_filter=Filter(
        must=[
            FieldCondition(
                key="category",
                match=MatchValue(value="휴가")
            )
        ]
    )
)

-- pgvector 확장 설치
CREATE EXTENSION vector;
 
-- 벡터 컬럼이 있는 테이블 생성
CREATE TABLE documents (
    id SERIAL PRIMARY KEY,
    content TEXT NOT NULL,
    source TEXT,
    category TEXT,
    embedding vector(1536),
    created_at TIMESTAMP DEFAULT NOW()
);
 
-- HNSW 인덱스 생성 (검색 성능 최적화)
CREATE INDEX ON documents
    USING hnsw (embedding vector_cosine_ops)
    WITH (m = 16, ef_construction = 200);
 
-- 유사도 검색
SELECT id, content, source,
       1 - (embedding <=> query_embedding) AS similarity
FROM documents
WHERE category = '휴가'
ORDER BY embedding <=> query_embedding
LIMIT 5;

import psycopg2
from pgvector.psycopg2 import register_vector
 
conn = psycopg2.connect("postgresql://user:pass@localhost/mydb")
register_vector(conn)
 
cur = conn.cursor()
 
# 검색
cur.execute("""
    SELECT id, content, 1 - (embedding <=> %s) AS similarity
    FROM documents
    ORDER BY embedding <=> %s
    LIMIT 5
""", (query_vector, query_vector))
 
results = cur.fetchall()

HNSW 그래프 구조:
Layer 2:  A -------- D          (성긴 연결, 빠른 탐색)
Layer 1:  A --- B --- D --- F   (중간 밀도)
Layer 0:  A-B-C-D-E-F-G-H-I    (모든 노드, 정밀 검색)

# Qdrant에서 바이너리 양자화 설정
from qdrant_client.models import (
    BinaryQuantization,
    BinaryQuantizationConfig
)
 
client.create_collection(
    collection_name="documents_quantized",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE
    ),
    quantization_config=BinaryQuantization(
        binary=BinaryQuantizationConfig(
            always_ram=True  # 양자화된 벡터를 항상 RAM에 유지
        )
    )
)

from langchain.embeddings import OpenAIEmbeddings
from langchain.schema import Document
 
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")
 
documents = [
    Document(
        page_content="연차는 입사일 기준으로 매년 15일이 부여됩니다.",
        metadata={"source": "hr_policy.pdf", "category": "휴가"}
    ),
    Document(
        page_content="재택근무는 팀장 승인 후 주 2회까지 가능합니다.",
        metadata={"source": "hr_policy.pdf", "category": "근무"}
    ),
]
 
# Pinecone
from langchain_pinecone import PineconeVectorStore
pinecone_store = PineconeVectorStore.from_documents(
    documents, embeddings, index_name="rag-demo"
)
 
# Qdrant
from langchain_qdrant import QdrantVectorStore
qdrant_store = QdrantVectorStore.from_documents(
    documents, embeddings,
    url="http://localhost:6333",
    collection_name="rag-demo"
)
 
# pgvector
from langchain_postgres import PGVector
pgvector_store = PGVector.from_documents(
    documents, embeddings,
    connection="postgresql://user:pass@localhost/mydb",
    collection_name="rag-demo"
)
 
# 동일한 인터페이스로 검색
results = pinecone_store.similarity_search("연차 몇 일?", k=3)