Chroma DB 2026: 개발자 친화적 RAG 벡터 데이터베이스, 50배 더 빠른 임베딩 — Python 가이드

pip install chromadb

# 특정 임베딩 백엔드 포함
pip install chromadb[sentence-transformers]

# 설치 확인
python -c "import chromadb; print(chromadb.__version__)"
# Expected: 0.6.x or higher

import chromadb

# 순수 메모리 — 프로세스 종료 시 데이터 사라짐
client = chromadb.Client()

import chromadb

# 데이터를 ./chroma_db 디렉토리에 저장
client = chromadb.PersistentClient(path="./chroma_db")

# Docker에서 Chroma 서버 실행
docker run -d \
  --name chroma \
  -v ./chroma_data:/chroma/chroma \
  -p 8000:8000 \
  chromadb/chroma:latest

# Python에서 연결
import chromadb
client = chromadb.HttpClient(host="localhost", port=8000)

import chromadb

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

# 컬렉션 생성 또는 가져오기
# "documents"는 원시 텍스트 청크
# "metadatas"는 필터링용 키-값 쌍
# "ids"는 고유 식별자

collection = client.get_or_create_collection(name="knowledge_base")

documents = [
    "Chroma is a vector database designed for AI applications.",
    "RAG stands for Retrieval-Augmented Generation.",
    "HNSW indexing enables fast approximate nearest neighbor search.",
    "Embeddings convert text into high-dimensional vectors.",
]

collection.add(
    documents=documents,
    metadatas=[
        {"source": "docs", "topic": "database"},
        {"source": "docs", "topic": "ai"},
        {"source": "blog", "topic": "indexing"},
        {"source": "blog", "topic": "embeddings"},
    ],
    ids=["doc_1", "doc_2", "doc_3", "doc_4"]
)

print(f"Collection count: {collection.count()}")
# Output: Collection count: 4

# 단순 유사도 검색
results = collection.query(
    query_texts=["What is a vector database?"],
    n_results=2
)

print(results["documents"])
# Output: [["Chroma is a vector database designed for AI applications."]]

# 메타데이터 필터링 포함
results = collection.query(
    query_texts=["How does search work fast?"],
    where={"source": "blog"},  # 메타데이터로 필터링
    n_results=2
)

print(results["documents"])
# Output: [["HNSW indexing enables fast approximate nearest neighbor search."]]

# 문서 업데이트
collection.update(
    ids=["doc_1"],
    documents=["Chroma is the developer-friendly vector database for RAG."],
    metadatas=[{"source": "docs", "topic": "database", "updated": True}]
)

# ID로 삭제
collection.delete(ids=["doc_4"])

print(f"Collection count after delete: {collection.count()}")
# Output: Collection count after delete: 3

pip install langchain-chroma langchain-openai

from langchain_chroma import Chroma
from langchain_openai import OpenAIEmbeddings
from langchain_core.documents import Document

# 임베딩 함수 초기화
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

vector_store = Chroma(
    collection_name="langchain_docs",
    embedding_function=embeddings,
    persist_directory="./chroma_langchain"
)

# 문서 추가
docs = [
    Document(page_content="Chroma integrates seamlessly with LangChain.", metadata={"source": "tutorial"}),
    Document(page_content="RAG pipelines combine retrieval with LLM generation.", metadata={"source": "guide"}),
]

vector_store.add_documents(docs)

# 검색
results = vector_store.similarity_search("How do I use LangChain with Chroma?", k=2)
for doc in results:
    print(doc.page_content)

pip install llama-index-vector-stores-chroma

from llama_index.vector_stores.chroma import ChromaVectorStore
from llama_index.core import StorageContext, VectorStoreIndex
from llama_index.embeddings.openai import OpenAIEmbedding
import chromadb

# 설정
chroma_client = chromadb.PersistentClient(path="./chroma_llamaindex")
chroma_collection = chroma_client.get_or_create_collection("llamaindex")

vector_store = ChromaVectorStore(chroma_collection=chroma_collection)
storage_context = StorageContext.from_defaults(vector_store=vector_store)

# 문서로 인덱스 구축
from llama_index.core import Document

documents = [Document(text="Chroma works great with LlamaIndex for RAG.")]
index = VectorStoreIndex.from_documents(
    documents,
    storage_context=storage_context,
    embed_model=OpenAIEmbedding()
)

# 쿼리
query_engine = index.as_query_engine()
response = query_engine.query("What vector database should I use with LlamaIndex?")
print(response)

