Chroma vs Pinecone vs Weaviate — 벡터 데이터베이스 완전 비교 2026

1
2
3
4
5
6
7

# 전통 DB: 정확 매칭
SELECT * FROM documents WHERE content LIKE '%머신러닝%'

# 벡터 DB: 의미 기반 검색
query_vector = embed("딥러닝과 신경망의 차이는?")
results = vectordb.search(query_vector, k=5)
# → "머신러닝" 언급 없어도 의미적으로 유사한 문서 반환

1

pip install chromadb

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43

import chromadb
from chromadb.utils import embedding_functions

# 클라이언트 생성 (로컬 파일 저장)
client = chromadb.PersistentClient(path="./chroma_data")

# OpenAI 임베딩 함수 설정
openai_ef = embedding_functions.OpenAIEmbeddingFunction(
    api_key="your-api-key",
    model_name="text-embedding-3-small"
)

# 컬렉션 생성
collection = client.get_or_create_collection(
    name="company_docs",
    embedding_function=openai_ef,
    metadata={"hnsw:space": "cosine"}  # 코사인 유사도 사용
)

# 문서 추가
collection.add(
    documents=[
        "연차 휴가는 15일입니다.",
        "재택근무는 주 3일까지 가능합니다.",
        "병가는 의사 진단서 제출 시 무제한입니다."
    ],
    metadatas=[
        {"source": "hr_policy.pdf", "page": 1},
        {"source": "work_policy.pdf", "page": 3},
        {"source": "hr_policy.pdf", "page": 5}
    ],
    ids=["doc1", "doc2", "doc3"]
)

# 검색
results = collection.query(
    query_texts=["휴가는 몇 일인가요?"],
    n_results=3,
    where={"source": "hr_policy.pdf"}  # 메타데이터 필터
)

