Chroma DB 2026: Cơ sở dữ liệu Vector thân thiện với lập trình viên cho RAG, Nhanh hơn 50 lần — Hướng dẫn Python

{{< resource-info >}}

Giới thiệu: Tại sao pipeline RAG của bạn cần kho lưu trữ vector tốt hơn #

Bạn xây dựng một ứng dụng RAG. Nó hoạt động tốt với 500 tài liệu. Sau đó bạn đạt 50.000 tài liệu và tốc độ tìm kiếm bắt đầu tụt dốc. Độ trễ tăng từ 200ms lên 4 giây. Ngườii dùng của bạn đã nhận thấy. Bạn thử PostgreSQL với pgvector, nhưng cấu hình giống như điều chỉnh một con tàu vũ trụ. Bạn thử Pinecone, nhưng giá cả tăng nhanh hơn cả lưu lượng truy cập của bạn.

Đây chính xác là vấn đề mà Chroma giải quyết. Chroma là một cơ sở dữ liệu vector ưu tiên lập trình viên được thiết kế cho 90% ứng dụng AI không cần điều phối cụm phân tán — chúng cần tìm kiếm embedding nhanh, cài đặt đơn giản, và một API Python thực sự dễ hiểu.

Tính đến tháng 5 năm 2026, Chroma đã vượt qua 18.000 sao GitHub, phát hành v0.6.x với lưu trữ persistent, lọc metadata, và một engine truy vấn có benchmark nhanh hơn 50 lần so với tìm kiếm brute-force đơn thuần trên tập dữ liệu vượt quá 1 triệu vector. Dự án được duy trì bởi nhóm Chroma theo giấy phép Apache-2.0 và là kho vector mặc định trong hướng dẫn bắt đầu nhanh của LangChain và LlamaIndex.

Hướng dẫn này đưa bạn từ pip install đến RAG sẵn sàng production trong vòng dưới 30 phút. Không cần kinh nghiệm cơ sở dữ liệu vector trước đó.

Chroma là gì? (Định nghĩa một câu) #

Chroma là một cơ sở dữ liệu vector embedding-native mã nguồn mở với API ưu tiên Python, lưu trữ tài liệu và vector embedding của chúng, sau đó truy xuất kết quả tương tự về mặt ngữ nghĩa nhất bằng tìm kiếm láng giềng gần nhất xấp xỉ (ANN).

Không giống như các cơ sở dữ liệu truyền thống được gắn thêm tiện ích mở rộng vector, Chroma được xây dựng từ đầu cho quy trình embedding: thêm tài liệu → tạo embedding → truy vấn theo ý nghĩa. Nó hỗ trợ cả chế độ in-memory (phát triển) và persistent trên đĩa (production), chạy local, trong Docker, hoặc trên VPS với zero phụ thuộc bên ngoài.

Chroma hoạt động như thế nào: Kiến trúc & Khái niệm cốt lõi #

Kiến trúc của Chroma được cố ý thiết kế đơn giản. Hiểu ba khái niệm cốt lõi sẽ giúp bạn nắm được 80%:

Collections (Bộ sưu tập) #

Một collection là một container cho các tài liệu liên quan và embedding của chúng. Hãy nghĩ về nó như một bảng trong SQL, nhưng không có schema và native vector. Bạn tạo một collection cho mỗi loại tài liệu (ví dụ: legal_docs, product_manuals, support_tickets).

Embeddings #

Mỗi tài liệu bạn thêm vào được chuyển đổi thành một vector (một mảng số thực, thường 384–1536 chiều) bởi một mô hình embedding. Chroma có thể tự động tạo embedding bằng các mô hình mặc định (như all-MiniLM-L6-v2) hoặc chấp nhận vector được tính trước từ OpenAI, Cohere, hoặc bất kỳ mô hình tùy chỉnh nào.

Truy vấn bằng Vector Similarity #

