Rotational Quantization (RQ)

Compression by Default

Starting with v1.33, you can set a default quantization for new collections using the DEFAULT_QUANTIZATION environment variable. This variable is not set by default, meaning no quantization is applied unless you explicitly configure it. When set (e.g., to 8-bit RQ quantization), all newly created collections will use that quantization setting. Note that once set on a collection, quantization can't be disabled. Default quantization only applies for the HNSW vector index type.

Rotational quantization (RQ) is a fast vector compression technique that offers significant performance benefits. Two RQ variants are available in Weaviate:

• 8-bit RQ: Up to 4x compression while retaining almost perfect recall (98-99% on most datasets). Recommended for most use cases.
• 1-bit RQ: Close to 32x compression as dimensionality increases with moderate recall across various datasets.

8-bit RQ

Added in v1.32

8-bit Rotational quantization (RQ) for the HNSW vector index was added in v1.32.

Preview

8-bit Rotational quantization (RQ) for the flat vector index was added in v1.34 as a preview.

This means that the feature is still under development and may change in future releases, including potential breaking changes. We do not recommend using this feature in production environments at this time.

8-bit RQ provides up-to 4x compression while maintaining 98-99% recall in internal testing. It is generally recommended for most use cases as the default quantization techniques.

Enable compression for new collection

RQ can be enabled at collection creation time through the collection definition:

PythonJavaScript/TypeScriptGoJava v6Java v5 (Deprecated)C# (Beta)

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

from weaviate.classes.config import Configure, Property, DataType

client.collections.create(
    name="MyCollection",
    vector_config=Configure.Vectors.text2vec_openai(
        quantizer=Configure.VectorIndex.Quantizer.rq()
    ),
    properties=[
        Property(name="title", data_type=DataType.TEXT),
    ],
)

import weaviate, { configure } from 'weaviate-client';

await client.collections.create({
    name: "MyCollection",
    vectorizers: configure.vectors.text2VecOpenAI({
        quantizer: configure.vectorIndex.quantizer.rq()
    }),
    properties: [
        { name: "title", dataType: weaviate.configure.dataType.TEXT }
    ]
})

// Define the configuration for RQ. Setting 'enabled' to true
rq_config := map[string]interface{}{
  "enabled": true,
}

// Define the class schema
class := &models.Class{
  Class:      className,
  Vectorizer: "text2vec-openai",
  // Assign the RQ configuration to the vector index config
  VectorIndexConfig: map[string]interface{}{
  	"rq": rq_config,
  },
}

// Create the collection in Weaviate
err = client.Schema().ClassCreator().
  WithClass(class).
  Do(context.Background())

client.collections.create("MyCollection",
    col -> col.vectorConfig(VectorConfig.text2vecTransformers(vc -> vc
        .quantization(Quantization.rq())
    )).properties(Property.text("title")));

WeaviateClass myCollection = WeaviateClass.builder()
    .className("MyCollection")
    .vectorizer("text2vec-openai")
    .vectorIndexConfig(VectorIndexConfig.builder()
        .rq(RQConfig.builder()
            .enabled(true)
            .build())
        .build())
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build()))
    .build();

Result<Boolean> createResult = client.schema().classCreator()
    .withClass(myCollection)
    .run();

//         await client.Collections.Create(new CollectionConfig
//         {
//             Name = "MyCollection",
//             Properties = [Property.Text("title")],
//             VectorConfig = new VectorConfig(
//                 "default",
//                 new Vectorizer.Text2VecTransformers(),
//                 new VectorIndex.HNSW
//                 {
//                     // highlight-start
//                     Quantizer = new VectorIndex.Quantizers.RQ()
//                     // highlight-end
//                 }
//             )
//         });

Enable compression for existing collection

RQ can also be enabled for an existing collection by updating the collection definition:

PythonJavaScript/TypeScriptJava v5 (Deprecated)Java v6C# (Beta)Go

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

from weaviate.classes.config import Reconfigure

collection = client.collections.use("MyCollection")
collection.config.update(
    vector_config=Reconfigure.Vectors.update(
        name="default",
        vector_index_config=Reconfigure.VectorIndex.hnsw(
            quantizer=Reconfigure.VectorIndex.Quantizer.rq(),
        ),
    )
)

import { reconfigure } from 'weaviate-client';

const collection = client.collections.use("MyCollection")

await collection.config.update({
    vectorizers: [ reconfigure.vectors.update({
        name: "default",
        vectorIndexConfig: reconfigure.vectorIndex.hnsw({
            quantizer: reconfigure.vectorIndex.quantizer.rq(),
        }),
    })]
})

