✍️ 필사 모드: Vector Database 완전 가이드 2025: 임베딩, 유사도 검색, Pinecone/Weaviate/Qdrant/pgvector

전통 검색: "강아지 공원" → 키워드 매칭 → "강아지"와 "공원" 포함 문서만 반환
벡터 검색: "강아지 공원" → 의미 벡터화 → 유사한 의미의 모든 문서 반환
         → "개가 잔디밭에서 놀고 있다" ✅ 발견
         → "반려견 산책 장소 추천" ✅ 발견

from openai import OpenAI

client = OpenAI()

# 텍스트를 벡터로 변환
response = client.embeddings.create(
    model="text-embedding-3-large",
    input="Vector Database는 AI 시대의 핵심 인프라입니다"
)

embedding = response.data[0].embedding
print(f"차원 수: {len(embedding)}")   # 3072
print(f"벡터 샘플: {embedding[:5]}")  # [0.023, -0.041, 0.017, ...]

from sentence_transformers import SentenceTransformer
from PIL import Image

model = SentenceTransformer("clip-ViT-B-32")

# 이미지 임베딩
img = Image.open("cat_photo.jpg")
img_embedding = model.encode(img)

# 텍스트 임베딩 (같은 벡터 공간)
text_embedding = model.encode("a cute orange cat")

# 텍스트로 이미지 검색 가능!
from numpy import dot
from numpy.linalg import norm

similarity = dot(img_embedding, text_embedding) / (
    norm(img_embedding) * norm(text_embedding)
)
print(f"유사도: {similarity:.4f}")  # 0.28+ (관련 있으면 높음)

텍스트: "바다 위의 일몰" ──┐
                           ├──→ 동일 벡터 공간 → 유사도 비교 가능
이미지: 🌅 (일몰 사진)  ──┘

import numpy as np

def cosine_similarity(a, b):
    return np.dot(a, b) / (np.linalg.norm(a) * np.linalg.norm(b))

# 예시: 3차원 벡터
vec_a = np.array([1, 2, 3])
vec_b = np.array([2, 4, 6])  # 같은 방향, 크기만 다름
vec_c = np.array([-1, -2, -3])  # 반대 방향

print(cosine_similarity(vec_a, vec_b))  # 1.0 (완전 동일 방향)
print(cosine_similarity(vec_a, vec_c))  # -1.0 (완전 반대 방향)

def euclidean_distance(a, b):
    return np.linalg.norm(a - b)

vec_a = np.array([1, 2])
vec_b = np.array([4, 6])

print(euclidean_distance(vec_a, vec_b))  # 5.0

def dot_product(a, b):
    return np.dot(a, b)

vec_a = np.array([1, 2, 3])
vec_b = np.array([4, 5, 6])

print(dot_product(vec_a, vec_b))  # 32

def manhattan_distance(a, b):
    return np.sum(np.abs(a - b))

vec_a = np.array([1, 2, 3])
vec_b = np.array([4, 6, 3])

print(manhattan_distance(vec_a, vec_b))  # 7 (3 + 4 + 0)

텍스트 임베딩 검색    → 코사인 유사도 (기본 추천)
이미지 유사도 검색    → 유클리드 거리
추천 시스템 (MIPS)   → 내적
고차원 희소 벡터     → 코사인 유사도
클러스터링 / 분류    → 유클리드 거리

Layer 3: [A] ────────────────── [B]     (소수 노드, 장거리 연결)
           \                   /
Layer 2: [A] ── [C] ── [D] ── [B]      (중간 노드)
           \   / \   / \   / \
Layer 1: [A]-[E]-[C]-[F]-[D]-[G]-[B]   (대부분 노드, 단거리 연결)
           |   |   |   |   |   |   |
Layer 0: [모든 벡터가 존재하는 기본 층]    (전체 노드)

# Qdrant에서 HNSW 설정 예시
from qdrant_client import QdrantClient
from qdrant_client.models import VectorParams, HnswConfigDiff

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

client.create_collection(
    collection_name="documents",
    vectors_config=VectorParams(
        size=1536,
        distance="Cosine"
    ),
    hnsw_config=HnswConfigDiff(
        m=16,                    # 노드당 연결 수 (높을수록 정확, 메모리 증가)
        ef_construct=128,        # 인덱스 구축 시 탐색 범위
        full_scan_threshold=10000  # 이 수 이하면 brute-force
    )
)