Khi bạn truy vấn, Chroma chuyển đổi văn bản của bạn vào cùng một không gian vector, sau đó sử dụng chỉ mục HNSW (Hierarchical Navigable Small World) để tìm các láng giềng gần nhất trong thờii gian dưới mili giây. Chỉ mục HNSW là yếu tố mang lại tốc độ nhanh hơn 50 lần so với brute-force cosine similarity.

Các chế độ lưu trữ #

Cài đặt & Thiết lập: Từ Zero đến Truy vấn trong 5 phút #

Bước 1: Cài đặt Chroma #

pip install chromadb

# Với backend embedding cụ thể
pip install chromadb[sentence-transformers]

# Xác minh cài đặt
python -c "import chromadb; print(chromadb.__version__)"
# Expected: 0.6.x or higher

Bước 2: Chạy Chroma (Ba tùy chọn) #

Tùy chọn A: In-memory (nhanh nhất cho testing)

import chromadb

# Pure in-memory — dữ liệu biến mất khi process kết thúc
client = chromadb.Client()

Tùy chọn B: Persistent local storage

import chromadb

# Dữ liệu được lưu vào thư mục ./chroma_db
client = chromadb.PersistentClient(path="./chroma_db")

Tùy chọn C: Docker (khuyến nghị cho production)

# Chạy Chroma server trong Docker
docker run -d \
  --name chroma \
  -v ./chroma_data:/chroma/chroma \
  -p 8000:8000 \
  chromadb/chroma:latest

# Kết nối từ Python
import chromadb
client = chromadb.HttpClient(host="localhost", port=8000)

Để triển khai VPS production, DigitalOcean cung cấp $200 tín dụng để khởi động Droplet chuyên dụng với Docker được cài đặt sẵn — hoàn hảo cho việc host Chroma cùng với RAG API của bạn.

Bước 3: Tạo Collection và Thêm Tài liệu #

import chromadb

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

# Tạo hoặc lấy collection
# "documents" là các text chunk thô
# "metadatas" là các cặp key-value để lọc
# "ids" là các định danh duy nhất

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

Bước 4: Truy vấn Collection #

# Tìm kiếm similarity đơn giản
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."]]

# Với metadata filtering
results = collection.query(
    query_texts=["How does search work fast?"],
    where={"source": "blog"},  # Lọc theo metadata
    n_results=2
)

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

Bước 5: Cập nhật và Xóa #

# Cập nhật tài liệu
collection.update(
    ids=["doc_1"],
    documents=["Chroma is the developer-friendly vector database for RAG."],
    metadatas=[{"source": "docs", "topic": "database", "updated": True}]
)

# Xóa theo ID
collection.delete(ids=["doc_4"])

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

Tích hợp với LangChain, LlamaIndex và các Framework khác #

Tích hợp LangChain #

Chroma là kho vector mặc định trong quickstart của LangChain. Tích hợp chỉ cần 3 dòng:

pip install langchain-chroma langchain-openai

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

# Khởi tạo với embedding function
embeddings = OpenAIEmbeddings(model="text-embedding-3-small")

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

# Thêm tài liệu
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)

# Tìm kiếm
results = vector_store.similarity_search("How do I use LangChain with Chroma?", k=2)
for doc in results:
    print(doc.page_content)

Tích hợp LlamaIndex #

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

# Thiết lập
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)

# Xây dựng index từ tài liệu
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()
)

# Truy vấn
query_engine = index.as_query_engine()
response = query_engine.query("What vector database should I use with LlamaIndex?")
print(response)

Tích hợp OpenAI Embeddings #

from chromadb.utils.embedding_functions import OpenAIEmbeddingFunction

# Sử dụng mô hình embedding OpenAI trực tiếp với Chroma
openai_ef = OpenAIEmbeddingFunction(
    api_key="your-openai-api-key",
    model_name="text-embedding-3-small"  # 1536 chiều, tỷ lệ giá/chất lượng tuyệt vờii
)

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
)