for doc, distance in zip(results["documents"][0], results["distances"][0]):
    print(f"[유사도: {1-distance:.3f}] {doc}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

from langchain_community.vectorstores import Chroma
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# 문서에서 직접 생성
vectorstore = Chroma.from_documents(
    documents=chunks,
    embedding=embeddings,
    persist_directory="./chroma_db",
    collection_name="my_collection"
)

# 기존 DB 로드
vectorstore = Chroma(
    persist_directory="./chroma_db",
    embedding_function=embeddings,
    collection_name="my_collection"
)

retriever = vectorstore.as_retriever(search_kwargs={"k": 5})

1

pip install pinecone-client

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57

from pinecone import Pinecone, ServerlessSpec
import time

# 클라이언트 초기화
pc = Pinecone(api_key="your-pinecone-api-key")

# 인덱스 생성 (처음 한 번만)
index_name = "company-rag"

if index_name not in pc.list_indexes().names():
    pc.create_index(
        name=index_name,
        dimension=1536,  # text-embedding-3-small 차원수
        metric="cosine",
        spec=ServerlessSpec(
            cloud="aws",
            region="us-east-1"
        )
    )
    # 인덱스 준비 대기
    while not pc.describe_index(index_name).status["ready"]:
        time.sleep(1)

index = pc.Index(index_name)

# 벡터 삽입 (배치 처리 권장)
vectors_to_upsert = [
    {
        "id": "doc1",
        "values": [0.1, 0.2, ...],  # 1536개 float
        "metadata": {
            "text": "연차 휴가는 15일입니다.",
            "source": "hr_policy.pdf",
            "page": 1
        }
    },
    # ...
]

# 배치 삽입 (한 번에 최대 100개)
batch_size = 100
for i in range(0, len(vectors_to_upsert), batch_size):
    batch = vectors_to_upsert[i:i+batch_size]
    index.upsert(vectors=batch)

# 검색
query_vector = embed("휴가 정책")  # 실제 임베딩 함수 호출

results = index.query(
    vector=query_vector,
    top_k=5,
    filter={"source": {"$eq": "hr_policy.pdf"}},  # 메타데이터 필터
    include_metadata=True
)

for match in results["matches"]:
    print(f"[점수: {match['score']:.3f}] {match['metadata']['text']}")

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18

from langchain_pinecone import PineconeVectorStore
from langchain_openai import OpenAIEmbeddings

embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

# 문서에서 직접 생성
vectorstore = PineconeVectorStore.from_documents(
    documents=chunks,
    embedding=embeddings,
    index_name="company-rag"
)

# 기존 인덱스 연결
vectorstore = PineconeVectorStore(
    index=pc.Index("company-rag"),
    embedding=embeddings,
    text_key="text"
)

1
2
3
4
5
6
7
8
9

# Docker로 로컬 실행
docker run -d \
  -p 8080:8080 \
  -p 50051:50051 \
  -e QUERY_DEFAULTS_LIMIT=20 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
  -v weaviate_data:/var/lib/weaviate \
  cr.weaviate.io/semitechnologies/weaviate:latest

1

pip install weaviate-client

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60

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

# 클라이언트 연결
client = weaviate.connect_to_local()

# 스키마(컬렉션) 정의
client.collections.create(
    name="CompanyDoc",
    vectorizer_config=Configure.Vectorizer.text2vec_openai(
        model="text-embedding-3-small"
    ),
    properties=[
        Property(name="content", data_type=DataType.TEXT),
        Property(name="source", data_type=DataType.TEXT),
        Property(name="page", data_type=DataType.INT),
        Property(name="department", data_type=DataType.TEXT),
    ]
)

collection = client.collections.get("CompanyDoc")

# 데이터 삽입 (배치)
with collection.batch.dynamic() as batch:
    for chunk in chunks:
        batch.add_object({
            "content": chunk.page_content,
            "source": chunk.metadata.get("source", ""),
            "page": chunk.metadata.get("page", 0),
            "department": chunk.metadata.get("department", "general")
        })

# 벡터 유사도 검색
results = collection.query.near_text(
    query="휴가 정책",
    limit=5,
    return_metadata=MetadataQuery(distance=True)
)

for obj in results.objects:
    print(f"[거리: {obj.metadata.distance:.3f}] {obj.properties['content'][:100]}")

# 하이브리드 검색 (벡터 + BM25)
results = collection.query.hybrid(
    query="연차 휴가 일수",
    alpha=0.7,   # 0=순수 BM25, 1=순수 벡터
    limit=5
)

# 메타데이터 필터
from weaviate.classes.query import Filter

results = collection.query.near_text(
    query="휴가",
    limit=5,
    filters=Filter.by_property("department").equal("HR")
)

client.close()

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20

from langchain_weaviate.vectorstores import WeaviateVectorStore
from langchain_openai import OpenAIEmbeddings
import weaviate

client = weaviate.connect_to_local()
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vectorstore = WeaviateVectorStore.from_documents(
    documents=chunks,
    embedding=embeddings,
    client=client,
    index_name="CompanyDoc",
    text_key="content"
)

# 하이브리드 검색 retriever
retriever = vectorstore.as_retriever(
    search_type="mmr",
    search_kwargs={"k": 5}
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

import faiss
import numpy as np

dimension = 1536
index = faiss.IndexFlatL2(dimension)  # L2 거리 기반

# GPU 버전
res = faiss.StandardGpuResources()
gpu_index = faiss.index_cpu_to_gpu(res, 0, index)

vectors = np.random.random((10000, dimension)).astype('float32')
index.add(vectors)

query = np.random.random((1, dimension)).astype('float32')
distances, indices = index.search(query, k=5)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

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

client = QdrantClient(url="http://localhost:6333")

client.create_collection(
    collection_name="company_docs",
    vectors_config=VectorParams(size=1536, distance=Distance.COSINE)
)

client.upsert(
    collection_name="company_docs",
    points=[
        PointStruct(id=1, vector=[...], payload={"text": "내용", "source": "doc.pdf"})
    ]
)

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15

# Chroma에서 모든 벡터 추출
collection = chroma_client.get_collection("my_docs")
all_data = collection.get(include=["embeddings", "documents", "metadatas"])

# Pinecone으로 이전
for i, (emb, doc, meta) in enumerate(zip(
    all_data["embeddings"],
    all_data["documents"],
    all_data["metadatas"]
)):
    pinecone_index.upsert(vectors=[{
        "id": all_data["ids"][i],
        "values": emb,
        "metadata": {**meta, "text": doc}
    }])