전체 벡터 공간:
┌─────────────────────────────────┐
│  ● ●   ★ ●                     │
│   ●  Cluster1  ●  ●            │
│  ●  ●          ★               │
│        ● ●  Cluster2  ●        │
│         ●     ●  ● ●           │
│              ●   ●             │
│    ● ●  ●         ★            │
│     Cluster3        Cluster4   │
│    ●  ● ●         ●  ●  ●     │
└─────────────────────────────────┘
★ = 클러스터 중심(centroid)

검색: Query와 가장 가까운 클러스터(nprobe개) 내에서만 검색

# FAISS에서 IVF-PQ 인덱스 생성
import faiss

dimension = 1536
nlist = 256      # 클러스터 수
m_pq = 48        # 서브벡터 수 (차원을 m_pq개로 분할)
nbits = 8        # 각 서브벡터의 코드북 크기

quantizer = faiss.IndexFlatL2(dimension)
index = faiss.IndexIVFPQ(quantizer, dimension, nlist, m_pq, nbits)

# 학습 데이터로 클러스터 + 코드북 학습
index.train(training_vectors)
index.add(all_vectors)

# 검색 시 nprobe 설정
index.nprobe = 16  # 탐색할 클러스터 수
distances, indices = index.search(query_vector, k=10)

원본 (float32, 1536차원): 1536 x 4 bytes = 6,144 bytes/벡터
PQ 압축 (48 서브벡터):   48 x 1 byte  = 48 bytes/벡터
→ 128배 압축! 1억 벡터: 614GB → 4.8GB

from pinecone import Pinecone, ServerlessSpec

pc = Pinecone(api_key="YOUR_KEY")

# 인덱스 생성
pc.create_index(
    name="my-index",
    dimension=1536,
    metric="cosine",
    spec=ServerlessSpec(
        cloud="aws",
        region="us-east-1"
    )
)

index = pc.Index("my-index")

# 벡터 업서트
index.upsert(
    vectors=[
        ("id1", [0.1, 0.2, ...], {"title": "문서 제목", "category": "tech"}),
        ("id2", [0.3, 0.4, ...], {"title": "다른 문서", "category": "science"}),
    ],
    namespace="articles"
)

# 검색 (필터 + 벡터)
results = index.query(
    vector=[0.15, 0.25, ...],
    top_k=5,
    filter={"category": "tech"},
    namespace="articles",
    include_metadata=True
)

import weaviate
from weaviate.classes.config import Configure, Property, DataType

client = weaviate.connect_to_local()

# 컬렉션 생성 (내장 벡터화)
collection = client.collections.create(
    name="Article",
    vectorizer_config=Configure.Vectorizer.text2vec_openai(
        model="text-embedding-3-small"
    ),
    properties=[
        Property(name="title", data_type=DataType.TEXT),
        Property(name="content", data_type=DataType.TEXT),
        Property(name="category", data_type=DataType.TEXT),
    ]
)

# 데이터 추가 (자동 벡터화)
articles = client.collections.get("Article")
articles.data.insert(
    properties={
        "title": "Vector DB 가이드",
        "content": "벡터 데이터베이스는 AI 시대의 핵심...",
        "category": "tech"
    }
)

# 시맨틱 검색
response = articles.query.near_text(
    query="인공지능 인프라",
    limit=5,
    filters=weaviate.classes.query.Filter.by_property("category").equal("tech")
)

from qdrant_client import QdrantClient
from qdrant_client.models import (
    Distance, VectorParams, PointStruct,
    Filter, FieldCondition, MatchValue
)

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

# 컬렉션 생성
client.create_collection(
    collection_name="articles",
    vectors_config=VectorParams(
        size=1536,
        distance=Distance.COSINE
    )
)

# 벡터 업서트
client.upsert(
    collection_name="articles",
    points=[
        PointStruct(
            id=1,
            vector=[0.1, 0.2, ...],
            payload={"title": "Vector DB 가이드", "category": "tech", "views": 1500}
        ),
    ]
)