WeaviateClass updatedCollection = WeaviateClass.builder()
    .className("MyCollection")
    .description("Updated collection with RQ compression")
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build()))
    .vectorizer("text2vec-openai")
    .vectorIndexConfig(VectorIndexConfig.builder()
        .rq(RQConfig.builder()
            .enabled(true)
            .build())
        .build())
    .build();

Result<Boolean> updateResult = client.schema().classUpdater()
    .withClass(updatedCollection)
    .run();

CollectionHandle<Map<String, Object>> collection =
    client.collections.use("MyCollection");
collection.config.update(c -> c.vectorConfig(VectorConfig
    .text2vecTransformers(vc -> vc.quantization(Quantization.rq()))));

//         await collection.Config.Update(c =>
//         {
//             var vectorConfig = c.VectorConfig["default"];
//             vectorConfig.VectorIndexConfig.UpdateHNSW(h => h.Quantizer = new VectorIndex.Quantizers.RQ());
//         });

// Get the existing collection configuration
class, err := client.Schema().ClassGetter().
  WithClassName(className).Do(context.Background())

if err != nil {
  log.Fatalf("get class for vec idx cfg update: %v", err)
}

// Get the current vector index configuration
cfg := class.VectorIndexConfig.(map[string]interface{})

// Add RQ configuration to enable quantization
cfg["rq"] = map[string]interface{}{
  "enabled": true,
}

// Update the class configuration
class.VectorIndexConfig = cfg

// Apply the updated configuration to the collection
err = client.Schema().ClassUpdater().
  WithClass(class).Do(context.Background())

if err != nil {
  log.Fatalf("update class to use rq: %v", err)
}

1-bit RQ

Added in v1.32

1-bit Rotational quantization (RQ) for the HNSW vector index was added in v1.33.

Preview

1-bit Rotational quantization (RQ) for the flat vector index was added in v1.34 as a preview.

This means that the feature is still under development and may change in future releases, including potential breaking changes. We do not recommend using this feature in production environments at this time.

1-bit RQ is an quantization technique that provides close to 32x compression as dimensionality increases. 1-bit RQ serves as a more robust and accurate alternative to BQ with only a slight performance trade-off. While more performant than PQ in terms of encoding time and distance calculations, 1-bit RQ typically offers slightly lower recall than well-tuned PQ.

Enable compression for new collection

RQ can be enabled at collection creation time through the collection definition:

PythonJavaScript/TypeScriptGoJava v5 (Deprecated)Java v6C# (Beta)

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

from weaviate.classes.config import Configure, Property, DataType

client.collections.create(
    name="MyCollection",
    vector_config=Configure.Vectors.text2vec_openai(
        quantizer=Configure.VectorIndex.Quantizer.rq(bits=1)
    ),
    properties=[
        Property(name="title", data_type=DataType.TEXT),
    ],
)

import weaviate, { configure } from 'weaviate-client';

await client.collections.create({
    name: "MyCollection",
    vectorizers: configure.vectors.text2VecOpenAI({
        quantizer: configure.vectorIndex.quantizer.rq({
            bits: 1,
        })
    }),
    properties: [
        { name: "title", dataType: weaviate.configure.dataType.TEXT }
    ]
})

// Define the configuration for RQ. Setting 'enabled' to true
rq_config := map[string]interface{}{
  "enabled": true,
  "bits":    1,
}

// Define the class schema
class := &models.Class{
  Class:      className,
  Vectorizer: "text2vec-openai",
  // Assign the RQ configuration to the vector index config
  VectorIndexConfig: map[string]interface{}{
  	"rq": rq_config,
  },
}

// Create the collection in Weaviate
err = client.Schema().ClassCreator().
  WithClass(class).
  Do(context.Background())

WeaviateClass myCollection = WeaviateClass.builder()
    .className("MyCollection")
    .vectorizer("text2vec-openai")
    .vectorIndexConfig(VectorIndexConfig.builder()
        .rq(RQConfig.builder()
            .enabled(true)
            .bits(1L)
            .build())
        .build())
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build()))
    .build();

Result<Boolean> createResult = client.schema().classCreator()
    .withClass(myCollection)
    .run();

client.collections.create("MyCollection",
    col -> col.vectorConfig(VectorConfig.text2vecTransformers(vc -> vc
        .quantization(Quantization.rq(q -> q.bits(1)))
    )).properties(Property.text("title")));

