Storing and Managing Text Chunks in Vector Databases with JavaScript

Introduction

Hello there, welcome to the second lesson of our " Scaling Up RAG with Vector Databases " course! In the previous unit, you explored how to break large documents into smaller chunks and attach useful metadata (like doc_id, chunk_id, and labels such as category). These chunks are essential for structuring data in a way that makes retrieval easier. In this lesson, we'll build on that groundwork by showing you how to store them in a vector database . One popular choice is ChromaDB — a specialized, open-source database designed for high-speed, semantic querying of vectors. By switching from keyword-based searches to semantic searches, your RAG system will retrieve relevant information more efficiently. Let's dive in!

Understanding Vector Databases

A vector database stores data in the form of numerical vectors that capture the semantic essence of texts (or other data). The database then uses similarity metrics — rather than literal word matches — so that conceptually similar items are stored close together. This means searches on vector databases can retrieve contextually relevant results even when keywords are absent. By leveraging approximate or exact nearest-neighbor strategies for similarity, vector databases can scale to handle millions or billions of vectors while still providing quick query responses. This makes them especially suitable for RAG systems, which rely on fast semantic lookups across large collections of text.

Why We Need Vector Databases for RAG

Before we explore how to set up a vector database, let's look at why it's a crucial component of a RAG pipeline: Semantic Retrieval : By embedding text into vectors, queries can match documents based on meaning rather than strict keyword matches. This yields more accurate and context-sensitive search results. Scalability : Specialized vector databases handle large datasets efficiently, allowing you to store and query vast libraries of text chunks without sacrificing performance. Richer Context : Embeddings capture nuanced relationships among chunks, ensuring that related information is surfaced even when it doesn't use the exact same terms. Easy Updates : Vector databases (like ChromaDB) often allow you to add and remove chunks on the fly, so your collection stays in sync with new or evolving information.

Join the 1M+ learners on CodeSignal

Be a part of our community of 1M+ users who develop and demonstrate their skills on CodeSignal

Setting Up ChromaDB and Basic Configuration

Now, let's jump into coding with ChromaDB, our chosen vector database. Here's how to set up a ChromaDB client using JavaScript:

JavaScript

import fs from 'fs';
import path from 'path';
import { ChromaClient, OpenAIEmbeddingFunction } from 'chromadb';

async function buildChroma // Use an OpenAI model for embeddings
    const embedder = new OpenAIEmbeddingFunction({
        model_name: "text-embedding-ada-002"
    });

    // Create a ChromaDB client with a specified path
    const chroma = new ChromaClient({ path: "http://localhost:8000" });

    // Check if the collection already exists or create a new one
    const collectionName = "rag_collection";
    const collections = await chroma.listCollections();
    let collection;
    if (collections.find((coll) => coll === collectionName)) {
        console.log(`Collection "${collectionName}" already exists. Retrieving it...`);
        collection = await chroma.getCollection({ name: collectionName });
        if (!collection.embeddingFunction) {
            collection.embeddingFunction = embedder;
        }
    } else {
        console.log(`Collection "${collectionName}" does not exist. Creating collection...`);
        collection = await chroma.createCollection({
            name: collectionName,
            embeddingFunction: embedder,
        });
    }

    // ... continues
}

import fs from 'fs';
import path from 'path';
import { ChromaClient, OpenAIEmbeddingFunction } from 'chromadb';

async function buildChroma // Use an OpenAI model for embeddings
    const embedder = new OpenAIEmbeddingFunction({
        model_name: "text-embedding-ada-002"
    });

    // Create a ChromaDB client with a specified path
    const chroma = new ChromaClient({ path: "http://localhost:8000" });

    // Check if the collection already exists or create a new one
    const collectionName = "rag_collection";
    const collections = await chroma.listCollections();
    let collection;
    if (collections.find((coll) => coll === collectionName)) {
        console.log(`Collection "${collectionName}" already exists. Retrieving it...`);
        collection = await chroma.getCollection({ name: collectionName });
        if (!collection.embeddingFunction) {
            collection.embeddingFunction = embedder;
        }
    } else {
        console.log(`Collection "${collectionName}" does not exist. Creating collection...`);
        collection = await chroma.createCollection({
            name: collectionName,
            embeddingFunction: embedder,
        });
    }

    // ... continues
}