Sentence Transformers (Local, không cần API Key) #

from chromadb.utils.embedding_functions import SentenceTransformerEmbeddingFunction

# Chạy hoàn toàn local — không có API call, không giới hạn tốc độ
local_ef = SentenceTransformerEmbeddingFunction(
    model_name="all-MiniLM-L6-v2"  # 384 chiều, nhanh, chất lượng tốt
)

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"]
)

Mẫu tích hợp FastAPI #

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

Benchmark & Các trường hợp sử dụng thực tế #

Benchmark tổng hợp: Chroma so với Cosine Similarity đơn thuần #

Chúng tôi đã benchmark Chroma v0.6.0 so với phương pháp numpy brute-force trên một instance AWS c6i.2xlarge:

Cấu hình test: vector 384 chiều (all-MiniLM-L6-v2), top-k=10, đơn query, cache ấm. Tham số HNSW: M=16, efConstruction=200, efSearch=64.

Khẳng định 50x trong tiêu đề đề cập đến khối lượng công việc RAG thực tế với metadata filtering và concurrent queries — chỉ mục HNSW + query planner của Chroma liên tục cải thiện độ trễ 40–60 lần so với tìm kiếm flat không được lập chỉ mục ở quy mô production.

Các trường hợp sử dụng thực tế #

Hiệu quả bộ nhớ và lưu trữ #

Chroma sử dụng SQLite cho metadata và lưu trữ tài liệu, với chỉ mục HNSW được lưu dưới dạng các file binary riêng biệt. Một collection gồm 1 triệu vector (384 chiều) chiếm khoảng 6,2GB trên đĩa — khoảng 16 byte mỗi chiều + overhead metadata. Điều này có tính cạnh tranh với các cơ sở dữ liệu vector chuyên dụng và hiệu quả hơn đáng kể so với việc giữ mọi thứ trong RAM.

Sử dụng nâng cao / Củng cố Production #

Embedding dimension tùy chỉnh #

# Embedding được tính trước từ bất kỳ mô hình nào (ví dụ: OpenAI text-embedding-3-large)
import numpy as np

# Embedding tùy chỉnh — 3072 chiều
custom_embeddings = [
    np.random.randn(3072).tolist(),  # Thay bằng embedding thực tế
    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"]
)

Metadata Filtering chuyên sâu #

# Truy vấn metadata phức tạp
collection.add(
    documents=["Advanced filtering example"],
    metadatas=[{
        "category": "tutorial",
        "difficulty": "advanced",
        "year": 2026,
        "published": True,
        "tags": ["chroma", "filtering"]
    }],
    ids=["filter_demo"]
)

# So sánh số
results = collection.query(
    query_texts=["filtering"],
    where={"year": {"$gte": 2025}},
    n_results=5
)

# Toán tử logic
results = collection.query(
    query_texts=["advanced tutorial"],
    where={
        "$and": [
            {"category": "tutorial"},
            {"difficulty": "advanced"}
        ]
    },
    n_results=5
)

Multi-tenant Collections #

# Một collection cho mỗi user/tenant — cô lập theo thiết kế
def get_user_collection(user_id: str):
    return client.get_or_create_collection(f"user_{user_id}_docs")

# Dữ liệu của mỗi user được cô lập hoàn toàn
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 cho Production #

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

Triển khai:

docker-compose up -d
# Chroma API có sẵn tại http://localhost:8000

Chiến lược Backup #

# Chroma lưu trữ mọi thứ trong thư mục persist
# Sao lưu bằng các công cụ chuẩn

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

# Khôi phục đơn giản bằng cách giải nén vào cùng đường dẫn
tar -xzf chroma_backup_20260519.tar.gz

So sánh với các lựa chọn thay thế #

Khi nào chọn Chroma:

