Metadata-Based Filtering in RAG Systems with JavaScript

Welcome to the final lesson in our Scaling Up RAG with Vector Databases course! Previously, we explored how to chunk large documents for efficient retrieval, store these chunks in a vector database (such as ChromaDB), and then retrieve them to build prompts for Large Language Models (LLMs). Remember, chunking and storing these text fragments provided the basic scaffolding for a Retrieval-Augmented Generation (RAG) pipeline.

In this lesson, we will expand on that foundation by introducing metadata-based filtering, which allows you to target specific attributes — like category or date — and make your content searches significantly more precise. By the end, you will be able to create queries that focus only on the metadata you care about, such as retrieving documents from specific categories.

Before we get hands-on, let's talk about the intuition behind metadata:

• What is Metadata, and Why Does It Matter?
  Metadata includes any labeled information that describes your text chunks. Common examples are category, date, or title. When you have a large collection of documents, a normal text-based similarity search might return results you don't actually want. But by selectively filtering on metadata, you can drastically reduce irrelevant results and ensure only the most pertinent information is retrieved.

• Real-World Example
  Imagine a large enterprise knowledge base spanning different departments (e.g., Human Resources, Technology, Finance). If you only want to see technology-related documents, applying a simple metadata filter on the category field ensures that your search never strays into HR or Finance content. This becomes particularly useful when you have specialized queries that are domain-specific and need accurate, fast retrieval.

Let's move to coding, first focusing on the metadata filter:

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

const embedder = new OpenAIEmbeddingFunction({
    model_name: "text-embedding-ada-002"
});

const chroma = new ChromaClient({ path: "http://localhost:8000" });
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,
    });
}

function metadataEnhancedSearch(query, collection, categories = null, topK = 3) {
    // If categories are provided, build the filter
    const where = categories ? { category: { $in: categories } } : null;

Here, we take an optional list of categories and build a where clause:

• A where query in ChromaDB acts like a targeted filter on the collection (similar to a WHERE clause in SQL). By specifying { category: { $in: categories } }, only documents with a matching category will be returned.
• The $ symbol in $in denotes a special operator in ChromaDB's query language. It's similar to MongoDB's query syntax, where operators like $in, $eq, $gt, etc., are prefixed with a dollar sign to distinguish them from regular field names. In this case, $in checks if the category value is contained within the provided list of categories.
• If no categories are passed in, the filter is set to null, which tells ChromaDB to run a broader, unfiltered search.