Multi-node setup

Replication settings

Replication factor change

The replication factor of a collection cannot be updated by updating the collection's definition.

From v1.32 by using replica movement, the replication factor of a shard can be changed.

Configure replication settings, such as async replication and deletion resolution strategy.

PythonJavaScript/TypeScriptGoJava v6Java v5 (Deprecated)C#Curl

  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, ReplicationDeletionStrategy

client.collections.create(
    "Article",
    replication_config=Configure.replication(
        factor=3,
        async_enabled=True,
        deletion_strategy=ReplicationDeletionStrategy.TIME_BASED_RESOLUTION,
        async_config=Configure.Replication.async_config(
            max_workers=5,
            hashtree_height=16,
            frequency=30,
        ),
    ),
)

  .Configure

import { configure } from 'weaviate-client';

await client.collections.create({
  name: 'Article',
  replication: configure.replication({
    factor: 3,
    asyncEnabled: true,
    deletionStrategy: 'TimeBasedResolution',
    asyncConfig: {
      maxWorkers: 5,
      hashtreeHeight: 16,
      frequency: 30,
    },
  }),
})

  articleClass := &models.Class{
    Class:       "Article",
    Description: "Collection of articles",
    ReplicationConfig: &models.ReplicationConfig{
      AsyncEnabled:     true,
      Factor:           3,
      DeletionStrategy: models.ReplicationConfigDeletionStrategyTimeBasedResolution,
    },
  }

threeNodeClient.collections.create("Article",
    col -> col.replication(Replication.of(rep -> rep.replicationFactor(3)
        .asyncEnabled(true)
        .deletionStrategy(DeletionStrategy.TIME_BASED_RESOLUTION)
        .asyncReplication(AsyncReplicationConfig.of(async -> async
            .propagationConcurrency(5)
            .hashTreeHeight(16)
            .frequencyMillis(30))))));

// Configure replication settings
Integer replicationFactor = 3;
Boolean asyncEnabled = true;

// Create replication configuration
ReplicationConfig replicationConfig = ReplicationConfig.builder()
    .factor(replicationFactor) // factor=3
    .asyncEnabled(asyncEnabled) // async_enabled=True
    .deletionStrategy(ReplicationConfig.DeletionStrategy.DELETE_ON_CONFLICT)
    .build();

// Create the Article collection with replication configuration
WeaviateClass articleClass = WeaviateClass.builder()
    .className(collectionName)
    .description("Article collection with replication configuration")
    .replicationConfig(replicationConfig) // Set the replication config
    .build();

// Add the collection to the schema
Result<Boolean> result = client.schema().classCreator()
    .withClass(articleClass)
    .run();

await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = "Article",
        ReplicationConfig = new ReplicationConfig
        {
            Factor = 1,
            AsyncEnabled = true,
            DeletionStrategy = DeletionStrategy.TimeBasedResolution,
        },
    }
);

curl \
-X POST \
-H "Content-Type: application/json" \
-d '{
    "class": "Article",
    "properties": [
        {
            "dataType": [
                "string"
            ],
            "description": "Title of the article",
            "name": "title"
        }
    ],
    "replicationConfig": {
      "factor": 3,
      "asyncEnabled": true,
      "deletionStrategy": "TimeBasedResolution",
      "asyncConfig": {
        "maxWorkers": 5,
        "hashtreeHeight": 16,
        "frequency": 30000
      }
    }
}' \
http://localhost:8080/v1/schema

Additional information

To use replication factors greater than one, use a multi-node deployment.

For details on the configuration parameters, see the following:

• Replication

Update replication settings

Update async replication settings for an existing collection. The asyncConfig parameters are mutable and can be changed at any time.

PythonJavaScript/TypeScriptJava v6

  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.get("Article")

collection.config.update(
    replication_config=Reconfigure.replication(
        async_config=Reconfigure.Replication.async_config(
            max_workers=10,
            frequency=60,
        ),
    ),
)

const articleReplication = client.collections.use('Article')

await articleReplication.config.update({
  replication: reconfigure.replication({
    asyncConfig: {
      maxWorkers: 10,
      frequency: 60,
    },
  }),
})

var collection = threeNodeClient.collections.use("Article");

collection.config.update(col -> col.replication(Replication.of(
    rep -> rep.asyncReplication(AsyncReplicationConfig.of(async -> async
        .propagationConcurrency(10)
        .frequencyMillis(60))))));

info

Changing the hash tree height invalidates the existing tree and triggers a full rebuild. The rebuild duration scales with the number of objects in the collection, but it runs in the background and does not block reads or writes.

Sharding settings

Configure sharding per collection.

PythonJavaScript/TypeScriptGoJava v6Java v5 (Deprecated)C#

  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

client.collections.create(
    "Article",
    sharding_config=Configure.sharding(
        virtual_per_physical=128,
        desired_count=1,
        desired_virtual_count=128,
    ),
)

import { configure } from 'weaviate-client';