# 필터 + 벡터 검색
results = client.search(
    collection_name="articles",
    query_vector=[0.15, 0.25, ...],
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="tech")),
        ]
    ),
    limit=5
)

from pymilvus import connections, Collection, FieldSchema, CollectionSchema, DataType

connections.connect("default", host="localhost", port="19530")

# 스키마 정의
fields = [
    FieldSchema(name="id", dtype=DataType.INT64, is_primary=True, auto_id=True),
    FieldSchema(name="title", dtype=DataType.VARCHAR, max_length=200),
    FieldSchema(name="embedding", dtype=DataType.FLOAT_VECTOR, dim=1536),
]
schema = CollectionSchema(fields, description="Articles")
collection = Collection("articles", schema)

# 인덱스 생성
index_params = {
    "index_type": "HNSW",
    "metric_type": "COSINE",
    "params": {"M": 16, "efConstruction": 256}
}
collection.create_index("embedding", index_params)

# 검색
collection.load()
results = collection.search(
    data=[[0.1, 0.2, ...]],
    anns_field="embedding",
    param={"metric_type": "COSINE", "params": {"ef": 128}},
    limit=5,
    output_fields=["title"]
)

import chromadb

client = chromadb.PersistentClient(path="./chroma_db")

collection = client.create_collection(
    name="articles",
    metadata={"hnsw:space": "cosine"}
)

# 문서 추가 (자동 임베딩)
collection.add(
    documents=["Vector DB는 AI 인프라의 핵심입니다", "RAG는 검색 증강 생성입니다"],
    metadatas=[{"category": "tech"}, {"category": "ai"}],
    ids=["doc1", "doc2"]
)

# 검색
results = collection.query(
    query_texts=["인공지능 데이터베이스"],
    n_results=5,
    where={"category": "tech"}
)

-- PostgreSQL 14+ 필요
-- 확장 설치
CREATE EXTENSION IF NOT EXISTS vector;

-- 벡터 컬럼이 있는 테이블 생성
CREATE TABLE documents (
    id BIGSERIAL PRIMARY KEY,
    title TEXT NOT NULL,
    content TEXT,
    category TEXT,
    embedding VECTOR(1536),  -- OpenAI text-embedding-3-small 차원
    created_at TIMESTAMPTZ DEFAULT NOW()
);

-- 벡터 삽입
INSERT INTO documents (title, content, category, embedding)
VALUES (
    'Vector DB 가이드',
    'Vector Database는 AI 시대의 핵심...',
    'tech',
    '[0.1, 0.2, 0.3, ...]'::vector  -- 1536차원 벡터
);

-- 코사인 거리 검색 (가장 유사한 5개)
SELECT id, title, 1 - (embedding <=> '[0.15, 0.25, ...]'::vector) AS similarity
FROM documents
WHERE category = 'tech'
ORDER BY embedding <=> '[0.15, 0.25, ...]'::vector
LIMIT 5;

-- L2 거리 검색
SELECT id, title, embedding <-> '[0.15, 0.25, ...]'::vector AS distance
FROM documents
ORDER BY embedding <-> '[0.15, 0.25, ...]'::vector
LIMIT 5;

-- 내적 검색 (Maximum Inner Product)
SELECT id, title, (embedding <#> '[0.15, 0.25, ...]'::vector) * -1 AS inner_product
FROM documents
ORDER BY embedding <#> '[0.15, 0.25, ...]'::vector
LIMIT 5;

-- HNSW 인덱스 (추천)
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops)
WITH (m = 16, ef_construction = 128);

-- 검색 시 ef_search 설정
SET hnsw.ef_search = 100;

-- IVFFlat 인덱스
CREATE INDEX ON documents
USING ivfflat (embedding vector_cosine_ops)
WITH (lists = 100);  -- 클러스터 수 (sqrt(rows) 권장)

-- 검색 시 probes 설정
SET ivfflat.probes = 10;

-- 1. 부분 인덱스 (특정 카테고리만)
CREATE INDEX ON documents
USING hnsw (embedding vector_cosine_ops)
WHERE category = 'tech';