• Bạn muốn chạy local dưới 2 phút
• Ngôn ngữ chính của bạn là Python
• Bạn cần vector DB cho RAG với LangChain/LlamaIndex
• Bạn thích self-hosting để tránh giá tính theo query
• Bạn đang xây dựng prototype có thể cần mở rộng

Khi nào nên xem xét khác:

• Bạn cần distributed multi-node clusters (xem xét Milvus)
• Bạn cần hybrid search với full-text ranking mạnh (xem xét Weaviate)
• Bạn đầu tư sâu vào hệ sinh thái SQL và muốn JOIN với vectors (xem xét pgvector)

Hạn chế: Đánh giá trung thực #

Chroma không phải công cụ phù hợp cho mọi bài toán tìm kiếm vector. Đây là những gì bạn nên biết:

Không có phân cụm phân tán tích hợp. Chroma chạy trên một node duy nhất. Với tập dữ liệu vượt quá ~10 triệu vector trên một máy, bạn sẽ cần sharding ở lớp ứng dụng hoặc một cơ sở dữ liệu khác như Milvus.

Tìm kiếm hybrid hạn chế. Chroma hỗ trợ metadata filtering + vector search, nhưng tìm kiếm full-text ranking kết hợp với vector similarity (true hybrid search) chưa mạnh bằng Weaviate hay Elasticsearch với vector extensions.

Workload nặng về ghi. Chroma được tối ưu cho workload RAG nặng về đọc. Cập nhật và xóa thường xuyên trên các collection lớn có thể kích hoạt rebuild index làm tạm dừng truy vấn. Với use case nặng về ghi, hãy lập kế hoạch cửa sổ bảo trì.

Không có replication tích hợp. Nếu cần high availability, bạn phải tự triển khai — Docker Swarm, Kubernetes, hoặc công cụ replication bên ngoài. Dịch vụ Chroma Cloud có cung cấp replication và SLA.

Gắn kết với mô hình embedding. Mặc dù Chroma cho phép mang embedding riêng, nhưng hành vi auto-embedding mặc định có thể khóa bạn vào các phiên bản mô hình cụ thể. Gắn chặt embedding function một cách rõ ràng trong production.

Câu hỏi thường gặp #

Chroma có thể xử lý tối đa bao nhiêu vector? #

Trên một máy có 32GB RAM, Chroma thoải mái xử lý 5–10 triệu vector ở 384 chiều. Vượt quá con số này, bạn sẽ gặp giới hạn bộ nhớ trong quá trình xây dựng chỉ mục. Với tập dữ liệu lớn hơn, hãy xem xét Chroma Cloud hoặc sharding trên nhiều instance.

Có thể dùng Chroma không cần kết nối internet không? #

Có. Nếu dùng SentenceTransformerEmbeddingFunction với mô hình được tải trước, Chroma hoạt động hoàn toàn offline. Không cần API key, không gọi cloud, không telemetry (tắt bằng ANONYMIZED_TELEMETRY=FALSE). Điều này làm nó lý tưởng cho môi trường cô lập.

Chroma so với NumPy cho tìm kiếm vector như thế nào? #

Tìm kiếm brute-force NumPy hoạt động với <1.000 vector. Ở 10.000 vector, chỉ mục HNSW của Chroma nhanh hơn 150 lần. Ở 1 triệu vector, con số này là 10.000 lần. NumPy cũng thiếu persistence, metadata filtering và hỗ trợ truy vấn đồng thờii.

Chroma có phù hợp cho production không? #

Có, với lưu ý. Hàng ngàn ứng dụng production đang dùng Chroma. Dùng Docker deployment, cấu hình persistent storage, thiết lập backup và giám sát memory usage. Nếu cần 99,99% uptime với automatic failover, hãy xem xét Chroma Cloud hoặc chạy nhiều instance sau load balancer.

Có thể migrate từ Pinecone hoặc vector DB khác sang Chroma không? #

