Cluster status and metadata

Monitor the health, status, and metadata of your Weaviate cluster.

The live endpoint checks if the application is alive. You can use it for a Kubernetes liveness probe.

The endpoint accepts a GET request:

GET /v1/.well-known/live

The endpoint returns HTTP status code 200 if the application is able to respond to HTTP requests.

print(client.is_live())

import weaviate from 'weaviate-client';

const client = await weaviate.connectToLocal()
const response = await client.isLive()

console.log(response)

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)
  }

  isLive, err := client.Misc().LiveChecker().Do(context.Background())
  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", isLive)
}

curl http://localhost:8080/v1/.well-known/live

The endpoint returns HTTP status code 200 if the application is able to respond to HTTP requests.

The ready endpoint checks if the application is ready to receive traffic. You can use it for Kubernetes readiness probe.

The discovery endpoint accepts a GET request:

GET /v1/.well-known/ready

The endpoint returns HTTP status code 200 if the application is able to respond to HTTP requests. If the application is currently unable to serve traffic, the endpoint returns HTTP status code 503.

If the application is unavailable and you have horizontal replicas of Weaviate that can receive traffic, redirect traffic to one of the replicas.

print(client.is_ready())

import weaviate from 'weaviate-client';

const client = await weaviate.connectToLocal()
const response = await client.isReady()

console.log(response)

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)
  }

  isReady, err := client.Misc().ReadyChecker().Do(context.Background())
  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", isReady)
}

curl http://localhost:8080/v1/.well-known/ready

Each Weaviate node can be set to one of the following operational modes, limiting the types of operations it can handle:

• ReadWrite: (default) There are no restrictions; the node can handle both read and write operations.
• WriteOnly: The node is limited to write operations.
• ReadOnly: The node is limited to read operations and backup creation via the /backups endpoints.
• ScaleOut: The same as ReadOnly, with additional CUD operations on /replication endpoints allowed.

These modes can be configured using the OPERATIONAL_MODE environment variable, or the equivalent operational_mode runtime configuration.

The v1/schema/cluster-status endpoint displays the status of the schema synchronization. The endpoint returns the following fields:

• healthy: The status of the schema synchronization.
• hostname: The hostname of the Weaviate instance.
• ignoreSchemaSync: Whether to ignore the cluster check at startup (for recovery from an out-of-sync situation).
• nodeCount: The number of nodes in the cluster.

Example response:

{
    "healthy": true,
    "hostname": "node1",
    "ignoreSchemaSync": false,
    "nodeCount": 3
}

You can retrieve information about individual nodes in a Weaviate cluster. The query can be for the entire cluster, or for a particular collection.

The nodes endpoint returns an array of nodes. The nodes have the following fields:

• name: Name of the node.
• status: Status of the node (one of: HEALTHY, UNHEALTHY, UNAVAILABLE, INDEXING).
• version: Version of Weaviate running on the node.
• gitHash: Short git hash of the latest commit of Weaviate running on the node.
• stats: Statistics for the node.
  • shardCount: Total number of shards on the node.
  • objectCount Total number of indexed objects on the node.
• shards: Array of shard statistics. To see shards details, set output == verbose.
  • name: Name of the shard.
  • class: Name of the collection stored on the shard.
  • objectCount: Number of indexed objects on the shard.
  • vectorQueueLength: Number of objects waiting to be indexed on the shard. (Available starting in Weaviate 1.22 when ASYNC_INDEXING is enabled.)

The following command will retrieve summary information about all nodes in the cluster:

import weaviate

client = weaviate.connect_to_local()

import weaviate from 'weaviate-client';

const client = await weaviate.connectToLocal()

const response = await client.cluster.nodes({
  collection: 'JeopardyQuestion',
  output: 'minimal'
})

console.log(response)

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)
  }

  nodesStatus, err := client.Cluster().
    NodesStatusGetter().
    Do(context.Background())

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", nodesStatus)
}

WeaviateClient client = WeaviateClient
    .connectToLocal(config -> config.host("127.0.0.1").port(8080));

curl http://localhost:8080/v1/nodes

Example output:

{
  "nodes": [
    {
      "batchStats": {
        "ratePerSecond": 0
      },
      "gitHash": "e6b37ce",
      "name": "weaviate-0",
      "stats": {
        "objectCount": 0,
        "shardCount": 2
      },
      "status": "HEALTHY",
      "version": "1.22.1"
    },
    {
      "batchStats": {
        "ratePerSecond": 0
      },
      "gitHash": "e6b37ce",
      "name": "weaviate-1",
      "stats": {
        "objectCount": 1,
        "shardCount": 2
      },
      "status": "HEALTHY",
      "version": "1.22.1"
    },
    {
      "batchStats": {
        "ratePerSecond": 0
      },
      "gitHash": "e6b37ce",
      "name": "weaviate-2",
      "stats": {
        "objectCount": 1,
        "shardCount": 2
      },
      "status": "HEALTHY",
      "version": "1.22.1"
    }
  ]
}

You can retrieve metadata about the Weaviate instance, such as:

• hostname: The location of the Weaviate instance.
• version: The version of Weaviate.
• modules: Module specific info.

import weaviate

client = weaviate.connect_to_local()

meta_info = client.get_meta()
print(meta_info)

client.close()

import weaviate from 'weaviate-client';

const client = await weaviate.connectToLocal()
const response = await client.getMeta()

console.log(response)

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)
  }

  meta, err := client.Misc().MetaGetter().Do(context.Background())

  if err != nil {
    panic(err)
  }
  fmt.Printf("%v", meta)
}

curl http://localhost:8080/v1/meta

returns:

{
  "hostname": "http://[::]:8080",
  "modules": {
    "text2vec-contextionary": {
      "version": "en0.16.0-v0.4.21",
      "wordCount": 818072
    }
  },
  "version": "1.0.0"
}

Have a question or feedback? Here's how to reach us.