//         await client.Collections.Create(new CollectionConfig
//         {
//             Name = "MyCollection",
//             Properties = [Property.Text("title")],
//             VectorConfig = new VectorConfig(
//                 "default",
//                 new Vectorizer.Text2VecTransformers(),
//                 new VectorIndex.HNSW
//                 {
//                     // highlight-start
//                     Quantizer = new VectorIndex.Quantizers.RQ { Bits = 1 }
//                     // highlight-end
//                 }
//             )
//         });

Enable compression for existing collection

RQ can also be enabled for an existing collection by updating the collection definition:

PythonJavaScript/TypeScriptGoJava v6Java v5 (Deprecated)C# (Beta)

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

from weaviate.classes.config import Reconfigure

collection = client.collections.use("MyCollection")
collection.config.update(
    vector_config=Reconfigure.Vectors.update(
        name="default",
        vector_index_config=Reconfigure.VectorIndex.hnsw(
            quantizer=Reconfigure.VectorIndex.Quantizer.rq(bits=1),
        ),
    )
)

import { reconfigure } from 'weaviate-client';

const collection = client.collections.use("MyCollection")

await collection.config.update({
    vectorizers: [ reconfigure.vectors.update({
        name: "default",
        vectorIndexConfig: reconfigure.vectorIndex.hnsw({
            quantizer: reconfigure.vectorIndex.quantizer.rq({ bits: 1 }),
        }),
    })]
})

// Get the existing collection configuration
class, err := client.Schema().ClassGetter().
  WithClassName(className).Do(context.Background())

if err != nil {
  log.Fatalf("get class for vec idx cfg update: %v", err)
}

// Get the current vector index configuration
cfg := class.VectorIndexConfig.(map[string]interface{})

// Add RQ configuration to enable scalar quantization
cfg["rq"] = map[string]interface{}{
  "enabled": true,
  "bits":    1,
}

// Update the class configuration
class.VectorIndexConfig = cfg

// Apply the updated configuration to the collection
err = client.Schema().ClassUpdater().
  WithClass(class).Do(context.Background())

if err != nil {
  log.Fatalf("update class to use rq: %v", err)
}

CollectionHandle<Map<String, Object>> collection =
    client.collections.use("MyCollection");
collection.config
    .update(c -> c.vectorConfig(VectorConfig.text2vecTransformers(
        vc -> vc.quantization(Quantization.rq(q -> q.bits(1))))));

WeaviateClass updatedCollection = WeaviateClass.builder()
    .className("MyCollection")
    .description("Updated collection with RQ compression")
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build()))
    .vectorizer("text2vec-openai")
    .vectorIndexConfig(VectorIndexConfig.builder()
        .rq(RQConfig.builder()
            .enabled(true)
            .bits(1L)
            .build())
        .build())
    .build();

Result<Boolean> updateResult = client.schema().classUpdater()
    .withClass(updatedCollection)
    .run();

//         await collection.Config.Update(c =>
//         {
//             var vectorConfig = c.VectorConfig["default"];
//             vectorConfig.VectorIndexConfig.UpdateHNSW(h => h.Quantizer = new VectorIndex.Quantizers.RQ { Bits = 1 });
//         });

RQ parameters

To tune RQ, use these quantization and vector index parameters:

Parameter	Type	Default	Details
rq: bits	integer	8	The number of bits used to quantize each data point. Value can be 8 or 1. Learn more about 8-bit and 1-bit RQ.
rq: rescoreLimit	integer	-1	The minimum number of candidates to fetch before rescoring.
rq : cache	boolean	false	Whether to cache the vectors in memory. (only when using the flat vector index type)
vectorCacheMaxObjects	integer	1e12	Maximum number of objects in the memory cache. By default, this limit is set to one trillion (1e12) objects when a new collection is created. For sizing recommendations, see Vector cache considerations.

PythonJavaScript/TypeScriptGoJava v6Java v5 (Deprecated)C# (Beta)

  API docs

More infoCode snippets in the documentation reflect the latest client library and Weaviate Database version. Check the Release notes for specific versions.

If a snippet doesn't work or you have feedback, please open a GitHub issue.

from weaviate.classes.config import Configure, Property, DataType

