Product Quantization (PQ)

import { configure } from 'weaviate-client';

from weaviate.classes.config import Configure

client.collections.create(
    name="Question",
    description="A Jeopardy! question",
    vector_config=Configure.Vectors.text2vec_openai(
        name="default",
    ),
    generative_config=Configure.Generative.openai(),
)

const collection = await client.collections.create({
  name: 'Question',
  vectorizer: weaviate.configure.vectors.text2VecOpenAI({
    sourceProperties: ["title"],
  })
})

// Create initial collection without PQ
initialClass := &models.Class{
  Class:      className,
  Vectorizer: "text2vec-openai",
  Properties: []*models.Property{
    {Name: "question", DataType: []string{"text"}},
    {Name: "answer", DataType: []string{"text"}},
  },
  VectorIndexConfig: map[string]interface{}{
    "distance": "cosine",
  },
}

err = client.Schema().ClassCreator().
  WithClass(initialClass).
  Do(context.Background())

client.collections.create("Question",
    col -> col.description("A Jeopardy! question")
        .properties(Property.text("question"), Property.text("answer"))
        .vectorConfig(VectorConfig.text2vecOpenAi(
            vc -> vc.quantization(Quantization.uncompressed()))));

await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = "Question",
        Description = "A Jeopardy! question",
        VectorConfig = Configure.Vector("default", v => v.Text2VecTransformers()),
        Properties =
        [
            Property.Text("question"),
            Property.Text("answer"),
            Property.Text("category"),
        ],
    }
);

from weaviate.classes.config import Reconfigure

jeopardy = client.collections.use("Question")
jeopardy.config.update(
    vector_config=Reconfigure.Vectors.update(
        name="default",
        vector_index_config=Reconfigure.VectorIndex.hnsw(
            quantizer=Reconfigure.VectorIndex.Quantizer.pq(
                training_limit=50000  # Default: 100000
            ),
        )
    )
)

const collection = client.collections.use(collectionName);

await collection.config.update({
  vectorizers: weaviate.reconfigure.vectors.update({
    vectorIndexConfig: weaviate.reconfigure.vectorIndex.hnsw({
      quantizer: weaviate.reconfigure.vectorIndex.quantizer.pq({
        trainingLimit: 50000
      })
    })
  })
})

// 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 PQ configuration to enable product quantization
cfg["pq"] = map[string]interface{}{
  "enabled":       true,
  "trainingLimit": 100000, // Optional: number of vectors to use for training
  "segments":      96,     // Optional: number of segments for product quantization
}

// 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 pq: %v", err)
}

collection.config
    .update(c -> c.vectorConfig(VectorConfig.text2vecOpenAi(vc -> vc
        .quantization(Quantization.pq(pq -> pq.trainingLimit(50000))))));

await collection.Config.Update(c =>
{
    var vectorConfig = c.VectorConfig["default"];
    vectorConfig.VectorIndexConfig.UpdateHNSW(h =>
        h.Quantizer = new VectorIndex.Quantizers.PQ
        {
            TrainingLimit = 50000,
            Encoder = new VectorIndex.Quantizers.PQ.EncoderConfig
            {
                Type = VectorIndex.Quantizers.EncoderType.Tile,
                Distribution = VectorIndex.Quantizers.DistributionType.Normal,
            },
        }
    );
});

jeopardy = client.collections.use("Question")
config = jeopardy.config.get()
pq_config = config.vector_config["default"].vector_index_config.quantizer

# print some of the config properties
print(f"Encoder: { pq_config.encoder }")
print(f"Training: { pq_config.training_limit }")
print(f"Segments: { pq_config.segments }")
print(f"Centroids: { pq_config.centroids }")

const collection = client.collections.use(collectionName);

// Verify the PQ configuration was applied
updatedClass, err := client.Schema().ClassGetter().
  WithClassName(className).Do(context.Background())
if err != nil {
  log.Fatalf("get class to verify vec idx cfg changes: %v", err)
}

cfg = updatedClass.VectorIndexConfig.(map[string]interface{})
log.Printf("pq config: %v", cfg["pq"])

CollectionHandle<Map<String, Object>> jeopardy =
    client.collections.use("Question");
Optional<CollectionConfig> configOpt = jeopardy.config.get();

System.out.println(configOpt);

var jeopardy = client.Collections.Use("Question");
var config = await jeopardy.Config.Get();

Console.WriteLine(
    JsonSerializer.Serialize(config, new JsonSerializerOptions { WriteIndented = true })
);