-- 2. 반정규화를 활용한 필터 + 벡터 검색
-- 느린 패턴: 벡터 검색 후 필터
SELECT * FROM documents
WHERE category = 'tech'
ORDER BY embedding <=> query_vec
LIMIT 10;

-- 빠른 패턴: 파티션 테이블 활용
CREATE TABLE documents_tech PARTITION OF documents
FOR VALUES IN ('tech');

-- 3. EXPLAIN으로 인덱스 사용 확인
EXPLAIN (ANALYZE, BUFFERS)
SELECT id, title
FROM documents
ORDER BY embedding <=> '[0.15, 0.25, ...]'::vector
LIMIT 5;

-- Index Scan using documents_embedding_idx 확인

import psycopg2
from pgvector.psycopg2 import register_vector

conn = psycopg2.connect("postgresql://user:pass@localhost/mydb")
register_vector(conn)

cur = conn.cursor()

# 벡터 검색
query_embedding = [0.1, 0.2, ...]  # 1536차원
cur.execute("""
    SELECT id, title, 1 - (embedding <=> %s::vector) AS similarity
    FROM documents
    WHERE category = %s
    ORDER BY embedding <=> %s::vector
    LIMIT %s
""", (query_embedding, "tech", query_embedding, 5))

results = cur.fetchall()
for row in results:
    print(f"ID: {row[0]}, Title: {row[1]}, Similarity: {row[2]:.4f}")

쿼리: "PostgreSQL 16 릴리즈 노트"

벡터 검색만: "MySQL 8.0 새 기능"도 높은 유사도 (비슷한 의미)
키워드 검색만: "PostgreSQL 16"이 정확히 포함된 문서만
하이브리드 검색: 의미적으로 유사 + "PostgreSQL 16" 포함 = 최적 결과

# Weaviate의 하이브리드 검색
response = articles.query.hybrid(
    query="PostgreSQL vector search performance",
    alpha=0.5,  # 0 = 키워드만, 1 = 벡터만, 0.5 = 균형
    limit=10,
    fusion_type="relative_score"  # rankedFusion 또는 relativeScoreFusion
)

def reciprocal_rank_fusion(keyword_results, vector_results, k=60):
    """
    RRF 점수 = sum(1 / (k + rank_i))
    k = 60이 일반적
    """
    scores = {}
    
    for rank, doc_id in enumerate(keyword_results):
        scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank + 1)
    
    for rank, doc_id in enumerate(vector_results):
        scores[doc_id] = scores.get(doc_id, 0) + 1 / (k + rank + 1)
    
    # 점수 기준 정렬
    return sorted(scores.items(), key=lambda x: x[1], reverse=True)

# 예시
keyword_hits = ["doc_A", "doc_B", "doc_C", "doc_D"]
vector_hits = ["doc_C", "doc_A", "doc_E", "doc_B"]

fused = reciprocal_rank_fusion(keyword_hits, vector_hits)
# doc_A와 doc_C가 양쪽 모두 상위 → 최종 상위

-- 하이브리드 검색 (PostgreSQL)
WITH vector_search AS (
    SELECT id, title, content,
           1 - (embedding <=> query_vec) AS vector_score,
           ROW_NUMBER() OVER (ORDER BY embedding <=> query_vec) AS vector_rank
    FROM documents
    ORDER BY embedding <=> query_vec
    LIMIT 20
),
keyword_search AS (
    SELECT id, title, content,
           ts_rank(to_tsvector('english', content), plainto_tsquery('english', 'vector database')) AS bm25_score,
           ROW_NUMBER() OVER (ORDER BY ts_rank(to_tsvector('english', content), plainto_tsquery('english', 'vector database')) DESC) AS keyword_rank
    FROM documents
    WHERE to_tsvector('english', content) @@ plainto_tsquery('english', 'vector database')
    LIMIT 20
)
SELECT
    COALESCE(v.id, k.id) AS id,
    COALESCE(v.title, k.title) AS title,
    -- RRF 점수
    COALESCE(1.0 / (60 + v.vector_rank), 0) +
    COALESCE(1.0 / (60 + k.keyword_rank), 0) AS rrf_score
FROM vector_search v
FULL OUTER JOIN keyword_search k ON v.id = k.id
ORDER BY rrf_score DESC
LIMIT 10;