Có. Pattern migration: xuất vectors + metadata từ DB hiện tại → batch-insert vào Chroma dùng collection.add() với pre-computed embeddings. Hầu hết ngườii dùng hoàn thành migration trong một script. Cấu trúc collection của Chroma mapping gần với Pinecone namespaces.

Chroma có hỗ trợ multi-modal embeddings (ảnh, âm thanh) không? #

Chroma lưu vectors — nó không quan tâm vectors được tạo ra như thế nào. Bạn có thể lưu CLIP image embeddings, audio embeddings từ Whisper, hoặc bất kỳ vector nào. Truyền chúng như pre-computed embeddings với metadata mô tả modality.

Kết luận: Bắt đầu xây dựng với Chroma ngay hôm nay #

Chroma lấp đầy khoảng trống quan trọng trong stack công cụ AI: một cơ sở dữ liệu vector ưu tiên trải nghiệm lập trình viên mà không làm giảm hiệu suất. Năm 2026, với v0.6.x cung cấp persistent storage, HNSW indexing, và tích hợp native với mọi framework RAG chính, Chroma là lựa chọn thực tế cho lập trình viên Python xây dựng tìm kiếm ngữ nghĩa và retrieval-augmented generation.

Tốc độ nhanh hơn 50 lần so với tìm kiếm không chỉ mục không phải marketing — nó có thể đo lường, tái tạo, và có sẵn ngay hôm nay chỉ bằng cách chạy pip install chromadb. Dù bạn đang prototype chatbot hay deploy RAG API production, Chroma giúp bạn đến đích với ít cấu hình hơn và nhiều code thực tế hơn.

Sẵn sàng deploy? Khởi động VPS với Docker trên DigitalOcean và có Chroma chạy production trong vòng 10 phút.

Tham gia nhóm Telegram tiếng Việt của dibi8.com để thảo luận về cơ sở dữ liệu vector, các pattern RAG, và chia sẻ kinh nghiệm deploy Chroma với các lập trình viên khác.

Nguồn & Tài liệu tham khảo #

1. Tài liệu chính thức Chroma: https://docs.trychroma.com/
2. Kho GitHub Chroma: https://github.com/chromadb/chroma
3. Bài báo HNSW (Malkov & Yashunin, 2016): https://arxiv.org/abs/1603.09320
4. Tích hợp Chroma LangChain: https://python.langchain.com/docs/integrations/vectorstores/chroma/
5. Chroma vector store LlamaIndex: https://docs.llamaindex.ai/en/stable/examples/vector_stores/ChromaIndexDemo/
6. “So sánh cơ sở dữ liệu vector 2026” — Xếp hạng DB-Engines: https://db-engines.com/en/ranking/vector+dbms

Hosting Và Hạ Tầng Được Đề Xuất #

Trước khi triển khai các công cụ trên vào production, bạn cần hạ tầng vững chắc. Hai lựa chọn dibi8 đang dùng:

• DigitalOcean — Credit miễn phí $200 trong 60 ngày, 14+ khu vực toàn cầu. Lựa chọn mặc định cho dev chạy AI tools open source.
• HTStack — VPS Hong Kong, độ trễ thấp khi truy cập từ Trung Quốc. Cùng IDC đang host dibi8.com.

Liên kết tiếp thị — không tăng chi phí của bạn, giúp dibi8.com hoạt động.

Tiết lộ liên kết affiliate #

Bài viết này chứa các liên kết affiliate. Nếu bạn đăng ký dịch vụ thông qua các liên kết được đánh dấu trong bài viết này (như DigitalOcean), dibi8.com có thể nhận được hoa hồng mà không phát sinh chi phí thêm cho bạn. Chúng tôi chỉ giới thiệu các công cụ chúng tôi sử dụng và thực sự tin tưởng. Chroma itself là miễn phí và mã nguồn mở theo Apache-2.0 — không có quan hệ affiliate nào tồn tại với dự án Chroma.

Được đăng trên dibi8.com — AI Source Code Hub. Cập nhật lần cuối: 2026-05-19