Learn ChromaDB - Prerequisite Skills & Environment Setup

#Introduction

Welcome to the Learn ChromaDB series! This series will take you from mastering ChromaDB — the open-source, AI-native vector database used to build Retrieval-Augmented Generation (RAG) applications, semantic search, and agent memory — from the foundations of the concepts all the way to production readiness. In total there are 23 episodes arranged in six phases.

But before touching chromadb, there are some core skills and software you must have. Why do these prerequisites matter? Because ChromaDB is not just a place to store text. It is a database that stores vectors — numeric representations of meaning — and every operation revolves around this concept. If you do not yet understand what an embedding is, every query feature will feel like a black box.

Episode 0 is your roadmap: we will make sure the prerequisite skills are in place, set up a Python environment, install ChromaDB, and run your first verification. Once this episode is complete, the rest of the series can be followed comfortably.

#Core Skills You Must Master

#Python 3.9+ and Environment Management

ChromaDB is a Python library, so you need to be comfortable with Python 3.9 and above. Make sure basic syntax like lists, dicts, loops, and functions are not foreign to you. Most importantly: get into the habit of using a virtual environment so your RAG projects do not collide with other dependencies.

python3 --version

The output should show version 3.9 or newer. If not, update Python on your system first.

#The Concepts of Vectors and Embeddings

This is a foundation that cannot be negotiated. An embedding is a sequence of numbers (a vector) that represents the meaning of a piece of text. Two texts with similar meanings produce vectors that are close together in a high-dimensional space. Key concepts to understand:

• Dimensions: the length of the vector, for example 384 or 1536, depending on the embedding model.
• Similarity: how close two vectors are, usually measured with cosine similarity.
• ANN: approximate nearest neighbor, the fast nearest-neighbor search technique used by vector databases.

Also understand the RAG workflow in general: documents are split, embedded, stored in a vector database, and then when a question arrives, the query is embedded and the nearest vectors are retrieved to serve as context for the model's answer.

embed → store → retrieve → generate

#Software to Prepare

#A Python Environment with venv

Start by creating a project directory and a virtual environment:

mkdir rag-project
cd rag-project
python3 -m venv .venv
source .venv/bin/activate

Once activated, your terminal prompt will show (.venv). All subsequent installations will run inside this environment.

#Installing ChromaDB

With the environment active, install the main library:

pip install chromadb

This process will pull in several large dependencies such as onnxruntime and numpy. Wait until it finishes, then verify:

pip show chromadb

Make sure Version shows 1.5.9 or newer. This is the latest stable release as of this series being written, and it matters because it fixes a security vulnerability we will discuss in episode 14.

#Extra Tools: Docker and Embedding Models

For episodes 12-15 later on, you will run ChromaDB as a server. Get Docker ready now so things go smoothly later:

docker --version

Optional but very useful: sentence-transformers for more powerful local embeddings, or an OpenAI account if you want to use the embedding API. We will cover both in depth in episode 6. For the whole series, ChromaDB's built-in embedding is enough — it runs locally without an API key.

#Verifying Your Environment

Before moving on to episode 1, run a quick verification to make sure everything is ready:

Verifikasi pertama chromadb

import chromadb
 
client = chromadb.Client()
collection = client.create_collection("cek-instalasi")
collection.add(documents=["halo"], ids=["1"])
hasil = collection.query(query_texts=["halo"])
print(hasil["ids"])

If there are no errors and it prints [['1']], your environment is ready. The chromadb.Client() call above creates an in-memory client, and collection.add stores your first document — we will break down both in episode 3.

One more thing: get into the habit of using client.query(query_texts=["halo"]) rather than memorizing syntax. This whole series will build that habit so that in production, you will not get stuck.

#Summary of Skills You Must Master

A summary of the prerequisites you have prepared in episode 0:

• Python 3.9+ with the habit of using virtual environments.
• The concept of embeddings: dimensions, cosine similarity, and ANN.
• The RAG workflow: embed, store, retrieve, generate.
• chromadb installed at version 1.5.9 or newer.
• Docker as preparation for server mode in upcoming episodes.

If anything is missing, stop and complete it before continuing. A strong foundation will make the next 22 episodes feel much lighter.

#Closing

In episode 0 you laid the groundwork for the whole series: understanding the concepts of vectors and embeddings, the RAG workflow, setting up a Python environment with venv, installing chromadb 1.5.9, and verifying your first operation.

Key takeaways:

• ChromaDB stores vectors, not just text: master the embedding concept first.
• The RAG workflow always revolves around embed → store → retrieve → generate.
• Always use a virtual environment for Python projects.
• Make sure chromadb is installed at least at version 1.5.9.
• First verification: create a client, add one document, and query it back.

In the next episode, episode 1, we will discuss history, background, and why you need ChromaDB — from the problem of storing embeddings at million-scale, the birth of Chroma as search infrastructure for AI, to its position as one of the most widely used open-source vector databases. Make sure your environment is ready, because the Learn ChromaDB journey has only just begun!