client.collections.create(
    name="MyCollection",
    vector_config=Configure.Vectors.text2vec_openai(
        quantizer=Configure.VectorIndex.Quantizer.rq(
            bits=8,  # Optional: Number of bits
            rescore_limit=20,  # Optional: Number of candidates to fetch before rescoring
            cache=True,  # Optional: Enable caching for flat index (enabled by default for for HNSW)
        ),
        vector_index_config=Configure.VectorIndex.flat(
            vector_cache_max_objects=100000,  # Optional: Maximum number of objects in the memory cache
        ),
    ),
    properties=[
        Property(name="title", data_type=DataType.TEXT),
    ],
)

import weaviate, { configure } from 'weaviate-client';

await client.collections.create({
    name: "MyCollection",
    vectorizers: configure.vectors.text2VecOpenAI({
        quantizer: configure.vectorIndex.quantizer.rq({
            bits: 8,  // Optional: Number of bits
            rescoreLimit: 20,  // Optional: Number of candidates to fetch before rescoring
        }),
    }),
    properties: [
        { name: "title", dataType: weaviate.configure.dataType.TEXT }
    ],
})

// Define a custom configuration for RQ
rq_with_options_config := map[string]interface{}{
  "enabled":      true,
  "bits":         8,  // Optional: Number of bits
  "rescoreLimit": 20, // Optional: Number of candidates to fetch before rescoring
}

// Define the class schema with the custom RQ config and other HNSW settings
class_with_options := &models.Class{
  Class:      className,
  Vectorizer: "text2vec-openai",
  VectorIndexConfig: map[string]interface{}{
  	"rq": rq_with_options_config,
  },
}

// Create the collection in Weaviate
err = client.Schema().ClassCreator().
  WithClass(class_with_options).
  Do(context.Background())

client.collections.create("MyCollection",
    col -> col.vectorConfig(VectorConfig.text2vecTransformers(vc -> vc
        .quantization(Quantization.rq(q -> q.bits(8) // Optional: Number of bits
            .rescoreLimit(20) // Optional: Number of candidates to fetch before rescoring
        ))
    )).properties(Property.text("title")));

WeaviateClass myCollection = WeaviateClass.builder()
    .className("MyCollection")
    .vectorizer("text2vec-openai")
    .vectorIndexConfig(VectorIndexConfig.builder()
        .rq(RQConfig.builder()
            .enabled(true)
            .bits(8L) // Optional: Number of bits
            .rescoreLimit(20L) // Optional: Number of candidates to fetch before rescoring
            .build())
        .build())
    .properties(Arrays.asList(
        Property.builder()
            .name("title")
            .dataType(Arrays.asList(DataType.TEXT))
            .build()))
    .build();

Result<Boolean> createResult = client.schema().classCreator()
    .withClass(myCollection)
    .run();

//         await client.Collections.Create(new CollectionConfig
//         {
//             Name = "MyCollection",
//             Properties = [Property.Text("title")],
//             VectorConfig = new VectorConfig(
//                 "default",
//                 new Vectorizer.Text2VecTransformers(),
//                 new VectorIndex.HNSW
//                 {
//                     // highlight-start
//                     Quantizer = new VectorIndex.Quantizers.RQ
//                     {
//                         Bits = 8,        // Optional: Number of bits
//                         RescoreLimit = 20  // Optional: Number of candidates to fetch before rescoring
//                     }
//                     // highlight-end
//                 }
//             )
//         });

Additional considerations

Multiple vector embeddings (named vectors)

Collections can have multiple named vectors. The vectors in a collection can have their own configurations, and compression must be enabled independently for each vector. Every vector is independent and can use PQ, BQ, RQ, SQ, or no compression.

Multi-vector embeddings (ColBERT, ColPali, etc.)

Added in v1.30

Multi-vector embeddings (implemented through models like ColBERT, ColPali, or ColQwen) represent each object or query using multiple vectors instead of a single vector. Just like with single vectors, multi-vectors support PQ, BQ, RQ, SQ, or no compression.

During the initial search phase, compressed vectors are used for efficiency. However, when computing the MaxSim operation, uncompressed vectors are utilized to ensure more precise similarity calculations. This approach balances the benefits of compression for search efficiency with the accuracy of uncompressed vectors during final scoring.

Multi-vector performance

RQ supports multi-vector embeddings. Each token vector is rounded up to a multiple of 64 dimensions, which may result in less than 4x compression for very short vectors. This is a technical limitation that may be addressed in future versions.

Further resources

• Starter guides: Compression
• Reference: Vector index
• Concepts: Vector quantization
• Concepts: Vector index

Questions and feedback

If you have any questions or feedback, let us know in the user forum.

Technical questions

If you have questions feel free to post on our Community forum.

Documentation feedback

Leave feedback by opening a GitHub issue.