from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction

# OpenAI 임베딩 모델을 Chroma와 직접 사용
openai_ef = OpenAIEmbeddingFunction(
    api_key="your-openai-api-key",
    model_name="text-embedding-3-small"  # 1536 차원, 뛰어난 가성비
)

collection = client.get_or_create_collection(
    name="openai_embedded",
    embedding_function=openai_ef
)

collection.add(
    documents=["OpenAI embeddings produce high-quality vectors for semantic search."],
    ids=["doc_openai_1"]
)

results = collection.query(
    query_texts=["Tell me about OpenAI vectors"],
    n_results=1
)

from chromadb.utils.embedding_functions import SentenceTransformerEmbeddingFunction

# 완전 로컬 실행 — API 호출 없음, 속도 제한 없음
local_ef = SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"  # 384 차원, 빠름, 우수한 품질
)

collection = client.get_or_create_collection(
    name="local_embeddings",
    embedding_function=local_ef
)

collection.add(
    documents=["Local embeddings are free and privacy-preserving."],
    ids=["local_1"]
)

from fastapi import FastAPI, HTTPException
from pydantic import BaseModel
import chromadb

app = FastAPI()
client = chromadb.PersistentClient(path="./chroma_api")
collection = client.get_or_create_collection("api_docs")

class QueryRequest(BaseModel):
    query: str
    n_results: int = 5

@app.post("/search")
def search_docs(request: QueryRequest):
    try:
        results = collection.query(
            query_texts=[request.query],
            n_results=request.n_results
        )
        return {
            "documents": results["documents"][0],
            "distances": results["distances"][0],
            "metadatas": results["metadatas"][0]
        }
    except Exception as e:
        raise HTTPException(status_code=500, detail=str(e))

@app.get("/health")
def health():
    return {"status": "ok", "count": collection.count()}

# Run: uvicorn main:app --reload

# 임의 모델의 사전 계산 임베딩 (예: OpenAI text-embedding-3-large)
import numpy as np

# 커스텀 임베딩 — 3072 차원
custom_embeddings = [
    np.random.randn(3072).tolist(),  # 실제 임베딩으로 교체
    np.random.randn(3072).tolist(),
]

collection = client.get_or_create_collection("custom_dims")
collection.add(
    embeddings=custom_embeddings,
    documents=["Doc with custom embedding", "Another doc"],
    ids=["custom_1", "custom_2"]
)

# 복잡한 메타데이터 쿼리
collection.add(
    documents=["Advanced filtering example"],
    metadatas=[{
        "category": "tutorial",
        "difficulty": "advanced",
        "year": 2026,
        "published": True,
        "tags": ["chroma", "filtering"]
    }],
    ids=["filter_demo"]
)

# 숫자 비교
results = collection.query(
    query_texts=["filtering"],
    where={"year": {"$gte": 2025}},
    n_results=5
)

# 논리 연산자
results = collection.query(
    query_texts=["advanced tutorial"],
    where={
        "$and": [
            {"category": "tutorial"},
            {"difficulty": "advanced"}
        ]
    },
    n_results=5
)

# 사용자/테넌트별 컬렉션 — 설계상 격리
def get_user_collection(user_id: str):
    return client.get_or_create_collection(f"user_{user_id}_docs")

# 각 사용자 데이터 완전 격리
user_a = get_user_collection("alice")
user_b = get_user_collection("bob")

user_a.add(documents=["Alice's private document"], ids=["alice_1"])
user_b.add(documents=["Bob's private document"], ids=["bob_1"])

# docker-compose.yml
version: "3.8"

services:
  chroma:
    image: chromadb/chroma:0.6.0
    ports:
      - "8000:8000"
    volumes:
      - chroma_data:/chroma/chroma
    environment:
      - IS_PERSISTENT=TRUE
      - PERSIST_DIRECTORY=/chroma/chroma
      - ANONYMIZED_TELEMETRY=FALSE
    restart: unless-stopped
    deploy:
      resources:
        limits:
          memory: 8G
        reservations:
          memory: 2G

volumes:
  chroma_data:

docker-compose up -d
# Chroma API: http://localhost:8000 에서 사용 가능

# Chroma는 모든 데이터를 지속 디렉토리에 저장한다
# 표준 도구로 백업 가능

tar -czf chroma_backup_$(date +%Y%m%d).tar.gz ./chroma_data/

# 복구는 동일 경로에 압축 해제만 하면 된다
tar -xzf chroma_backup_20260519.tar.gz