✍️ 필사 모드: 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
    )
)

ベクトル空間:
┌─────────────────────────────────┐
│  * *   X *                      │
│   *  Cluster1  *  *             │
│  *  *          X                │
│        * *  Cluster2  *         │
│         *     *  * *            │
│              *   *              │
│    * *  *         X             │
│     Cluster3        Cluster4    │
│    *  * *         *  *  *       │
└─────────────────────────────────┘
X = クラスタ中心（centroid）

検索: クエリに最も近いクラスタ（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
)

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;

-- 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;

クエリ: "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"
)

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が両方で上位 → 最終上位

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
)

水平シャーディング: データを複数ノードに分散
┌─ Node 1 ─┐ ┌─ Node 2 ─┐ ┌─ Node 3 ─┐
│ Shard 1   │ │ Shard 2   │ │ Shard 3   │
│ 33%データ │ │ 33%データ │ │ 33%データ │
└───────────┘ └───────────┘ └───────────┘
        ↕ 検索時にすべてのノードにクエリ後マージ

# 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)

小規模（10万以下）+ 既存PostgreSQL → pgvector
小規模プロトタイピング → ChromaDB
中規模（10万〜1000万）+ セルフホスティング → QdrantまたはWeaviate
大規模（1000万+）+ セルフホスティング → Milvus
マネージドサービス希望 → PineconeまたはZilliz Cloud
ハイブリッド検索重要 → Weaviate
フィルタリング重要 → Qdrant

100万ベクトル（1536次元、HNSW）推定インフラ:
  - RAM必要: 約12GB
  - ディスク: 約20GB
  - AWS r6g.xlarge (4vCPU, 32GB): 月約150ドル
  - 運用人件費別途

1000万ベクトル:
  - RAM必要: 約100GB
  - AWS r6g.4xlarge (16vCPU, 128GB): 月約600ドル

コスト削減のヒント:
  - 量子化でメモリ60〜75%削減
  - DiskANNでSSD活用（メモリ80%削減）
  - 次元削減（1536 → 512）でメモリ3倍節約