How It Works:

Embedding Setup: We define an OpenAIEmbeddingFunction to generate vectors for the text chunks. The model we're using, text-embedding-ada-002, is a powerful model that maps sentences to a dense vector space. It's popular for RAG applications because it balances efficiency with strong semantic understanding capabilities.
Client Configuration: new ChromaClient({ path: "http://localhost:8000" }) connects to ChromaDB with a specified path. This setup allows for a persistent connection to a ChromaDB server running locally or remotely.
Collection Management: We check if a collection named "rag_collection" exists; if not, we create a new one. It's worth noting that listCollections() returns only the collection names, not their full metadata. So when checking for existence with find((coll) => coll === collectionName), ensure that you're comparing against strings — not objects — to avoid mismatches. This check avoids accidentally creating duplicates and keeps your namespace clean. A collection in ChromaDB is a logical container that groups related documents and their embeddings together, similar to a table in a traditional database but optimized for vector similarity operations. Collections allow you to organize your vector data into separate namespaces, making it possible to maintain multiple distinct sets of documents with different embedding models or for different use cases.

Updating and Managing Documents

ChromaDB allows you to keep your collection up to date with new or modified information. Below is an example of adding and then deleting a "document" (or chunk) after the collection has already been created:

JavaScript

// Example chunks to showcase adding them to a new collection
const exampleChunks = [
    { doc_id: 0, chunk_id: 0, category: "ai", content: "RAG stands for Retrieval-Augmented Generation." },
    { doc_id: 0, chunk_id: 1, category: "ai", content: "A crucial component of a RAG pipeline is the Vector Database." },
    { doc_id: 1, chunk_id: 0, category: "finance", content: "Accurate data is essential in finance." },
];

buildChromaCollection(exampleChunks).then(async collection => {
    // Prepare a new chunk to add
    const newDocument = {
        doc_id: 2,
        chunk_id: 0,
        category: "food",
        content: "Bananas are yellow fruits rich in potassium."
    };

    // Construct a unique ID for the new document
    // Format: "chunk_{doc_id}_{chunk_id}" (e.g., "chunk_2_0")
    const docId = `chunk_${newDocument.doc_id}_${newDocument.chunk_id}`;

    // Add the new chunk to the existing collection
    await collection.add({
        documents: [newDocument.content],  // The text content to be embedded
        metadatas: [{                      // Metadata for filtering and context
            doc_id: newDocument.doc_id,
            chunk_id: newDocument.chunk_id,
            category: newDocument.category
        }],
        ids: [docId]                       // Unique identifier for this chunk
    });

    // If needed, remove the chunk by its unique ID
    // For example, if the information about bananas becomes outdated
    await collection.delete({ ids: [docId] });  // Using the same ID: "chunk_2_0"
});

Key Points:

exampleChunks is our initial list of text chunks with their metadata, while newDocument is a new chunk we want to add to our existing collection.
docId is a unique identifier string created by combining document ID and chunk ID (e.g., "chunk_2_0").
Why Unique IDs Matter: Each chunk needs a unique identifier so ChromaDB can reference it later for updates, deletions, or retrieval. By combining doc_id and chunk_id into a string like "chunk_2_0", we ensure each chunk has a distinct ID while maintaining its relationship to the source document.
Adding: Calling collection.add() again embeds the new document automatically, so your collection grows in real time.
Deleting: When old or incorrect information becomes obsolete — such as a product description that's been updated or regulatory data that's changed — you can simply remove it by its ID. In real-world scenarios, data about policies, facts, or even entire documents can become outdated over time, and selectively deleting chunks lets you keep your database accurate without a full rebuild.

This flexibility means you can keep your RAG environment updated without fully restructuring your database.