Pre-filtering:  필터 적용 → 필터된 벡터만 검색 (정확하지만 느릴 수 있음)
Post-filtering: 벡터 검색 → 결과에 필터 적용 (빠르지만 결과가 적을 수 있음)
In-filtering:   검색 중 필터 동시 적용 (최적이지만 구현 복잡)

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

# 복합 필터
results = client.search(
    collection_name="products",
    query_vector=query_embedding,
    query_filter=Filter(
        must=[
            FieldCondition(key="category", match=MatchValue(value="electronics")),
            FieldCondition(key="price", range=Range(gte=100, lte=500)),
        ],
        must_not=[
            FieldCondition(key="out_of_stock", match=MatchValue(value=True)),
        ],
        should=[
            FieldCondition(key="brand", match=MatchValue(value="Apple")),
            FieldCondition(key="brand", match=MatchValue(value="Samsung")),
        ]
    ),
    limit=10
)

권장 사항:
- 자주 필터링하는 필드에 페이로드 인덱스 생성
- 카디널리티가 낮은 필드 (category, status)에 유리
- 날짜 범위 필터는 인덱스 필수
- 중첩 객체보다 플랫 구조 선호

비권장:
- 고유 값이 매우 많은 필드에 인덱스 (사용자 ID 등)
- 벡터 검색 없이 메타데이터만으로 검색 (일반 DB가 유리)

전략 1: 네임스페이스/파티션 분리 (Pinecone, Milvus)
┌──────────── Index ────────────┐
│  Namespace: tenant_A  ●●●●●  │
│  Namespace: tenant_B  ○○○○○  │
│  Namespace: tenant_C  △△△△△  │
└───────────────────────────────┘
- 장점: 간단, 데이터 격리
- 단점: 교차 테넌트 검색 어려움

전략 2: 메타데이터 필터 (Qdrant, Weaviate)
┌──────── Collection ───────────┐
│  ●(A) ○(B) △(C) ●(A) ○(B)   │
│  △(C) ●(A) ●(A) ○(B) △(C)   │
│  tenant_id 필터로 분리        │
└───────────────────────────────┘
- 장점: 유연, 교차 검색 가능
- 단점: 테넌트 많으면 성능 저하

전략 3: 컬렉션 분리 (소수 대형 테넌트)
┌─ Collection: tenant_A ─┐
│  ●●●●●●●●●●●●●●●●●●  │
└────────────────────────┘
┌─ Collection: tenant_B ─┐
│  ○○○○○○○○○○○○○○○○○○  │
└────────────────────────┘
- 장점: 완벽한 격리, 독립적 스케일링
- 단점: 관리 오버헤드

# Qdrant 예시: 컬렉션 관리
# 컬렉션 목록
collections = client.get_collections()

# 컬렉션 정보
info = client.get_collection("articles")
print(f"벡터 수: {info.points_count}")
print(f"인덱스 상태: {info.status}")

# 컬렉션 삭제
client.delete_collection("old_articles")

# 별칭 (블루-그린 배포)
client.update_collection_aliases(
    change_aliases_operations=[
        {"create_alias": {"collection_name": "articles_v2", "alias_name": "articles_prod"}}
    ]
)

수평 샤딩: 데이터를 여러 노드에 분산
┌─ Node 1 ─┐ ┌─ Node 2 ─┐ ┌─ Node 3 ─┐
│ Shard 1   │ │ Shard 2   │ │ Shard 3   │
│ 33% 데이터│ │ 33% 데이터│ │ 33% 데이터│
└───────────┘ └───────────┘ └───────────┘
        ↕ 검색 시 모든 노드 쿼리 후 병합

Qdrant 샤딩 설정:
- auto 샤딩: shard_number에 따라 자동 분배
- custom 샤딩: shard_key로 테넌트별 분리

# Qdrant 복제 설정
client.create_collection(
    collection_name="articles",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE),
    replication_factor=3,     # 3개 노드에 복제
    write_consistency_factor=2  # 2개 노드 확인 후 쓰기 성공
)

# Qdrant 스냅샷 생성
curl -X POST "http://localhost:6333/collections/articles/snapshots"

