# Cluster status and metadata

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

## Liveness

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

#### Usage

The endpoint accepts a `GET` request:

```js
GET /v1/.well-known/live
```

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

#### Example

:::code-group{sync="languages"}
```python title="Python"
print(client.is_live())
```

```js title="JavaScript/TypeScript"
import weaviate from 'weaviate-client';

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

console.log(response)
```

```go title="Go"
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)
}
```

```bash title="Curl"
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.

## Readiness

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

#### Usage

The discovery endpoint accepts a `GET` request:

```js
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.

#### Example

:::code-group{sync="languages"}
```python title="Python"
print(client.is_ready())
```

```js title="JavaScript/TypeScript"
import weaviate from 'weaviate-client';

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

console.log(response)
```

```go title="Go"
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)
}
```

```bash title="Curl"
curl http://localhost:8080/v1/.well-known/ready
```
:::

## Operational modes

:::callout{intent="info" title="Added in `v1.35.0`"}
:::

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](../database-configuration/overview.md), or the equivalent `operational_mode` [runtime configuration](../database-configuration/runtime-config.md).

## Schema synchronization

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:

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

## Cluster node data

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

### Parameters

| Name     | Location | Type   | Description                                                                                                              |
| -------- | -------- | ------ | ------------------------------------------------------------------------------------------------------------------------ |
| `output` | body     | string | How much information to include in the output. Options:  `minimal` (default) and `verbose` (includes shard information). |

### Returned data:

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

### Example

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

:::code-group{sync="languages"}
```python title="Python"
import weaviate

client = weaviate.connect_to_local()
```

```js title="JavaScript/TypeScript"
import weaviate from 'weaviate-client';

const client = await weaviate.connectToLocal()

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

console.log(response)
```

```go title="Go"
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)
}
```

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

```bash title="Curl"
curl http://localhost:8080/v1/nodes
```
:::

Example output:

```json
{
  "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"
    }
  ]
}
```

## Cluster metadata

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.

### Example

:::code-group{sync="languages"}
```python title="Python"
import weaviate

client = weaviate.connect_to_local()

meta_info = client.get_meta()
print(meta_info)

client.close()
```

```js title="JavaScript/TypeScript"
import weaviate from 'weaviate-client';

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

console.log(response)
```

```go title="Go"
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)
}
```

```bash title="Curl"
curl http://localhost:8080/v1/meta
```
:::

returns:

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

## Questions and feedback

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

::::card-grid
:::card{title="Community Forum" href="https://forum.weaviate.io/c/support" icon="messages-square"}
Ask questions and connect with other developers on our **Community forum**.
:::

:::card{title="Support" href="/guides/support-overview" icon="life-buoy"}
Weaviate Cloud user or customer? Find the right channel on the **Support page**.
:::
::::

## Related pages

- [Agents](./agents-index.md)
- [AI-assisted Weaviate code generation](./ai-assisted-vibe-coding-index.md)
- [APIs](./apis-index.md)
- [Authorization and authentication](./authorization-and-authentication-index.md)
- [Benchmarks](./benchmarks-index.md)
- [Best practices](./best-practices-index.md)
- [Client libraries](./clients-index.md)
- [Client Libraries / SDKs](./client-libraries-index.md)
- [Cloud](./cloud-index.md)
- [Cloud account management](./cloud-account-management-index.md)

# Agent Instructions

This portal answers questions programmatically. To receive a synthesized,
source-cited answer instead of crawling page by page, append the `?ask=`
query parameter to any page URL on this site:

    /guides/quickstart?ask=how+do+I+authenticate

Optional parameters:

- `&goal=<what-you-are-trying-to-do>` steers the answer toward your
  objective (e.g. `&goal=write+a+python+client`).
- `&version=<label>` scopes the answer to a mounted version when the
  portal publishes more than one.

The response is `text/markdown`: the answer followed by a `# Sources` list
of the portal pages it was grounded in. Status codes are the contract:

- `200` — the answer; `402` — the portal owner’s plan or answer credits are
  exhausted (surface this to your operator; do NOT retry); `429` — you are
  rate-limited; back off for the `Retry-After` seconds; `503` — the answer
  lane is temporarily unavailable; fall back to crawling the `.md` pages.

For the full corpus map read `llms.txt` at the site root; for the tool
surface (search + page fetch as MCP tools) see `/mcp`.