await client.collections.create({
  name: 'Article',
  sharding: configure.sharding({
    virtualPerPhysical: 128,
    desiredCount: 1,
    desiredVirtualCount: 128,
  })
})

  articleClass := &models.Class{
    Class:       "Article",
    Description: "Collection of articles",
    ShardingConfig: sharding.Config{
      VirtualPerPhysical:  128,
      DesiredCount:        1,
      DesiredVirtualCount: 128,
      Key:                 sharding.DefaultKey,
      Strategy:            sharding.DefaultStrategy,
      Function:            sharding.DefaultFunction,
    },
  }

client.collections.create("Article",
    col -> col.sharding(Sharding.of(s -> s.virtualPerPhysical(128)
        .desiredCount(1)
        .desiredVirtualCount(128))));

// Configure sharding settings
Integer virtualPerPhysical = 128;
Integer desiredCount = 1;
Integer desiredVirtualCount = 128;

// Create sharding configuration
ShardingConfig shardingConfig = ShardingConfig.builder()
    .virtualPerPhysical(virtualPerPhysical) // virtual_per_physical=128
    .desiredCount(desiredCount) // desired_count=1
    .desiredVirtualCount(desiredVirtualCount) // desired_virtual_count=128
    .build();

// Create the Article collection with sharding configuration
WeaviateClass articleClass = WeaviateClass.builder()
    .className(collectionName)
    .description("Article collection with sharding configuration")
    .shardingConfig(shardingConfig) // Set the sharding config
    .build();

// Add the collection to the schema
Result<Boolean> result = client.schema().classCreator()
    .withClass(articleClass)
    .run();

await client.Collections.Create(
    new CollectionCreateParams
    {
        Name = "Article",
        ShardingConfig = new ShardingConfig
        {
            VirtualPerPhysical = 128,
            DesiredCount = 1,
            DesiredVirtualCount = 128,
        },
    }
);

Additional information

For details on the configuration parameters, see the following:

• Sharding

Inspect shards (for a collection)

An index itself can be comprised of multiple shards.

PythonJavaScript/TypeScriptGoJava v6Java v5 (Deprecated)C#

  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.

articles = client.collections.use("Article")

article_shards = articles.config.get_shards()
print(article_shards)

let articles = client.collections.use('Article')

const shards = await articles.config.getShards()
console.log(JSON.stringify(shards, null, 2));

package main

import (
  "context"
  "fmt"

  "github.com/weaviate/weaviate-go-client/v5/weaviate"
)

func main() {
  cfg := weaviate.Config{
    Host:   "localhost:8080",
    Scheme: "http",
  }
  client, err := weaviate.NewClient(cfg)
  if err != nil {
    panic(err)
  }
  shards, err := client.Schema().
    ShardsGetter().
    WithClassName("Article").
    Do(context.Background())
  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", shards)
}

CollectionHandle<Map<String, Object>> articles =
    client.collections.use("Article");

List<Shard> articleShards = articles.config.getShards();
System.out.println(articleShards);

Result<Shard[]> result = client.schema().shardsGetter()
    .withClassName(collectionName)
    .run();

Shard[] shards = result.getResult();
if (shards == null || shards.length == 0) {
  System.out.println("No shards found in this collection.");
  return;
}

// Iterate over each shard and print its status
for (Shard shard : shards) {
  System.out.println("Shard name: " + shard.getName());
  System.out.println("Shard status: " + shard.getStatus()); // Get shard status (whether it's READY or READONLY)
}

    // Coming soon

Update shard status

You can manually update a shard to change it's status. For example, update the shard status from READONLY to READY after you make other changes.

PythonJavaScript/TypeScriptGoJava v6Java v5 (Deprecated)C#

  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.

articles = client.collections.use("Article")

article_shards = articles.config.update_shards(
    status="READY",
    shard_names=shard_names,  # The names (List[str]) of the shard to update (or a shard name)
)

print(article_shards)

let articles = client.collections.use("Article");

const shards = await articles.config.updateShards("READY", "shard-1234");
console.log(JSON.stringify(shards, null, 2));

shardStatus, err := client.Schema().ShardUpdater().
  WithClassName(myCollectionName). // Set your collection name
  WithShardName(shardName).        // Set the shard name to update
  WithStatus("READY").
  Do(ctx)
if err != nil {
  // handle error
  panic(err)
}
fmt.Printf("%v", shardStatus)

CollectionHandle<Map<String, Object>> articles =
    client.collections.use("Article");

List<Shard> articleShards =
    articles.config.updateShards(ShardStatus.READONLY, shardName);
System.out.println(articleShards);

Result<ShardStatus> updateToReadyStatus = client.schema().shardUpdater()
    .withClassName(collectionName)
    .withShardName(shardName)
    .withStatus(ShardStatuses.READY)
    .run();

if (updateToReadyStatus.hasErrors()) {
  System.out.println(updateToReadyStatus.getError());
  return;
}

System.out.println(updateToReadyStatus.getResult());

    // Coming soon

Further resources

• API References: REST: Schema

• References: Configuration: Schema
• Concepts: Data structure

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.