# 스냅샷 복원
curl -X PUT "http://localhost:6333/collections/articles/snapshots/recover" \
  -H "Content-Type: application/json" \
  -d '{"location": "http://backup-server/snapshot.tar"}'

# pgvector: pg_dump 활용
pg_dump -t documents mydb > documents_backup.sql

# 핵심 메트릭
monitoring_metrics = {
    "검색 지연 시간 (p50, p95, p99)": "목표: p99 100ms 이하",
    "QPS (초당 쿼리 수)": "부하에 따라 모니터링",
    "Recall@K": "정확도. 0.95 이상 목표",
    "인덱스 크기 / 메모리 사용량": "OOM 방지",
    "삽입 지연 시간": "실시간 업데이트 시 중요",
    "디스크 사용량": "용량 계획",
    "복제 지연": "데이터 일관성",
}

테스트 환경: AWS r6g.2xlarge (8vCPU, 64GB RAM)

Qdrant:
  - 인덱스 구축: 45분
  - 메모리: 48GB
  - p50 지연: 3ms, p99 지연: 12ms
  - QPS: 2,100 (Recall@10 = 0.96)

pgvector (HNSW):
  - 인덱스 구축: 2시간 30분
  - 메모리: 52GB
  - p50 지연: 8ms, p99 지연: 35ms
  - QPS: 800 (Recall@10 = 0.95)

Milvus (DiskANN):
  - 인덱스 구축: 35분
  - 메모리: 12GB (디스크 활용)
  - p50 지연: 5ms, p99 지연: 18ms
  - QPS: 1,800 (Recall@10 = 0.95)

소규모 (100K 이하) + 기존 PostgreSQL → pgvector
소규모 프로토타이핑 → ChromaDB
중규모 (100K~10M) + 셀프호스팅 → Qdrant or Weaviate
대규모 (10M+) + 셀프호스팅 → Milvus
관리형 서비스 원하면 → Pinecone or Zilliz Cloud
하이브리드 검색 중요 → Weaviate
필터링 중요 → Qdrant

1M 벡터 (1536차원, HNSW) 예상 인프라:
  - RAM 필요: 약 12GB
  - 디스크: 약 20GB
  - AWS r6g.xlarge (4vCPU, 32GB): 월 약 150달러
  - 운영 인력 비용 별도

10M 벡터:
  - RAM 필요: 약 100GB
  - AWS r6g.4xlarge (16vCPU, 128GB): 월 약 600달러

비용 절감 팁:
  - 양자화로 메모리 60~75% 절감
  - DiskANN으로 SSD 활용 (메모리 80% 절감)
  - 차원 축소 (1536 → 512) 시 메모리 3배 절감

from openai import OpenAI
from qdrant_client import QdrantClient
from qdrant_client.models import PointStruct, VectorParams, Distance

openai_client = OpenAI()
qdrant_client = QdrantClient("localhost", port=6333)

# 1. 문서 임베딩 및 저장
def embed_and_store(documents):
    for doc in documents:
        response = openai_client.embeddings.create(
            model="text-embedding-3-small",
            input=doc["content"]
        )
        embedding = response.data[0].embedding
        
        qdrant_client.upsert(
            collection_name="knowledge_base",
            points=[PointStruct(
                id=doc["id"],
                vector=embedding,
                payload={"title": doc["title"], "content": doc["content"]}
            )]
        )

# 2. 검색 + LLM 생성
def rag_query(question):
    # 질문 임베딩
    q_response = openai_client.embeddings.create(
        model="text-embedding-3-small",
        input=question
    )
    q_embedding = q_response.data[0].embedding
    
    # 벡터 검색
    results = qdrant_client.search(
        collection_name="knowledge_base",
        query_vector=q_embedding,
        limit=5
    )
    
    # 컨텍스트 구성
    context = "\n\n".join([
        f"[{r.payload['title']}]\n{r.payload['content']}"
        for r in results
    ])
    
    # LLM 생성
    response = openai_client.chat.completions.create(
        model="gpt-4o",
        messages=[
            {"role": "system", "content": f"다음 컨텍스트를 기반으로 답변하세요:\n\n{context}"},
            {"role": "user", "content": question}
        ]
    )
    
    return response.choices[0].message.content