◆ VECTOR DB RAG

Weaviate

v1.38.13 open-source

Weaviate is an open-source vector database that stores both objects and vectors, allowing for the combination of vector search with structured filtering with the fault tolerance and scalability of a cloud-native database.

source ↗ website ↗ rss ↗ last repo push Aug 24, 2026

from weaviate.classes.config import Configure

client.collections.create(
    "Doc",
    vector_config=Configure.Vectors.text2vec_weaviate(
        name="default",
        source_properties=["title", "body"],
        vector_index_config=Configure.VectorIndex.hnsw(
            quantizer=Configure.VectorIndex.Quantizer.rq(
                bits=4,
                rescore_limit=20,
            ),
        ),
    ),
)
from datetime import timedelta
from weaviate.classes.query import Boost, Filter

prefer_in_stock_and_recent = Boost.blend(
    [
        Boost.filter(Filter.by_property("in_stock").equal(True), weight=2.0),
        Boost.time_decay("released", scale=timedelta(days=30)),
    ],
    weight=0.3,
    depth=200,
)

response = collection.query.hybrid(
    query="wireless headphones",
    limit=4,
    boost=prefer_in_stock_and_recent,
)
curl -X POST http://localhost:8080/v1/backups/s3 \
  -H 'Content-Type: application/json' \
  -d '{"id": "my-backup", "includeRoles": true}'
curl -X POST 'http://localhost:8080/v1/search/Articles/near-text' \
  -H 'Content-Type: application/json' \
  -d '{"query": "quantum computing breakthroughs", "limit": 5}'
curl -X POST 'http://localhost:8080/v1/search/Articles/near-text' \
  -H 'Content-Type: application/json' \
  -d '{"query": "climate change", "limit": 5}'
curl -X POST 'http://localhost:8080/grpc-web' \
  -H 'Content-Type: application/grpc-web+proto' \
  -H 'X-Grpc-Web: 1' \
  --data-binary @request.bin
DEFAULT_SHARDING_COUNT=3 ./weaviate --config-file /etc/weaviate/config.yaml
POST /v1/backups/s3
{
  "id": "nightly-2025-07-15",
  "include": ["Product*", "Order*"]
}
curl -s http://<weaviate-host>:8080/debug/config | jq .
curl http://localhost:8080/debug/config
curl -X POST 'http://localhost:8080/v1/schema' -H 'Content-Type: application/json' -d '{"class": "Article", "vectorizer": "text2vec-cohere", "moduleConfig": {"text2vec-cohere": {"dimensions": 256}}}'
{
  "where": {
    "operator": "ContainsNone",
    "path": ["tags"],
    "valueTextArray": ["spam", "draft", "archived"]
  }
}
curl -X POST http://localhost:8080/v1/aliases \
  -H 'Content-Type: application/json' \
  -d '{"alias": "CurrentProducts", "collection": "Products_v2"}'
curl -X GET 'http://localhost:8080/v1/replication/replicate/{id}' \
  -H 'Authorization: Bearer <token>'
curl -X DELETE 'http://localhost:8080/v1/replications/replicate' \
  -H 'Authorization: Bearer <token>' \
  -H 'Content-Type: application/json'
curl -X POST http://localhost:8080/v1/schema \
  -H 'Content-Type: application/json' \
  -d '{
    "class": "Document",
    "vectorizer": "text2vec-nvidia"
  }'
{
  "class": "Product",
  "properties": [
    {
      "name": "price",
      "dataType": ["number"],
      "indexRangeFilters": true
    }
  ]
}
{
  Get {
    Article(
      nearText: {
        concepts: ["climate change"],
        targets: { combinationMethod: minimum, targetVectors: ["title", "body"] }
      }
    ) {
      title
      body
    }
  }
}
curl -s http://localhost:8080/v1/cluster/statistics | jq .
VOYAGEAI_APIKEY=your-key docker compose up
curl -s http://localhost:8080/v1/schema/MyCollection/shards | jq '.[].vectorQueueSize'
{
  Get {
    Article(
      where: {
        path: ["tags"],
        operator: ContainsAny,
        valueText: ["cybersecurity", "threat", "vulnerability"]
      }
    ) {
      title
      tags
    }
  }
}
curl -X POST http://localhost:8080/v1/schema \
  -H 'Content-Type: application/json' \
  -d '{"class": "Document", "multiTenancyConfig": {"enabled": true}}'

curl -X POST http://localhost:8080/v1/schema/Document/tenants \
  -H 'Content-Type: application/json' \
  -d '[{"name": "tenant-acme"}, {"name": "tenant-globex"}]'
curl http://localhost:8080/v1/schema/Document/tenants
{
  Get {
    Article(
      bm25: { query: "vector database" }
      where: { path: ["published"], operator: Equal, valueBoolean: true }
    ) {
      title
      _additional { score }
    }
  }
}
curl -X POST 'http://localhost:8080/v1/schema' \
  -H 'Content-Type: application/json' \
  -d '{"class": "MyClass", "vectorIndexConfig": {"distance": "l2-squared"}}'
{
  Get {
    Article(
      where: {
        path: ["_creationTimeUnix"]
        operator: GreaterThan
        valueString: "1672531200000"
      }
    ) {
      title
    }
  }
}
{
  Aggregate {
    Article(
      nearText: {
        concepts: ["machine learning"]
        certainty: 0.75
      }
    ) {
      meta { count }
      category { groupedBy { value } count }
    }
  }
}
curl -s -o /dev/null -w "%{http_code}" -X HEAD http://localhost:8080/v1/objects/<id>
{
  "class": "Article",
  "vectorIndexConfig": {
    "dynamicEfMin": 100,
    "dynamicEfMax": 500,
    "dynamicEfFactor": 8
  }
}
curl -X POST http://localhost:8080/v1/schema -H 'Content-Type: application/json' -d '{
  "class": "ClipExample",
  "vectorizer": "multi2vec-clip",
  "vectorIndexType": "hnsw",
  "moduleConfig": {
    "multi2vec-clip": {
      "imageFields": ["image"],
      "textFields": ["name"],
      "weights": {
        "textFields": [0.7],
        "imageFields": [0.3]
      }
    }
  },
  "properties": [
    {"dataType": ["string"], "name": "name"},
    {"dataType": ["blob"], "name": "image"}
  ]
}'
curl 'http://localhost:8080/v1/objects?limit=25&offset=75'
CLUSTER_HOSTNAME=node1 docker-compose up -d
{
  Get {
    Post(nearText: { concepts: "missspelled text" }) {
      content
      _additional {
        spellCheck {
          changes { corrected original }
          didYouMean
          location
          originalText
        }
      }
    }
  }
}
{
  Get {
    Post {
      content
      _additional {
        tokens(
          properties: ["content"],
          limit: 10,
          certainty: 0.8
        ) {
          certainty
          endPosition
          entity
          property
          startPosition
          word
        }
      }
    }
  }
}
curl -X POST http://localhost:8080/v1/classficiations \
  -H 'Content-Type: application/json' \
  -d '{
    "class": "Article",
    "type": "zeroshot",
    "classifyProperties": ["ofCategory"],
    "sourceWhere": { "operator": "IsNull", "path": ["ofCategory"], "valueBoolean": true },
    "targetWhere": { "operator": "Equal", "path": ["active"], "valueBoolean": true }
  }'
{
  Get {
    MyImage(nearImage: {
      image: "/9j/4AAQSkZJRgABAgE..."
      certainty: 0.7
    }) {
      image
    }
  }
}
{
  "class": "Article",
  "vectorIndexConfig": {
    "skip": false,
    "ef": 100,
    "efConstruction": 128,
    "maxConnections": 64
  }
}
{
  Get {
    Paragraph(
      ask: {
        question: "what is the population of Berlin?"
        certainty: 0.8
      }
    ) {
      _additional { answer { hasAnswer result certainty property startPosition endPosition } }
      text
    }
  }
}
{
  "class": "Article",
  "moduleConfig": {
    "text2vec-transformers": {
      "poolingStrategy": "cls"
    }
  }
}
{
  Get{
    Publication(
      nearObject: {
        id: "27b5213d-e152-4fea-bd63-2063d529024d",
        certainty: 0.7
      }
    ){
      name
      _additional {
        certainty
      }
    }
  }
}
AUTHENTICATION_OIDC_ENABLED=true
AUTHENTICATION_OIDC_ISSUER=https://myissuer.com
AUTHENTICATION_OIDC_CLIENT_ID=my-client-id
AUTHENTICATION_OIDC_USERNAME_CLAIM=email
AUTHENTICATION_OIDC_GROUPS_CLAIM=groups
AUTHORIZATION_ADMINLIST_ENABLED=true
[email protected],[email protected]
[email protected],[email protected]
ORIGIN=https://my-weaviate-deployment.com
CONFIGURATION_STORAGE_URL=http://etcd:2379
CONTEXTIONARY_URL=http://contextionary
ESVECTOR_URL=http://esvector:9200
ENABLE_COMPOUND_SPLITTING=true
{
  Get {
    Article(limit: 100) {
      title
      _featureProjection(dimensions: 3, algorithm: "tsne", perplexity: 5, learningRate: 25, iterations: 100) {
        vector
      }
    }
  }
}
curl -X GET 'http://localhost:8080/v1/things?include=_featureProjection&limit=100'
curl 'https://<weaviate-host>/v1/things/<id>?include=_nearestNeighbors'
type: contextual
informationGainCutoffPercentile: 10
informationGainMaximumBoost: 3
tfidfCutoffPercentile: 80
curl 'http://localhost:8080/v1/things?meta=true'
curl -X POST http://localhost:8080/v1/things \
  -H 'Content-Type: application/json' \
  -d '{
    "class": "Glasses",
    "schema": {
      "description": "These glasses are meant for far-sighted people"
    },
    "vectorWeights": {
      "far": "5 * w",
      "near": "5 * w"
    }
  }'
class: Fruit
vectorizeClassName: false
properties:
- name: name
  dataType: ["string"]
  vectorizePropertyName: false
curl -sf http://weaviate:8080/v1/.well-known/live && echo 'alive'
curl -sf http://weaviate:8080/v1/.well-known/ready && echo 'ready'
curl -X PATCH 'http://localhost:8080/v1/things/<id>' \
  -H 'Content-Type: application/json' \
  -d '{"class": "Article", "schema": {"title": "Updated Title"}}'
curl 'http://localhost:8080/v1/things/Dish/<id>?meta=true'
vector_index:
  denormalizationDepth: 4
curl http://localhost:8080/v1/meta
curl -X POST http://localhost:8080/v1/things \
  -H 'Content-Type: application/json' \
  -d '{"class": "City", "schema": {"inCountry": [{"beacon": "weaviate://localhost/things/<uuid>"}]}}'
curl -X POST http://localhost:8080/things \
  -H 'Content-Type: application/json' \
  -d '{"id": "a7e10b51-1f3e-4f5a-8d2e-000000000001", "class": "Article", "schema": {"title": "Example"}}'

Summary

Weaviate is an open-source vector database that stores objects and vectors, enabling semantic search at scale by combining vector similarity search with keyword filtering, RAG, and reranking. It can be deployed via Docker, Kubernetes, or as a managed service. This tool is for developers building applications requiring semantic search, such as chatbots or recommendation engines. Its documentation positions it alongside other vector stores. Weaviate features options for automatic vectorization using integrated models or direct import of pre-computed embeddings, and it supports production needs like multi-tenancy and RBAC.

What Weaviate answers

What methods can I use to provide the initial embeddings for my data?

I can either use integrated models for automatic vectorization during import or I can directly import pre-computed vector embeddings.

What security controls are built into the deployment?

The database includes built-in support for multi-tenancy, replication, and role-based access control.

How do I connect my application to the database?

I can deploy the service using Docker, Kubernetes, or by utilizing the managed Weaviate Cloud service.

Does the system handle different types of search together?

It combines vector similarity search with keyword filtering, RAG, and reranking within one query interface.

Can I make this available to different groups of users?

It supports built-in role-based access control authorization.

Are there options to manage different datasets for different teams?

The platform includes built-in multi-tenancy support.

Command line

composed command

option surface across analysed releases

options at that release added, per release removed, per release

option	found in	since	description

Values are placeholders taken from each option’s declared default. Nothing is executed here — the output shown is a recording of a run that already happened.

Release history

v1.38.13 Aug 27, 2026 · issue 009

Weaviate v1.38.13 adds a DigitalOcean generative module and export/import API endpoints for database user API-key hashes.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.13 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.13
```
- ›Adds export and import API endpoints for database user API-key hashes, enabling backup and migration of user credentials.
- ›Adds a DigitalOcean generative module, extending the set of supported generative AI providers.
- ›MCP server now runs in stateless streamable mode and correctly refuses GET requests with HTTP 405.
v1.37.15 Aug 27, 2026 · issue 009

Weaviate v1.37.15 adds TwelveLabs Marengo multimodal vectorizer, DigitalOcean generative module, cross-property AND matching in BM25, and parallelized rescoring.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.37.15 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.37.15
```
- ›Adds generative-digitalocean module for using DigitalOcean's generative AI models as a Weaviate generative backend.
- ›Adds cross-property AND matching in BM25 search, allowing terms to be required across multiple properties simultaneously.
- ›Adds per-query concurrency budget enforcement in HNSW compressed rescore via feat(hnsw): respect per-query concurrency budget in compressed rescore.
- ›Parallelizes HNSW Muvera late-interaction rescoring for improved throughput on multi-vector workloads.
- ›Parallelizes BM25 block term creation across properties, reducing indexing latency at scale.
+6 moreshow less
- ›Parallelizes hfresh rescoring with budget-aware workers and pooled buffer reads for fresh-index queries.
- ›Adds MUVERA-specific usage calculations for accurate billing and resource tracking on multi-vector collections.
- ›Allocates per-tenant vector cache memory lazily and proportionally to tenant size, reducing idle memory overhead in multi-tenant deployments.
- ›Warms the hfresh version map in the background at startup, reducing cold-start latency for fresh-index queries.
- ›Adds targeted replace scan with newest-wins visibility in lsmkv, improving read performance on frequently updated keys.
- ›Registers disable_dimension_metrics as a runtime override, allowing it to be toggled without a restart.
launch-20260827-aef6df4a Aug 27, 2026 · issue 009

Weaviate 1.39 adds Boost API GA, MMR GA, 4-bit RQ preview, and an experimental Search REST API with five new endpoints.
└──▷ USE IT
Create an HNSW collection with 4-bit Rotational Quantization to cut vector storage to ~1/8th of raw float32 size.
python
```
from weaviate.classes.config import Configure

client.collections.create(
    "Doc",
    vector_config=Configure.Vectors.text2vec_weaviate(
        name="default",
        source_properties=["title", "body"],
        vector_index_config=Configure.VectorIndex.hnsw(
            quantizer=Configure.VectorIndex.Quantizer.rq(
                bits=4,
                rescore_limit=20,
            ),
        ),
    ),
)
```
Use the Boost API on a hybrid search to prefer in-stock and recently released products without removing out-of-stock results.
python
```
from datetime import timedelta
from weaviate.classes.query import Boost, Filter

prefer_in_stock_and_recent = Boost.blend(
    [
        Boost.filter(Filter.by_property("in_stock").equal(True), weight=2.0),
        Boost.time_decay("released", scale=timedelta(days=30)),
    ],
    weight=0.3,
    depth=200,
)

response = collection.query.hybrid(
    query="wireless headphones",
    limit=4,
    boost=prefer_in_stock_and_recent,
)
```
- ›Adds experimental Search REST API with five endpoints — POST /v1/search/{collection}/near-text, POST /v1/search/{collection}/bm25, POST /v1/search/{collection}/hybrid, POST /v1/search/{collection}/near-object, and POST /v1/aggregate/{collection} — enabled per node via the EXPERIMENTAL_REST_SEARCH_ENABLED environment variable (accepted values: on, enabled, 1, true); routes return 422 when the feature is off.
- ›Promotes the Boost API to general availability, supporting query-time rescoring on hybrid, bm25, near_text, near_vector, near_object, near_media, and near_image in both .query.* and .generate.* namespaces; configurable via Boost.blend(), Boost.filter(), Boost.time_decay(), and Boost.numeric_decay() with weight (default 0.5), per-condition weight (default 1.0), and depth (default 100) parameters.
- ›Adds QUERY_BOOST_DEFAULT_DEPTH environment variable to set the cluster-wide default candidate depth for Boost rescoring.
- ›Promotes MMR (Maximal Marginal Relevance) diversity selection to general availability, now available on collection.query.hybrid and collection.generate.hybrid (requires Python client 4.23.0+); configured via Diversity.mmr(limit=<int>, balance=<float>) where balance ranges from 0.0 (pure diversity) to 1.0 (pure relevance), defaulting to 0.0.
- ›Adds 4-bit Rotational Quantization as a preview HNSW-only feature, configured via rq(bits=4, rescore_limit=<int>) in Configure.VectorIndex.Quantizer; delivers approximately 7.84x size reduction at 1536 dimensions (784 bytes vs 6144 bytes for raw float32).
+2 moreshow less
- ›Adds DEFAULT_QUANTIZATION=rq-4 environment variable to set 4-bit RQ with rescoreLimit of 20 as the cluster-wide default for new HNSW vector indexes.
- ›Reworks HNSW snapshots to reduce commit-log disk usage and speed up node startup (now generally available).

v1.39.2 Aug 26, 2026 · issue 009

└──▷ GET THIS VERSION

$ git clone --branch v1.39.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.39.2

›New generative-digitalocean module adds DigitalOcean as a generative AI provider.

v1.39.1 Aug 25, 2026 · issue 007

Weaviate v1.39.1 adds new REST Search API endpoints, backup role inclusion, GCS gRPC transport, and auto-schema named vector defaults.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.39.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.39.1
```
- ›Adds includeRoles parameter to the backup/restore process to include role definitions in backups.
- ›Adds BM25 keyword search REST endpoint (POST /v1/search/bm25 or equivalent REST Search API 1/4).
- ›Adds hybrid search REST endpoint (REST Search API 2/4).
- ›Adds near-object search REST endpoint (REST Search API 3/4).
- ›Adds aggregate counts REST endpoint (REST Search API 4/4).
+5 moreshow less
- ›Adds opt-in gRPC transport for the backup-gcs backend.
- ›Introduces RUNTIME_REINDEX_ENABLED kill-switch environment variable (off by default).
- ›Auto-schema now creates a default named vector instead of a legacy vector when inferring schema.
- ›Adds MUVERA-specific usage calculations for multi-vector index accounting.
- ›Resumes interrupted vector-index drop operations from the recorded pending set, improving reliability of drop-vector-index across restarts.
1.39.0 Aug 24, 2026 · issue 006

API surface changed: +4 endpoints, 1 modified
API CHANGE
API surface changed: +4 endpoints, 1 modified
- + POST /aggregate/{collection}
- + POST /search/{collection}/bm25
- + POST /search/{collection}/hybrid
- + POST /search/{collection}/near-object
- ~ POST /schema/{className}/properties/{propertyName}/index/{indexName}/cancel: response schema changed
- ›New endpoint POST /aggregate/{collection}
- ›New endpoint POST /search/{collection}/bm25
- ›New endpoint POST /search/{collection}/hybrid
- ›New endpoint POST /search/{collection}/near-object
- ›POST /schema/{className}/properties/{propertyName}/index/{indexName}/cancel: response schema changed
1.39.0 Aug 20, 2026 · issue 002

Weaviate now publishes an API — 119 endpoints across 20 areas: Schema, Objects, Authz, …
- ›Schema (26 endpoints) — Operations related to managing collections.
- ›Objects (19 endpoints) — Operations for managing individual data objects.
- ›Authz (18 endpoints) — Endpoints for managing Weaviate's Role-Based Access Control (RBAC) system.
- ›Replication (10 endpoints) — Operations related to managing data replication, including initiating and monitoring shard replica movements between nodes, querying current sharding states, and managing the lifecycle of replication tasks.
- ›Users (8 endpoints) — Endpoints for user account management in Weaviate.
+4 moreshow less
- ›Backups (7 endpoints) — Operations related to creating and managing backups of Weaviate data.
- ›Namespaces (7 endpoints) — Operations for managing cluster-level namespaces.
- ›Batch (3 endpoints) — Operations for performing actions on multiple data items (objects or references) in a single API request.
- ›12 more areas: Export, Mcp, Well Known, Classifications, Graphql, Nodes, Cluster, Distributedtasks, Meta, Root, Search, Tokenize
v1.38.10 Aug 18, 2026 · issue -001

Weaviate v1.38.10 adds REST Search API endpoints for BM25, hybrid, near-object, and aggregate-counts queries, plus includeRoles in backup/restore and opt-in gRPC transport for GCS backups.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.10 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.10
```
└──▷ TRY IT
Back up a Weaviate collection and include RBAC role definitions so they are restored alongside the data.
```
$ curl -X POST http://localhost:8080/v1/backups/s3 \
  -H 'Content-Type: application/json' \
  -d '{"id": "my-backup", "includeRoles": true}'
```
- ›Adds includeRoles parameter to the backup and restore process, enabling role definitions to be captured and replayed alongside data.
- ›Adds opt-in gRPC transport for the backup-gcs module, available as a new configuration option on the GCS backup provider.
- ›Adds a BM25 keyword search REST endpoint as part of the new REST Search API (feat(rest): bm25 keyword search endpoint).
- ›Adds a hybrid search REST endpoint as part of the new REST Search API (feat(rest): hybrid search endpoint).
- ›Adds a near-object search REST endpoint as part of the new REST Search API (feat(rest): near-object search endpoint).
+1 moreshow less
- ›Adds an aggregate counts REST endpoint as part of the new REST Search API (feat(rest): aggregate counts endpoint).
v1.38.10 Aug 18, 2026 · issue 002

Weaviate v1.38.10 adds REST Search API endpoints for BM25, hybrid, near-object, and aggregate searches, plus includeRoles in backup/restore and opt-in gRPC transport for GCS backups.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.10 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.10
```
- ›Adds includeRoles option to the backup and restore process, enabling role definitions to be captured and replayed with a backup.
- ›Adds opt-in gRPC transport for the backup-gcs module, improving throughput for GCS-backed backups.
- ›Adds REST BM25 keyword search endpoint (REST Search API 1/4), exposing a dedicated REST surface for keyword search.
- ›Adds REST hybrid search endpoint (REST Search API 2/4), exposing a dedicated REST surface for hybrid (vector + keyword) search.
- ›Adds REST near-object search endpoint (REST Search API 3/4), exposing a dedicated REST surface for vector similarity search by object reference.
+1 moreshow less
- ›Adds REST aggregate counts endpoint (REST Search API 4/4), exposing a dedicated REST surface for aggregate count queries.
v1.38.9 Aug 6, 2026 · issue -013

Weaviate v1.38.9 adds TwelveLabs Marengo multimodal vectorizer and a kill switch for runtime reindexing.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.9 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.9
```
- ›Adds RUNTIME_REINDEX_ENABLED environment variable as a kill switch for runtime reindexing (off by default).
- ›Adds multi2vec-twelvelabs vectorizer module integrating the TwelveLabs Marengo multimodal embedding model.
- ›Parallelizes HNSW Muvera late-interaction rescoring and budget-aware rescore workers, unlocking higher-throughput ANN search at scale.
- ›Parallelizes BM25 block term creation across properties, improving indexing performance for multi-property collections.
v1.38.9 Aug 6, 2026 · issue 002

Weaviate v1.38.9 adds TwelveLabs Marengo multimodal vectorizer and a per-query concurrency budget for compressed HNSW rescoring.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.9 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.9
```
- ›Adds RUNTIME_REINDEX_ENABLED environment variable kill switch (off by default) to control runtime reindexing.
- ›Adds multi2vec-twelvelabs vectorizer module integrating TwelveLabs Marengo for multimodal vectorization.
- ›Adds per-query concurrency budget enforcement in compressed HNSW rescore operations.
- ›Parallelizes BM25 block term creation across properties, unlocking higher indexing throughput.
- ›Parallelizes HNSW Muvera late-interaction rescoring for faster approximate nearest-neighbor queries.
+1 moreshow less
- ›Parallelizes hfresh rescoring with budget-aware workers and pooled buffer reads, improving query performance.
v1.39.0 Aug 4, 2026 · issue -015

Weaviate v1.39.0 adds gRPC-web, REST search, 4-bit RQ, Hybrid MMR, cross-property BM25 AND matching, drop-vector-index, and namespace suspend endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.39.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.39.0
```
└──▷ TRY IT
Run a near-text search against a collection using the new REST search endpoint without a gRPC client.
```
$ curl -X POST 'http://localhost:8080/v1/search/Articles/near-text' \
  -H 'Content-Type: application/json' \
  -d '{"query": "quantum computing breakthroughs", "limit": 5}'
```
- ›Adds POST /v1/search/{collection}/near-text REST endpoint for near-text search queries, with responses enveloped as {id, properties, references, metadata} and camelCase payload fields with a nested rerank object.
- ›Introduces /grpc-web endpoint, enabling gRPC-web protocol access to Weaviate.
- ›Adds GA resource-oriented index endpoints for the Alter Schema reindex feature (v1.39 RFC rework).
- ›Adds namespace suspend endpoints, RAFT state management, and DB-user status checks for namespace lifecycle control on shared clusters.
- ›Returns the first letters of API keys to admins on namespaced clusters.
+9 moreshow less
- ›Adds namespace graduation via backup/restore.
- ›Adds namespace-local roles for per-namespace RBAC isolation.
- ›Introduces drop-vector-index capability: supports removing a vector index from an existing collection property to reclaim disk space, with RBAC integration, multi-tenancy support, and cold-tenant completion.
- ›Adds cross-property AND matching in BM25 search, allowing queries to require term matches across multiple properties simultaneously.
- ›Adds 4-bit Rotational Quantization (RQ4) with improved SIMD vector search performance.
- ›Adds Maximal Marginal Relevance (MMR) support in Hybrid queries for result diversity.
- ›Adds soft-ranking Boost API with missing-property handling and property-type validation.
- ›Parallelizes block term creation across properties in BM25, improving indexing throughput.
- ›Multiple BM25/BlockMax WAND performance optimizations: faster varint decoding, reduced hot-path allocations, tiered merged filter, approximate IDF object count, and deferred tombstone checks.
v1.39.0 Aug 4, 2026 · issue 002

Weaviate v1.39 adds gRPC-web, REST search, BM25 cross-property AND, 4-bit RQ, MMR hybrid, and namespace suspend endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.39.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.39.0
```
└──▷ TRY IT
Run a near-text search against a collection using the new REST search endpoint, filtering and retrieving structured metadata.
```
$ curl -X POST 'http://localhost:8080/v1/search/Articles/near-text' \
  -H 'Content-Type: application/json' \
  -d '{"query": "climate change", "limit": 5}'
```
Enable gRPC-web clients (e.g. browser-based) to connect to Weaviate by targeting the new gRPC-web endpoint.
```
$ curl -X POST 'http://localhost:8080/grpc-web' \
  -H 'Content-Type: application/grpc-web+proto' \
  -H 'X-Grpc-Web: 1' \
  --data-binary @request.bin
```
- ›Introduces POST /v1/search/{collection}/near-text REST endpoint for near-text search queries, with response envelope containing id, properties, references, and metadata fields and camelCase payload fields.
- ›Introduces /grpc-web endpoint, enabling gRPC-web protocol access to the Weaviate API.
- ›Adds 4-bit Rotational Quantization (RQ4) with improved SIMD vector search performance.
- ›Adds namespace suspend endpoints to the control plane for suspending namespaced tenants, including RAFT state suspension and DB User status checks.
- ›Adds support for cross-property AND matching in BM25 search.
+8 moreshow less
- ›Adds Maximal Marginal Relevance (MMR) support in Hybrid queries for diversity-aware result ranking.
- ›Adds GA resource-oriented index endpoints for the Alter Schema reindex API (v1.39 RFC rework).
- ›Adds drop-vector-index capability (preview): removes inverted/vector indices from existing properties to reclaim disk space, with RBAC integration, multi-tenancy support, and cold-tenant completion.
- ›Returns first letters of API keys to admins on namespaced clusters.
- ›Adds namespace local roles, allowing per-namespace RBAC role scoping.
- ›Adds namespace graduation via backup/restore workflow.
- ›Adds gate to disallow global non-operator users and denies operator-only surfaces to namespaced users.
- ›Delivers multiple BM25/BlockMax WAND hot-path performance improvements including parallelized block term creation, tiered merged filters, approximate IDF object counts, and tombstone/filter probe optimizations.
v1.38.8 Jul 29, 2026 · issue -021

Weaviate v1.38.8 adds cross-property AND matching in BM25, new S3 auth broker credentials, and a runtime-overridable batched Contains gate.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.8 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.8
```
- ›Adds feat(backup-s3) new auth broker credentials for the S3 backup module, enabling alternative credential flows beyond static keys.
- ›Adds a runtime-overridable feature gate to opt into batched ContainsAny/ContainsAll/ContainsNone resolution via the config, inverted layer.
- ›Adds cross-property AND matching support in BM25 search, allowing BM25 queries to require match terms across multiple properties simultaneously.
- ›Exposes the first letters of API keys to admins on namespaced clusters, improving key identification without revealing secrets.
- ›Adds nested object filtering support to the usage module.
v1.38.8 Jul 29, 2026 · issue 002

Weaviate v1.38.8 adds cross-property AND matching in BM25, new S3 auth broker credentials, and nested object filtering in the usage module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.8 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.8
```
- ›Adds a runtime-overridable feature gate to enable batched Contains (opt-in) for inverted-index queries via a config/runtime override.
- ›Adds cross-property AND matching support in BM25 search, expanding keyword-search relevance control.
- ›Introduces new auth broker credentials for the S3 backup module (backup-s3), enabling additional authentication methods.
- ›Returns the first letters of API keys to admins on namespaced clusters, improving key auditability.
- ›Adds nested object filtering support to the usage module.
└──▷ BREAKING ON UPGRADE
- !Support for restoring old backup formats has been removed; backups created in legacy formats can no longer be restored.
v1.37.14 Jul 27, 2026 · issue -023

Weaviate v1.37.14 adds unified background-process metrics, persistent cluster identity, and configurable incremental-backup deduplication.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.37.14 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.37.14
```
- ›Makes the number of files deduplicated in incremental backups configurable.
- ›Adds unified background-process activity and duration metrics via feat(monitoring) instrumentation.
- ›Adds persistent cluster and node identity for correlatable telemetry across restarts.
- ›Replaces the per-tick due-scan in the cycle manager with a due-heap scheduler, reducing CPU overhead.
v1.37.14 Jul 27, 2026 · issue 002

Weaviate v1.37.14 adds unified background-process metrics, persistent cluster identity, and configurable incremental backup deduplication.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.37.14 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.37.14
```
- ›Makes the number of files deduplicated in incremental backups configurable.
- ›Adds unified background-process activity and duration metrics via feat(monitoring) instrumentation.
- ›Adds persistent cluster and node identity for correlatable telemetry across restarts.
- ›Replaces per-tick due-scan with a due-heap scheduler in cyclemanager for more efficient background task dispatch.
- ›Improves segment index performance using a van Emde Boas layout.
v1.38.5 Jul 16, 2026 · issue -034

Weaviate v1.38.5 adds a structured where-filter to the MCP hybrid search tool and warns when usage collection cycles overlap.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.5
```
- ›Exposes a structured where-filter on the MCP hybrid search tool, enabling filtered hybrid search through the MCP interface.
- ›Adds a warning when usage collection cycles overlap the configured collection interval, surfacing capacity issues in usage accounting.
v1.38.3 Jul 10, 2026 · issue -040

Weaviate v1.38.3 adds a /grpc-web endpoint, a runtime GraphQL toggle, hard-link replica movement, and namespace-local RBAC roles.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.3
```
- ›Introduces the /grpc-web endpoint, enabling gRPC-Web protocol support for browser and proxy-constrained clients.
- ›Adds a runtime toggle for the GraphQL API, allowing operators to enable or disable the GraphQL surface without restarting the node.
- ›Adds namespace-local roles, scoping RBAC role definitions to individual namespaces rather than globally.
- ›Adds a gate to disallow global non-operator users, restricting operator-only surfaces from namespaced users.
- ›Supports automaxprocs for automatic GOMAXPROCS tuning via cgroup v2, improving CPU scheduling in containerized deployments.
+4 moreshow less
- ›Propagates raw on-disk object bytes in async replication, reducing serialization overhead during replica sync.
- ›Uses batched hashtree-root pre-filtering for many-tenant clusters in async replication, reducing per-hashBeat overhead.
- ›Increases the hfresh searchProbe default to 256, improving recall for hybrid-fresh index queries.
- ›Optimizes the cycle manager for large multi-tenant collections, reducing overhead when managing many tenants.
v1.38.2 Jun 25, 2026 · issue -055

Weaviate v1.38.2 adds generative-deepseek module, location/endpoint/dimensions settings for Google, OpenAI, and AWS modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.2
```
- ›Adds generative-deepseek module with support for a stop setting in module settings.
- ›Adds location configuration setting to the text2vec-google module.
- ›Adds location setting support to the generative-google module.
- ›Adds endpoint setting support in the OpenAI client module.
- ›Adds dimensions setting support to the text2vec-aws module.
+2 moreshow less
- ›Validates X-*-BaseURL request headers across modules to close an SSRF bypass vector.
- ›Increases the default searchProbe value to 256 for improved hfresh search behavior.
v1.37.10 Jun 24, 2026 · issue -056

Weaviate v1.37.10 adds generative-deepseek module, OpenAI endpoint setting, Google location support, and AWS dimensions setting.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.37.10 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.37.10
```
- ›Adds generative-deepseek module with support for a stop setting in module settings.
- ›Adds endpoint setting to the OpenAI client module configuration.
- ›Adds location setting to the generative-google module.
- ›Adds location configuration to the text2vec-google module.
- ›Adds dimensions setting to the text2vec-aws module.
+2 moreshow less
- ›Validates X-*-BaseURL request headers to close an SSRF bypass vector in modules.
- ›Increases the searchProbe default to 256 for hfresh vector index searches.
v1.36.19 Jun 24, 2026 · issue -056

Weaviate v1.36.19 adds the generative-deepseek module, location and endpoint settings for Google/OpenAI/AWS modules, and SSRF header validation.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.36.19 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.36.19
```
- ›Adds generative-deepseek module with support for a stop setting in module configuration.
- ›Adds location configuration setting to the text2vec-google module.
- ›Adds location setting support to the generative-google module.
- ›Adds endpoint setting support in the OpenAI client module configuration.
- ›Adds dimensions setting support in the text2vec-aws module.
+1 moreshow less
- ›Validates X-*-BaseURL request headers in modules to close an SSRF bypass vector.
v1.38.0 Jun 5, 2026 · issue -075

Weaviate v1.38 adds Namespaces (Preview), Nested Object Filtering (Preview), Runtime Property Reindex (Preview), and promotes HFresh to GA.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.38.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.38.0
```
- ›Introduces Namespaces (Preview) — control-plane and data isolation between users on a shared cluster, with RBAC/OIDC wiring, per-namespace collection limits, object limits, cascading delete, user management, alias endpoints, and audit log entries.
- ›Adds Nested Object Filtering (Preview) — enables search and filtering within indexed JSON properties, supporting IsNull, positional arr[N] filtering, Contains* operators, correlated AND resolution, scope-aware NOT, and gRPC + GraphQL ingress for nested filter paths.
- ›Adds Runtime Property Reindex (Preview) — allows changing a property's index type at runtime without recreating the collection, with two-phase RAFT swap barrier for semantic migrations and graceful-restart resilience for in-flight reindex units.
- ›Promotes HFresh index to GA, with asymmetric distance computation, query-vector normalization before rescoring, and reduced posting-map memory usage.
v1.37.5 May 26, 2026 · issue -085

Weaviate v1.37.5 adds a DigitalOcean text embedding module, named vector support in the default vector index, and vector index compression allow-lists.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.37.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.37.5
```
- ›Adds text2vec-digitalocean module for generating text embeddings via DigitalOcean's embedding service.
- ›Supports named vectors in the default vector index, enabling multi-vector configurations without specifying a custom index per vector.
- ›Adds allow-lists for vector index compression, giving operators fine-grained control over which vectors are subject to compression.
- ›Adds validation for reserved property name suffixes in schema definitions, preventing naming conflicts at collection creation time.
v1.36.15 May 22, 2026 · issue -089

Weaviate v1.36.15 adds a new text2vec-digitalocean vectorization module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.36.15 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.36.15
```
- ›Adds text2vec-digitalocean module, enabling DigitalOcean-hosted embedding models as a vectorization source.
v1.35.21 May 21, 2026 · issue -090

Weaviate v1.35.21 adds a new text2vec-digitalocean vectorization module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.35.21 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.35.21
```
- ›Adds the text2vec-digitalocean module, enabling vectorization of text using DigitalOcean's embedding models as a new integration.
v1.37.2 Apr 23, 2026 · issue -118

Weaviate v1.37.2 speeds up collection export snapshots and adds asymmetric distance computation to hfresh.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.37.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.37.2
```
- ›Speeds up collection export snapshotting via concurrent tenant de-activation, reducing snapshot time for multi-tenant collections.
- ›Adds asymmetric distance computation to the hfresh index, improving approximate nearest-neighbor search accuracy for quantized vectors.
v1.37.0 Apr 16, 2026 · issue -125

Weaviate v1.37.0 adds a native MCP server, BlobHash property type, collection export, extensible tokenizers, and drop-vector-index support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.37.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.37.0
```
- ›Adds BlobHash property type that automatically stores blob data as hashes, greatly reducing disk space required for blob workloads.
- ›Introduces a native MCP (Model Context Protocol) server interface (preview), enabling AI agents such as Claude and IDEs to natively read and write to Weaviate without custom code, with hybrid search, RAG, and multi-tenancy support out of the box.
- ›Adds collection export to cloud backends (AWS, GCP, Azure) and filesystem with point-in-time exports, multi-node support, concurrent exports, multi-tenancy handling, cancellation, and observability; disabled by default and configured via environment variables including a default path env var.
- ›Adds a tokenizer endpoint and middleware integration for extensible tokenizers (Phase 1), bringing self-serve, multilingual tokenization with accent-insensitive processing options for text properties and custom stopword presets.
- ›Adds experimental support for dropping vector indices from existing collections via an alter-schema endpoint, allowing memory reclamation; endpoint can be disabled via an environment setting.
+7 moreshow less
- ›Adds file-based incremental backups, chunked backup file splits for large collections, backup/restore of INACTIVE tenants, and avoids halting compactions during backup.
- ›Migrates replica internal cluster communication from REST to gRPC for improved performance and security hardening.
- ›Adds Google AI Studio model support and audio support to the multi2vec-google module.
- ›Introduces token source authentication for backups-gcs and usage-gcs modules.
- ›Adds S3 assume-role support for S3-backed storage.
- ›Adds HFresh index preview improvements including an auto category, increased max posting size floor, and continued operation during backups.
- ›Adds validation that async replication is enabled before use, with async replication now production-ready.
v1.35.17 Apr 15, 2026 · issue -126

Weaviate v1.35.17 adds backup/restore for INACTIVE tenants and Google AI Studio API key support in multi2vec-google.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.35.17 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.35.17
```
- ›Adds support for Google AI Studio API key headers in the multi2vec-google module.
- ›Adds baseURL validation support.
- ›Adds support for compactv2 downgrades in HNSW.
- ›Provides a descriptive error on downgrade paths when a module is not available (backward-compatibility improvement).
v1.36.9 Apr 3, 2026 · issue -138

Weaviate v1.36.9 adds on-demand query profiling and implements AUTHENTICATION_OIDC_INSECURE_SKIP_TLS_VERIFY support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.36.9 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.36.9
```
- ›Implements AUTHENTICATION_OIDC_INSECURE_SKIP_TLS_VERIFY environment variable to allow skipping TLS verification for OIDC authentication.
- ›Adds on-demand query profiling support for runtime performance inspection of queries.
v1.35.16 Mar 26, 2026 · issue -146

Weaviate v1.35.16 adds token source authentication for GCS backup and usage integrations.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.35.16 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.35.16
```
- ›Introduces token source authentication support for the backups-gcs and usage-gcs integrations, enabling credential-less auth flows for GCS-backed operations.
v1.34.20 Mar 26, 2026 · issue -146

Weaviate v1.34.20 adds Google AI Studio support, audio vectorization, GCS token-source auth, and a new dimension-metrics control flag.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.34.20 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.34.20
```
- ›Adds DisableDimensionMetrics configuration to control whether dimension metrics are reported.
- ›Introduces token source authentication for the backups-gcs and usage-gcs modules.
- ›Adds audio support to the multi2vec-google module for multimodal vectorization.
- ›Adds support for Google AI Studio models in the multi2vec-google module.
v1.36.6 Mar 19, 2026 · issue -153

Weaviate v1.36.6 adds audio support to multi2vec-google, a DEFAULT_SHARDING_COUNT env var, and a DisableDimensionMetrics config option.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.36.6 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.36.6
```
└──▷ TRY IT
Override the default shard count for all new collections without modifying each schema definition individually.
```
$ DEFAULT_SHARDING_COUNT=3 ./weaviate --config-file /etc/weaviate/config.yaml
```
- ›Adds DEFAULT_SHARDING_COUNT environment variable to override the default shard count at the instance level.
- ›Adds DisableDimensionMetrics configuration option to control whether dimension metrics are reported.
- ›Adds audio modality support to the multi2vec-google module for multimodal vectorization.
- ›Adds IPv6 support for cluster networking.
- ›Enables dynamic lazy loading of shards to improve startup and resource utilization.
v1.35.15 Mar 19, 2026 · issue -153

Weaviate v1.35.15 adds audio support to multi2vec-google, a new DEFAULT_SHARDING_COUNT env var, and a DisableDimensionMetrics config option.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.35.15 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.35.15
```
- ›Adds DEFAULT_SHARDING_COUNT environment variable to override the default shard count at the server level.
- ›Adds DisableDimensionMetrics configuration option to control whether dimension metrics are reported.
- ›Adds audio support to the multi2vec-google module, expanding multimodal vectorization beyond text and images.
- ›Adds support for Google AI Studio models in the multi2vec-google module.
v1.36.5 Mar 12, 2026 · issue -159

Weaviate v1.36.5 adds Google AI Studio model support to the multi2vec-google module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.36.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.36.5
```
- ›Adds Google AI Studio model support to the multi2vec-google module, expanding multimodal vectorization beyond Vertex AI.
v1.36.0 Feb 24, 2026 · issue -174

Weaviate v1.36.0 promotes server-side batching, object TTL, backup restore cancellation, and inverted-index dropping to GA, and brings HFresh vector index into preview.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.36.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.36.0
```
└──▷ TRY IT
Back up only collections matching a wildcard pattern so nightly jobs don't require enumerating every class name.
```
$ POST /v1/backups/s3
{
  "id": "nightly-2025-07-15",
  "include": ["Product*", "Order*"]
}
```
- ›Adds wildcard support for include/exclude class lists in backup configuration, letting operators target collections by pattern.
- ›Introduces a debug abort endpoint for the object TTL subsystem (via PR #10543) to force-stop in-flight TTL deletion cycles.
- ›Exports new backup statuses in the OpenAPI/Swagger spec, enabling typed client integration with in-flight restore state.
- ›Object TTL reaches GA with batch deletions, throttled pause-every-X-batches cadence, Prometheus metrics, inactive-tenant handling, RBAC data delete permission enforcement, and schedule-based enforcement (TTL on a collection is only allowed when a schedule is configured).
- ›Alter Schema gains the ability to drop inverted indices from existing properties, with RBAC integration and multi-tenancy support, reclaiming disk space without recreating collections.
+3 moreshow less
- ›Adds VoyageAI V4 model support to the VoyageAI integration module.
- ›HNSW snapshots are now enabled by default, improving restart performance without manual configuration.
- ›Adds non-blocking segment deletions to reduce latency spikes during LSM compaction.
v1.34.15 Feb 20, 2026 · issue -178

Weaviate v1.34.15 adds a debug endpoint for LSM bucket views, batch logic for text2vec-google, and recursive nested property resolution.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.34.15 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.34.15
```
- ›Adds a debug endpoint for holding consistent views on LSM buckets, aiding low-level storage diagnostics.
- ›Adds naive batch logic to the text2vec-google module, enabling batched embedding requests.
- ›Returns all nested object properties recursively when specified implicitly in a query.
v1.33.17 Feb 20, 2026 · issue -178

Weaviate v1.33.17 adds batch vectorization support in text2vec-google and recursive nested property retrieval.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.17 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.17
```
- ›Adds naive batch logic to the text2vec-google module, enabling batch vectorization requests to Google's text embedding APIs.
- ›Returns all nested object properties recursively when a nested object is specified implicitly in a query.
v1.35.3 Jan 15, 2026 · issue -214

Weaviate v1.35.3 adds video modality support to the multi2vec-voyageai module and exposes backup size on status responses.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.35.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.35.3
```
- ›Adds video modality support to the multi2vec-voyageai module, enabling multimodal embeddings that include video inputs.
- ›Returns backup size in the backup status response, giving operators visibility into backup storage consumption.
v1.34.9 Jan 15, 2026 · issue -214

Weaviate v1.34.9 adds video modality support to the multi2vec-voyageai module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.34.9 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.34.9
```
- ›Adds video modality support to the multi2vec-voyageai module, enabling multimodal vectorization of video content.
v1.33.12 Jan 15, 2026 · issue -214

Weaviate v1.33.12 adds backup size reporting and video modality support for the multi2vec-voyageai module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.12 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.12
```
- ›Adds video modality support to the multi2vec-voyageai module, enabling multimodal embeddings that include video inputs.
- ›Returns backup size in the backup status response, giving operators visibility into backup storage usage.
v1.35.0 Dec 18, 2025 · issue -242

Weaviate v1.35.0 adds object TTL, HFresh vector index, multi2multivec-weaviate module, zstd backup compression, and internal gRPC clustering.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.35.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.35.0
```
- ›Adds Object TTL (Time To Live) support: objects automatically expire based on configurable time-to-live settings, with a dedicated TTL status endpoint, a post-search filter for TTL-based queries, and automatic enabling of index timestamps for creation and update times.
- ›Introduces the multi2multivec-weaviate module, enabling multi-to-multi-vector embeddings using Weaviate as the backend vectorizer.
- ›Adds dimensions setting support to Cohere vectorizer and reranker modules for controlling embedding output size.
- ›Adds BaseURL setting to Cohere's reranker module, enabling routing to custom or self-hosted Cohere-compatible endpoints.
- ›Adds batch API support to the text2vec-google module, reducing latency and API call overhead for large ingestion workloads.
+10 moreshow less
- ›Adds naive batch processing logic across text2vec and multi2vec modules for more efficient vectorization during bulk operations.
- ›Introduces VoyageAI v3.5 models and voyage-3-large support in the VoyageAI vectorizer module.
- ›Adds knowledge setting support to the Contextual AI module integration.
- ›Adds kagome tokenizer per-class user dictionary support for Japanese text processing.
- ›Renames the SPFresh vector index to HFresh, with updated defaults, dedicated merge queue, metadata stored in LSM store, shared bucket architecture, and compressed centroids.
- ›Adds zstd compression support for backups, reducing backup storage footprint.
- ›Makes file chunk size configurable for the file replication service in distributed deployments.
- ›Introduces an internal gRPC server as a REST cluster API equivalent, with connection manager, maintenance mode interceptor, and gzip compression for file copy service.
- ›Introduces Acks sub-message to the BatchStreamReply gRPC message for improved replication acknowledgement signaling.
- ›Adds replication scaling plan with a scale URL that includes collection and replication factor parameters.
v1.33.10 Dec 11, 2025 · issue -249

Weaviate v1.33.10 adds maintenance mode for gRPC and BaseURL support for Cohere's reranker module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.10 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.10
```
- ›Adds BaseURL setting to the Cohere reranker module, enabling use of custom or self-hosted Cohere reranker endpoints.
- ›Adds a maintenance mode interceptor to the gRPC server, allowing the server to reject requests during maintenance windows.
v1.32.22 Dec 11, 2025 · issue -249

Weaviate v1.32.22 adds BaseURL support for Cohere's reranker module and a maintenance mode interceptor for the gRPC server.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.22 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.22
```
- ›Adds BaseURL setting to the Cohere reranker module, allowing practitioners to point the reranker at a custom or self-hosted Cohere endpoint.
- ›Adds a maintenance mode interceptor to the gRPC server, enabling controlled rejection of requests during maintenance windows.
v1.34.2 Nov 30, 2025 · issue -260

Weaviate v1.34.2 adds a /debug/config endpoint to inspect live node configuration and makes file replication chunk size configurable.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.34.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.34.2
```
└──▷ TRY IT
Inspect the live configuration of a running Weaviate node without exposing secrets — useful for auditing settings after a rolling restart.
```
$ curl -s http://<weaviate-host>:8080/debug/config | jq .
```
- ›Adds GET /debug/config endpoint to dump the current node configuration at runtime, with sensitive data automatically omitted.
- ›Makes file chunk size configurable for the file replication service.
- ›Adds support for the knowledge setting in the Contextual AI API module integration.
v1.33.7 Nov 30, 2025 · issue -260

Weaviate v1.33.7 adds a /debug/config endpoint to inspect live node configuration without exposing sensitive data.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.7 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.7
```
└──▷ TRY IT
Inspect the live configuration of a Weaviate node without exposing secrets — useful for debugging misconfigurations in a running cluster.
```
$ curl http://localhost:8080/debug/config
```
- ›Adds GET /debug/config endpoint to dump the running node's configuration at runtime, with sensitive data automatically redacted.
v1.32.19 Nov 29, 2025 · issue -261

Weaviate v1.32.19 adds a /debug/config endpoint to inspect live node configuration without exposing sensitive data.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.19 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.19
```
- ›Adds GET /debug/config endpoint to dump the current node configuration at runtime, with sensitive data automatically redacted.
v1.34.1 Nov 27, 2025 · issue -263

Weaviate v1.34.1 adds VoyageAI v3.5 models, replication scaling, zstd backup compression, and new debug endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.34.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.34.1
```
- ›Adds a replication scaling plan with a dedicated URL endpoint accepting collection and replication factor parameters for dynamic replica management.
- ›Adds a debug endpoint to get and set gomemlimit dynamically at runtime.
- ›Adds a debug endpoint for setting max CPUs dynamically at runtime.
- ›Adds zstd compression support for backups.
- ›Adds Kagome tokenizer per-class user dictionary support.
+6 moreshow less
- ›Introduces VoyageAI v3.5 models in the VoyageAI module.
- ›Adds dimensions setting support in Cohere modules.
- ›Adds batch API support in the text2vec-google module.
- ›Adds naive batch logic for text2vec and multi2vec modules.
- ›Introduces an internal gRPC server as a REST clusterapi equivalent.
- ›Adds retry logic to the usage GCS module during metrics upload.
v1.33.6 Nov 27, 2025 · issue -263

Weaviate v1.33.6 adds zstd backup compression, dynamic memory/CPU debug endpoints, and an internal gRPC cluster server.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.6 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.6
```
- ›Adds debug endpoint to get and set gomemlimit dynamically at runtime without restarting the service.
- ›Adds debug endpoint to set max CPUs dynamically at runtime.
- ›Adds zstd compression for backups, reducing backup storage size.
- ›Introduces an internal gRPC server as the REST clusterapi equivalent for inter-node communication.
- ›Adds naive batch logic for text2vec and multi2vec modules to improve vectorization throughput.
+1 moreshow less
- ›Adds retry logic to the usage GCS module during metrics upload.
v1.32.18 Nov 27, 2025 · issue -263

Weaviate v1.32.18 adds debug endpoints for runtime memory/CPU tuning, zstd backup compression, and naive batch logic for vectorizer modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.18 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.18
```
- ›Adds a debug endpoint to dynamically get and set gomemlimit at runtime without restarting the service.
- ›Adds a debug endpoint to dynamically set the maximum number of CPUs at runtime.
- ›Adds zstd compression support for backups, reducing backup size and transfer time.
- ›Adds naive batch logic for text2vec and multi2vec modules to improve vectorization throughput.
- ›Adds retry logic to the usage GCS module during metrics upload for improved reliability.
v1.33.5 Nov 24, 2025 · issue -266

Weaviate v1.33.5 adds Geo HNSW index config, replication scaling API, VoyageAI v3.5 models, Cohere dimensions setting, and Google batch API support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.5
```
└──▷ TRY IT
Configure a Cohere vectorizer with a specific output dimensions value when creating a class schema.
```
$ curl -X POST 'http://localhost:8080/v1/schema' -H 'Content-Type: application/json' -d '{"class": "Article", "vectorizer": "text2vec-cohere", "moduleConfig": {"text2vec-cohere": {"dimensions": 256}}}'
```
- ›Adds a replication scaling API endpoint accepting collection and replication factor parameters via the updated replication scale URL to trigger replica scaling operations.
- ›Adds dimensions setting support in Cohere vectorizer modules, enabling control over output embedding dimensions.
- ›Adds batch API support in the text2vec-google module for more efficient bulk vectorization.
- ›Adds ability to configure Geo HNSW Index settings, enabling tuning of the HNSW index for geo-type properties.
- ›Introduces VoyageAI's v3.5 models as supported embedding options in the VoyageAI module.
+2 moreshow less
- ›Adds support for Amazon Nova Multimodal Embeddings model in Weaviate modules.
- ›Adds support for the newest Anthropic models in the generative-anthropic module.
v1.32.17 Nov 24, 2025 · issue -266

Weaviate v1.32.17 adds VoyageAI v3.5 models, Amazon Nova Multimodal Embeddings, Geo HNSW config, replication scaling, and Cohere dimensions support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.17 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.17
```
- ›Adds dimensions setting to Cohere modules for controlling embedding output size.
- ›Adds Geo HNSW Index settings configuration, enabling tunable HNSW parameters for geo-indexed collections.
- ›Adds a replication scaling plan API, updated to include collection and replication factor parameters in the scale URL.
- ›Adds support for batch API in the text2vec-google module for higher-throughput vectorization.
- ›Introduces VoyageAI v3.5 models as supported embedding options.
+2 moreshow less
- ›Adds support for Amazon Nova Multimodal Embeddings model in the modules layer.
- ›Adds support for the newest Anthropic models in the generative-anthropic module.
v1.31.20 Nov 21, 2025 · issue -269

Weaviate v1.31.20 adds Geo HNSW index configuration, replication scaling, VoyageAI v3.5 models, Cohere dimensions, and Google batch API support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.20 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.20
```
- ›Adds configurable HNSW index settings for Geo indexes, enabling tuning of the Geo HNSW index via collection configuration.
- ›Introduces a replication scaling plan with a dedicated scale URL that includes collection and replication factor parameters, enabling dynamic replication factor changes.
- ›Adds support for the dimensions setting in Cohere embedding modules, allowing control over output vector dimensionality.
- ›Introduces VoyageAI's v3.5 models as supported embedding options in the VoyageAI module.
- ›Adds batch API support in the text2vec-google module, enabling bulk vectorization requests to the Google embedding API.
+1 moreshow less
- ›Adds support for the newest Anthropic models in the generative-anthropic module.
v1.34.0 Nov 5, 2025 · issue -285

Weaviate v1.34.0 adds SPFresh vector index, Flat Index rotational quantization, server-side dynamic batching, and Contextual AI modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.34.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.34.0
```
- ›Adds spfresh as a new vector index type, supporting custom configs, HNSW centroid indexing, uncompressed vectors, a disk queue, and dynamic posting-size calculation.
- ›Adds rotational quantization (1-bit and 8-bit RQ) support to the Flat Index, with usage metrics for Flat RQ index.
- ›Adds server-side dynamic batching (beta) to reduce client-side batching complexity.
- ›Adds Contextual AI Generative and Reranker module integration.
- ›Adds support for Amazon Nova Multimodal Embeddings model in the embeddings module.
+4 moreshow less
- ›Adds support for newest Anthropic models in the generative-anthropic module.
- ›Adds configurable Geo HNSW Index settings via the geo feature.
- ›Switches the default filter strategy to acorn for improved filtered vector search performance.
- ›Introduces HNSW snapshots v3 for faster snapshot handling.
v1.33.3 Oct 29, 2025 · issue -292

Weaviate v1.33.3 adds Multi-DC support via separate advertise and bind addresses in memberlist-raft networking.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.3
```
- ›Introduces separation between advertise and bind addresses in the memberlist-raft network layer to support Multi-DC deployments.
- ›Allows RQ (rescoring quantization) bits to be exported when using a dynamic index.
v1.32.15 Oct 29, 2025 · issue -292

Weaviate v1.32.15 adds Multi-DC support via separate advertise and bind addresses in memberlist-raft networking.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.15 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.15
```
- ›Introduces separation between advertise and bind addresses in memberlist-raft networking to support Multi Data Center deployments.
- ›Allows Rescoring Quantization (RQ) bits to be exported when using a dynamic index.
v1.33.2 Oct 25, 2025 · issue -296

Weaviate v1.33.2 adds sortable backup listings with size info and GOMEMLIMIT reporting to the usage module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.2
```
- ›Backup list API now supports descending/ascending sort order and returns backup size in results.
- ›Adds GOMEMLIMIT to the usage module payload, exposing Go memory limit data in usage reporting.
v1.32.14 Oct 24, 2025 · issue -297

Weaviate v1.32.14 adds backup list sorting with size reporting and GOMEMLIMIT to usage module payload.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.14 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.14
```
- ›Backup list API now supports ascending/descending sort order and returns backup size per entry.
- ›Adds GOMEMLIMIT to the usage module payload, surfacing Go memory limit data in usage telemetry.
v1.33.1 Oct 17, 2025 · issue -304

Weaviate v1.33.1 adds debug endpoints for shard/lock monitoring, image support in generative-Cohere, slow-query sampling, and a broad new set of internal observability metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.1
```
- ›Adds debug endpoints for shard and lock status monitoring (PR #9402).
- ›Adds image support in the generative-cohere module, enabling multimodal generative queries.
- ›Adds 1% sampled queries to the slow query log for lightweight production query tracing.
- ›Adds new compaction metrics, async replication metrics, LSM WAL recovery metrics, memtable flushing metrics, bucket lifecycle metrics, segment metrics, LSM cursor metrics, and bucket read/write ops metrics to Weaviate's Prometheus-compatible metrics surface.
- ›Sets RoaringSet as the default strategy for the dimensions bucket, improving dimension-tracking efficiency.
+1 moreshow less
- ›Renames the environment variable for fast failure detection to MEMBERLIST_FAST_FAILURE_DETECTION.
v1.31.17 Oct 17, 2025 · issue -304

Weaviate v1.31.17 adds image support in generative-Cohere, new debug endpoints, slow-query sampling, and expanded storage/replication metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.17 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.17
```
- ›Adds debug endpoints for shard and lock status monitoring (feat(debug): add debug endpoints for shard and lock status monitoring).
- ›Adds 1% sampled queries to the slow query log for performance visibility.
- ›Adds image support in the generative-cohere module.
- ›Adds new compaction metrics to Prometheus instrumentation.
- ›Adds async replication metrics.
+7 moreshow less
- ›Adds LSM WAL recovery metrics.
- ›Adds memtable flushing metrics.
- ›Adds bucket lifecycle metrics.
- ›Adds segment metrics.
- ›Adds bucket read/write ops metrics.
- ›Sets RoaringSet as the default strategy for the dimensions bucket.
- ›Defaults RAFT_TIMEOUTS_MULTIPLIER to 5 to better handle heavy-load environments.
v1.32.11 Oct 10, 2025 · issue -311

Weaviate v1.32.11 adds image support in generative-cohere, new debug endpoints, and a broad set of new observability metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.11 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.11
```
- ›Adds debug endpoints for shard and lock status monitoring via feat(debug) additions.
- ›Adds new compaction metrics for LSM storage observability.
- ›Adds async replication metrics for tracking replication health.
- ›Adds LSM WAL recovery metrics.
- ›Adds memtable flushing metrics.
+8 moreshow less
- ›Adds bucket lifecycle metrics.
- ›Adds segment metrics.
- ›Adds LSM cursor metrics.
- ›Adds bucket read/write ops metrics.
- ›Adds image support in the generative-cohere module.
- ›Renames environment variable to MEMBERLIST_FAST_FAILURE_DETECTION for memberlist failure detection configuration.
- ›Sets RoaringSet as the default strategy for the dimensions bucket.
- ›Defaults RAFT_TIMEOUTS_MULTIPLIER to 5 to better handle heavy load environments.
v1.33.0 Sep 25, 2025 · issue -325

Weaviate v1.33.0 adds Collection Aliases (GA), 1-bit RQ compression, ContainsNone/Not filters, and OIDC group management.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.33.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.33.0
```
└──▷ USE IT
Filter out documents that contain any of a set of unwanted values using the new ContainsNone operator.
json
```
{
  "where": {
    "operator": "ContainsNone",
    "path": ["tags"],
    "valueTextArray": ["spam", "draft", "archived"]
  }
}
```
- ›Adds GET /alias endpoint and alias-by-name resolution across objects, batch delete, collection GET, and shard-status operations, with RBAC requiring read=true,collection=* permission for alias lookup.
- ›Supports backup and restore of aliases as part of a collection, including an overwrite_alias flag during restore.
- ›Introduces ContainsNone and Not filter operators for inverted-index queries.
- ›Adds 1-bit Rotational Quantization (rq-1) compression mode alongside the existing 8-bit variant (rq-8), with RQ bit counts now tracked in usage metrics.
- ›Enables API-based vectorizer modules by default, removing the need for explicit opt-in configuration.
+7 moreshow less
- ›Expands vectorizer support to additional property types, and skips vectorizing objects that have only empty property values.
- ›Adds OIDC group claim parsing from string, improving OIDC role group management support.
- ›Switches the default filter strategy to acorn for improved filtered-search performance.
- ›Adds a Weaviate health-check file for liveness/readiness probing.
- ›Introduces experimental server-side batching capability.
- ›Sets a default compression algorithm for vector indexes when none is explicitly configured.
- ›Adds checksum validation to the inverted index format for data integrity.
v1.32.8 Sep 11, 2025 · issue -339

Weaviate v1.32.8 adds reasoningEffort and verbosity params to generative-OpenAI and introduces WAND slow-log tracing.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.8 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.8
```
- ›Adds reasoningEffort and verbosity parameters to the generative-openai module for controlling reasoning depth and output verbosity.
- ›Adds WAND slow-log tracing and context-cancellation support to surface slow query paths.
v1.31.14 Sep 10, 2025 · issue -340

Weaviate v1.31.14 adds reasoningEffort and verbosity params to the generative-openai module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.14 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.14
```
- ›Adds reasoningEffort and verbosity parameters to the generative-openai module for controlling OpenAI reasoning model behavior.
v1.32.6 Sep 5, 2025 · issue -345

Weaviate v1.32.6 adds Amazon Nova model support, a new multi2vec-aws module, a text2vec-morph module, and alias-based GET collection operations.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.6 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.6
```
- ›Adds multi2vec-aws module, enabling multimodal vectorization via AWS.
- ›Adds text2vec-morph module for text vectorization via Morph.
- ›Adds support for Amazon Nova models in the modules layer.
- ›Adds maxTokens support in the generative-aws module.
- ›Supports GET collection operations via alias, expanding alias-based API coverage.
v1.31.13 Sep 3, 2025 · issue -347

Weaviate v1.31.13 adds support for Amazon Nova models in the modules integration.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.13 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.13
```
- ›Adds support for Amazon Nova models in the Weaviate modules integration.
v1.32.4 Aug 19, 2025 · issue -362

Weaviate v1.32.4 adds alias backup support, BlockMax AND BM25 optimization, and text2vec-google dimensions setting.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.4 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.4
```
- ›Supports a dimensions setting for the text2vec-google module, with a default of 768 for the gemini-embedding-001 model.
- ›Adds backup and restore support for collection aliases as part of collection backups.
- ›Changes the default model for text2vec-google to gemini-embedding-001.
- ›Adds a debug parameter to grouped generative search.
- ›Backports BlockMax AND optimization for BM25 queries.
v1.30.13 Jul 24, 2025 · issue -364

Weaviate v1.30.13 adds custom OIDC JWKS URL support and a new built-in read-only role.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.30.13 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.30.13
```
- ›Adds support for a custom OIDC JWKS URL, enabling custom identity provider configurations.
- ›Adds a new built-in read-only role for RBAC authorization.
v1.31.7 Jul 23, 2025 · issue -364

Weaviate v1.31.7 adds support for custom OIDC JWKS URLs.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.7 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.7
```
- ›Adds support for custom OIDC JWKS URL configuration, enabling use of non-standard OIDC providers.
v1.31.6 Jul 17, 2025 · issue -364

Weaviate v1.31.6 adds jina-embeddings-v4 support, filtered search with MuVera, a new read-only built-in role, and AWS IAM for OIDC certificate download.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.6 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.6
```
- ›Adds support for new built-in read-only role for role-based access control.
- ›Adds support for jina-embeddings-v4 model in the Jina embeddings integration.
- ›Adds AWS IAM authentication support when downloading OIDC certificates.
- ›Enables filtered search with MuVera (multi-vector) indexing.
- ›Adds ability to pass any object property to generative prompts.
+3 moreshow less
- ›Adds OIDC audit log configuration.
- ›Enables reading of segment files with extra info.
- ›Adds metrics for lazy segment loading.
v1.32.0 Jul 15, 2025 · issue -364

Weaviate v1.32.0 adds collection aliases, rotational quantization, replica movement, compressed vector connections, and new embedding modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.32.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.32.0
```
└──▷ TRY IT
Create a collection alias so queries against the alias name are transparently routed to the real collection — useful for blue/green collection swaps without client changes.
```
$ curl -X POST http://localhost:8080/v1/aliases \
  -H 'Content-Type: application/json' \
  -d '{"alias": "CurrentProducts", "collection": "Products_v2"}'
```
- ›Adds REPLICA_MOVEMENT_DISABLED environment variable to control replica movement (renamed from REPLICA_MOVEMENT_ENABLED).
- ›Renames transferType to type in schema.json for replication operations.
- ›Renames nodeId to targetNode in the ListReplication API response.
- ›Adds timestamp fields for status changes to replication operation details endpoint.
- ›Adds Collection Alias (preview): create, update, delete, and resolve aliases for collections via new alias endpoints, usable in GraphQL schema and gRPC Search.
+12 moreshow less
- ›Adds Rotational Quantization as a new vector compression/quantization method.
- ›Adds Compressed Vector Connections, enabling HNSW graph traversal using compressed vectors for neighbor lookups.
- ›Adds support for reranking with the Cohere V3.5 model via the reranker-cohere module.
- ›Adds text2vec-google module support for Gemini embedding models.
- ›Renames the text2colbert-jinaai module to text2multivec-jinaai.
- ›Adds support for the jina-embeddings-v4 model in the JinaAI integration.
- ›Adds multi2multivec-jinaai module for multimodal-to-multi-vector embeddings via JinaAI.
- ›Adds neartext search support to the bigram module.
- ›Adds a Cluster Usage Module for internal collection of object storage size, vector storage size, and backup file sizes in bytes cluster-wide.
- ›Adds Cost-Aware Sort query planner with inverted-index sorter, delivering 2–200x faster filtered queries.
- ›Adds Router with single-tenant and multi-tenant support for replica movement operations.
- ›Improves the replica movement details endpoint with additional status information.
v1.31.5 Jul 4, 2025 · issue -364

Weaviate v1.31.5 adds Gemini embedding support, a backups listing endpoint, and renames the JinaAI multi-vector module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.5
```
- ›Adds text2multivec-jinaai module, renamed from text2colbert-jinaai, to reflect its multi-vector capability.
- ›Adds support for Gemini embedding models in the text2vec-google module.
v1.30.11 Jul 4, 2025 · issue -364

Weaviate v1.30.11 adds Gemini embedding model support and renames the JinaAI multi-vector module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.30.11 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.30.11
```
- ›Adds Gemini embedding model support to the text2vec-google module.
- ›Renames the text2colbert-jinaai module to text2multivec-jinaai.
v1.31.1 Jun 13, 2025 · issue -365

Weaviate v1.31.1 adds Cohere V3.5 reranking, cost-aware query planning (2–200x faster sorts), runtime slow-log overrides, and neartext search on bigram indexes.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.1
```
- ›Adds support for the Cohere V3.5 reranking model in the reranker integration.
- ›Adds a cost-aware query planner and inverted-index sorter, delivering 2–200x faster sorted queries.
- ›Enables overriding query slow-log settings at runtime without a restart.
- ›Adds neartext search support to bigram indexes.
- ›Allows RBAC configurations with no root users defined.
+2 moreshow less
- ›Adds more information to the details endpoint for replica operations.
- ›Improves memory performance by always reading fully loaded segments from memory and disabling bloom filters for in-memory segments.
v1.31.0 May 30, 2025 · issue -366

Weaviate v1.31.0 adds MUVERA encoding, HNSW snapshotting, BM25 AND/OR operators, replica movement APIs, and backward-compatible named vectors.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.31.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.31.0
```
└──▷ TRY IT
Poll the status of an in-progress replica movement operation by its UUID.
```
$ curl -X GET 'http://localhost:8080/v1/replication/replicate/{id}' \
  -H 'Authorization: Bearer <token>'
```
Cancel all pending replication operations for a collection shard when decommissioning a node.
```
$ curl -X DELETE 'http://localhost:8080/v1/replications/replicate' \
  -H 'Authorization: Bearer <token>' \
  -H 'Content-Type: application/json'
```
- ›Adds GET /v1/replication/replicate/{id} endpoint to query the status of a replica movement operation by UUID.
- ›Adds DELETE /replications/replicate endpoint to cancel or delete replication operations.
- ›Adds transferType parameter to replication API to distinguish between copy and move operations.
- ›Adds replicate domain to RBAC, enabling access control over replica movement operations.
- ›Adds minimumOrTokensMatch argument to BM25 keyword search, supporting AND/OR operator semantics via minimum-should-match logic.
+6 moreshow less
- ›Introduces MUVERA encoding for multi-vector representation, with configurable repetitions.
- ›Introduces HNSW periodic snapshotting to accelerate index recovery and reduce WAL replay on restart.
- ›Adds Prometheus metrics for FSM state transitions and replication engine lifecycle callbacks, plus a Grafana dashboard for monitoring the replication engine.
- ›Adds a shard filter to the node/class status internal and HTTP endpoints for scoped status queries.
- ›Enables adding new named vectors to existing collections by default, with auto-schema now producing named vectors.
- ›Allows legacy vector to be referenced as the default named vector in mixed collections.
v1.29.5 May 7, 2025 · issue -366

Weaviate v1.29.5 adds named Vectors to GroupHit responses and new metrics for OpenAI operations, shard status, and auto tenant operations.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.29.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.29.5
```
- ›Adds named Vectors to the GroupHitAdditional struct, exposing named vector results in group-by query responses.
- ›Adds metrics for OpenAI operations to improve observability of OpenAI integration usage.
- ›Adds a metric for internal shard status tracking at the DB layer, including shard shutdown as a valid tracked state.
- ›Adds metrics for auto tenant activation and deactivation operations.
- ›Introduces an optimized mmap package and migrates segment reads to it, reducing memory overhead for large datasets.
+3 moreshow less
- ›Improves BM25 block scoring by using a better average property length calculation for max impact scoring.
- ›Adds a downgrade path from 1.30 to 1.29 for RAFT snapshots, enabling version rollbacks without losing RBAC state.
- ›Sets NoLegacyTelemetry flag on the raft config to suppress legacy telemetry noise.
v1.30.1 Apr 16, 2025 · issue -367

Weaviate v1.30.1 adds DB user last-used tracking, a BM25 block reindex REST trigger, and a configurable RAFT trailing-logs setting.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.30.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.30.1
```
- ›Adds a REST call to trigger BM25 block (blockmax) reindexing by initiating a shard reinit, enabling on-demand reindex without a restart.
- ›Adds an environment variable to set a higher segment inspection limit for BM25 block searches.
- ›Adds 'last used time' tracking to DB users, surfaced through the /users/db endpoint.
- ›Returns the first 3 characters of an API key in API key response payloads, enabling key identification without exposing the full secret.
- ›Adds configurable collections, properties, and tenants selection to the blockmax migrator, allowing targeted migration rather than full-index migration.
v1.30.0 Apr 3, 2025 · issue -367

Weaviate v1.30.0 ships runtime config management, dynamic user/API-key REST APIs, dynamic RAG model selection, BlockMax WAND BM25, and multi-value vector GA.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.30.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.30.0
```
- ›Adds maximum_allowed_collection_limit as a runtime-configurable variable via the runtime config manager, enabling live tuning without restarts.
- ›Adds AUTOSCHEMA_ENABLED as a runtime override, controllable through the runtime config manager without a restart.
- ›Adds ASYNC_REPLICATION_DISABLED as a runtime override, controllable through the runtime config manager without a restart.
- ›Adds an environment variable to enable dynamic (DB) user management (DYNAMIC_USERS_ENABLED, later renamed); enables REST API-driven creation, update, suspension, activation, and revocation of users and API keys at runtime.
- ›Adds RBAC tenant filtering to batch object operations and POST batch/references, giving role-based access control coverage over batch workflows.
+8 moreshow less
- ›Adds RBAC filtering to the nodes endpoint so only nodes the caller has permission to see are returned.
- ›Adds a creationTime field to dynamically created users and saves the first letters of the API key for identification.
- ›Introduces the xAI generative module, adding xAI as a supported provider for retrieval-augmented generation.
- ›Dynamic RAG model selection is now GA: select the generative model per query at runtime; supports image inputs split across images and imageProperties fields in the dynamic provider.
- ›Adds ENABLE_EXPERIMENTAL_DYNAMIC_RAG_SYNTAX environment variable as a fallback option for enabling dynamic RAG syntax.
- ›BlockMax WAND-based BM25 is now GA and enabled by default, delivering significantly faster BM25 keyword search with an online, zero-downtime migration process for existing indexes.
- ›Multi-value vector search (ColBERT-style embeddings) is now GA; all multi-vector indexes now support BQ, PQ, and SQ quantization options.
- ›Adds metrics support for the internal http server, expanding observability coverage.
└──▷ BREAKING ON UPGRADE
- !BlockMax WAND migration produces segment files that are not backwards compatible with previous Weaviate versions; rolling back to an earlier version after migration is not supported.
v1.29.0 Feb 17, 2025 · issue -369

Weaviate v1.29.0 brings RBAC GA, async replication with Merkle Trees, ACORN random re-entry, and multi-vector (ColBERT) preview
└──▷ GET THIS VERSION
```
$ git clone --branch v1.29.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.29.0
```
- ›Adds EXPERIMENTAL_AUTHORIZATION_RBAC_READONLY_ROOT_GROUPS environment variable to configure read-only root groups for RBAC.
- ›Adds EXPERIMENTAL_AUTHORIZATION_READONLY_GROUPS environment variable to designate read-only groups in RBAC.
- ›Adds group assignment/revocation endpoints for RBAC, allowing roles to be assigned to and revoked from groups (restricted to root users only).
- ›Adds scope-based actions for role permissions in RBAC, with MATCH as the default scope (migrated via Raft).
- ›Adds filter-based authorization for READ ALL operations in RBAC, covering schema, tenants, roles, and object reads.
+9 moreshow less
- ›Adds user permissions management to RBAC, enabling per-user permission assignment.
- ›Adds RBAC permission body validation on assignment requests.
- ›Adds separate tenant and collection controls inside the RBAC schema permission model.
- ›RBAC moves to GA — fine-grained access control for collections, tenants, objects, and references is now production-ready.
- ›Adds Async Replication using Merkle Trees (hashtrees) to propagate missing objects across cluster nodes efficiently.
- ›Adds ACORN random re-entry strategy to improve vector index quality after updates and deletions, reducing query latency automatically.
- ›Adds extra environment variables to configure ACORN filter strategy behavior.
- ›Adds gRPC Aggregate support for search, property aggregators, and meta count queries.
- ›Adds Multi-Vector (ColBERT) retrieval support in preview, enabling multiple vectors per document for storage and search.
v1.28.5 Feb 14, 2025 · issue -369

Weaviate v1.28.5 adds four NVIDIA integration modules, expands RBAC with group assignment endpoints, and broadens gRPC aggregate support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.28.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.28.5
```
└──▷ TRY IT
Vectorize text using the new NVIDIA module when creating a Weaviate collection.
```
$ curl -X POST http://localhost:8080/v1/schema \
  -H 'Content-Type: application/json' \
  -d '{
    "class": "Document",
    "vectorizer": "text2vec-nvidia"
  }'
```
- ›Adds reranker-nvidia module for reranking results via NVIDIA APIs.
- ›Adds generative-nvidia module for generative (RAG) workflows via NVIDIA APIs.
- ›Adds text2vec-nvidia module for text vectorization via NVIDIA APIs.
- ›Adds multi2vec-nvidia module for multimodal vectorization via NVIDIA APIs.
- ›Adds EXPERIMENTAL_AUTHORIZATION_READONLY_GROUPS environment variable to configure read-only RBAC root groups.
+16 moreshow less
- ›Adds EXPERIMENTAL_AUTHORIZATION_RBAC_READONLY_ROOT_GROUPS flag for protecting root groups from modification.
- ›Adds RBAC group assignment and revocation endpoints, allowing roles to be assigned to and revoked from groups.
- ›Adds users/own-info endpoint, replacing the former authz/own-roles endpoint.
- ›Adds user read permission and user permissions management to RBAC.
- ›Adds RBAC scope-based actions for role permissions, with MATCH as the default scope migrated via Raft.
- ›Adds filter-based authorization for READ ALL operations covering schema, tenants, roles, and object retrieval.
- ›Adds RBAC authorization to the classifications API.
- ›Adds immutable root groups to RBAC, preventing end-users from modifying them.
- ›Expands gRPC Aggregate to support meta count queries, property aggregators, and search.
- ›Adds support for images in dynamic RAG syntax.
- ›Adds weaviate_schema_collections metric to track collection counts.
- ›Adds weaviate_schema_shards metric to track total shard count per node.
- ›Adds HTTP server metrics to main API handlers.
- ›Adds server metrics for main gRPC handlers.
- ›Adds a flag to disable async replication.
- ›Parallelises local and remote shard search to improve query throughput.
v1.27.12 Feb 10, 2025 · issue -369

Weaviate v1.27.12 adds image support in dynamic RAG syntax and parallelizes local and remote shard search.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.12 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.12
```
- ›Adds image support in dynamic RAG syntax, enabling multimodal retrieval-augmented generation queries.
- ›Parallelizes local and remote shard search, improving query performance across distributed deployments.
v1.28.0 Dec 11, 2024 · issue -371

Weaviate v1.28.0 previews RBAC authorization with built-in and custom roles, collection-level isolation, and full CRUD endpoints at /authz/roles.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.28.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.28.0
```
- ›Adds RBAC CRUD endpoints (e.g., POST /authz/roles, returning 409 on conflict) for creating, reading, updating, and deleting roles and permissions in preview.
- ›Supports add-permission and remove-permission operations on roles via the new authz API surface.
- ›Adds a read_roles field to the schema, enabling role metadata to be returned as part of collection schema responses.
- ›Introduces built-in roles with auto-generated permissions, alongside support for fully custom roles and permissions scoped to specific collections.
- ›Adds a users domain and associated actions to the RBAC permission model, enabling user-management operations to be gated by role.
+4 moreshow less
- ›RBAC policies are persisted across all Raft nodes and reloaded on restart, ensuring cluster-wide consistency.
- ›Adds RBAC authorization coverage to GraphQL (including batch GQL), gRPC search, REST batch delete, batch references, and object/reference endpoints.
- ›Adds an RBAC audit log component for tracking authorization decisions and pretty-printing resource paths on errors.
- ›Enforces collection and tenant existence validation at permission-creation time.
v1.26.12 Dec 11, 2024 · issue -371

Weaviate v1.26.12 adds VoyageAI multimodal embeddings, Ollama batch support, and a runtime log-level API.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.26.12 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.26.12
```
- ›Supports runtime log-level configuration via the API, enabling operators to adjust verbosity without restarting the service.
- ›Adds support for the Ollama batch endpoint, improving throughput for Ollama-backed vectorization.
- ›Adds a new VoyageAI multimodal module, enabling image and text embeddings through VoyageAI.
- ›Adds support for X-Goog-* headers in Google provider clients.
- ›Adds environment variable overrides for Azure backup block size and concurrency settings.
+1 moreshow less
- ›Adds an option to skip waiting for self-deployed modules on startup, reducing initialization delays in custom module deployments.
v1.25.28 Dec 10, 2024 · issue -371

Weaviate v1.25.28 adds a VoyageAI multimodal module for embedding multimodal content.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.28 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.28
```
- ›Adds a VoyageAI multimodal module, enabling multimodal embeddings via VoyageAI within Weaviate.
v1.27.8 Dec 10, 2024 · issue -371

Weaviate v1.27.8 adds a VoyageAI multimodal module for cross-modal vector search.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.8 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.8
```
- ›Adds the VoyageAI multimodal module, enabling vectorization of mixed-modality content via VoyageAI's embedding models.
v1.27.7 Dec 5, 2024 · issue -371

Weaviate v1.27.7 adds reindex-references API, maintenance-mode toggle, Azure env overrides, and X-Goog-* header support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.7 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.7
```
- ›Adds environment variable overrides for Azure block size and concurrency settings.
- ›Adds support for X-Goog-* headers, enabling Google-specific header passthrough.
- ›Adds an option to skip waiting for self-deployed modules on startup.
- ›Limits backup search scope to BACKUP_PATH for remote backends, reducing unintended traversal.
- ›Adds a reindex-references feature via the debug API to rebuild reference indexes.
+1 moreshow less
- ›Enables maintenance mode to be toggled on or off via the /debug API.
v1.25.27 Dec 2, 2024 · issue -371

Weaviate v1.25.27 adds environment overrides for Azure block size and concurrency, plus an option to skip waiting for self-deployed modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.27 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.27
```
- ›Adds environment overrides for Azure block size and concurrency settings.
- ›Adds an option to not wait for self-deployed modules on startup.
- ›Adds support for X-Goog-* headers in API requests.
v1.27.5 Nov 21, 2024 · issue -372

Weaviate v1.27.5 adds the multi2vec-jinaai multimodal embedding module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.5
```
- ›Adds multi2vec-jinaai module for multimodal vectorization using Jina AI embeddings.
v1.26.11 Nov 21, 2024 · issue -372

Weaviate v1.26.11 adds the multi2vec-jinaai multimodal embedding module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.26.11 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.26.11
```
- ›Adds the multi2vec-jinaai module, enabling multimodal vectorization via Jina AI's multi2vec models.
v1.25.26 Nov 21, 2024 · issue -372

Weaviate v1.25.26 adds the multi2vec-jinaai multimodal embedding module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.26 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.26
```
- ›Adds multi2vec-jinaai module, enabling multimodal vectorization via Jina AI's embedding models.
v1.25.25 Nov 13, 2024 · issue -372

Weaviate v1.25.25 adds the multi2vec-cohere multimodal vectorizer module and extends the Slow Log with richer query diagnostics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.25 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.25
```
- ›Introduces the multi2vec-cohere module, adding Cohere-backed multimodal vectorization support to Weaviate.
- ›Extends the Slow Log with additional information to help determine why a query is slow.
v1.27.3 Nov 13, 2024 · issue -372

Weaviate v1.27.3 adds multi2vec-cohere to default modules and extends the Slow Log with richer query diagnostics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.3
```
- ›Adds multi2vec-cohere to the default modules list, enabling multimodal Cohere embeddings without manual module configuration.
- ›Extends the Slow Log with additional information to help determine why a query is slow.
v1.26.9 Nov 8, 2024 · issue -372

Weaviate v1.26.9 adds the multi2vec-cohere multimodal vectorizer module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.26.9 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.26.9
```
- ›Introduces the multi2vec-cohere module for multimodal vectorization using Cohere.
v1.27.2 Nov 8, 2024 · issue -372

Weaviate v1.27.2 adds dynamic backup locations and a new multi2vec-cohere multimodal vectorizer module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.2
```
- ›Introduces the multi2vec-cohere module, enabling multimodal vectorization via Cohere's API.
- ›Adds dynamic backup locations, allowing backup destinations to be configured at backup time rather than only at startup.
v1.27.1 Oct 31, 2024 · issue -373

Weaviate v1.27.1 adds configurable gRPC message size, HNSW visited-list pool limit, Dynamic RAG module config, and parallel compressed vector cache prefill.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.1
```
- ›Adds an option to limit the HNSW visited list pool size, enabling memory cap on high-concurrency search workloads.
- ›Adds support for Dynamic RAG module configuration parameters, allowing per-request generative module tuning.
- ›Allows updating generative and reranker module configurations on existing collections without recreation.
- ›Prefills compressed (PQ/BQ) vector caches in parallel, accelerating startup time for quantized indexes.
- ›Performs non-blocking segment drops during compaction, reducing latency spikes on write-heavy workloads.
+1 moreshow less
- ›Improves segment cleanup to reduce storage overhead over time.
v1.27.0 Oct 16, 2024 · issue -373

Weaviate v1.27.0 adds ACORN-based HNSW filters, backup cancellation APIs, experimental read-compute scaling, dynamic RAG via gRPC, and new embedding/generative modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.27.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.27.0
```
- ›Adds a backup cancellation endpoint and a 'list backups in progress' endpoint, with CANCELED status now propagated across all backup API responses and a path field added to list backup responses.
- ›Adds experimental read-compute scaling via a separate querier component (exp/query) supporting vector search, property filters, and object retrieval from the LSMKV store for offloaded (FROZEN) tenants.
- ›Supports dynamic RAG syntax through the gRPC API.
- ›Supports sending Azure OpenAI deployment ID and resource name via request headers.
- ›Adds support for custom number of dimensions when using Azure OpenAI.
+13 moreshow less
- ›Adds weaviate_build_info Prometheus metric for build observability.
- ›Adds batch-size metrics for Prometheus observability.
- ›Adds SIMD implementation for Bitwise Hamming distance on x86 and ARM architectures.
- ›Adds ACORN-based minority filter improvements to HNSW for more accurate filtered vector search.
- ›Supports multiple inputs for a single target vector in multi-target vector search.
- ›Adds a Weaviate-hosted embeddings module.
- ›Adds a Generative FriendliAI module.
- ›Adds support for the JinaAI reranker API.
- ›Enables arrays in generative searches.
- ›Adds gpt-4o model support in the Generative-OpenAI module.
- ›Renames generative-palm module to generative-google, multi2vec-palm to multi2vec-google, and text2vec-palm to text2vec-google, with AltNames support for backward compatibility.
- ›Adds a progress indicator for schema catchup on restart.
- ›Adds segment cleanup for LSM storage.
v1.26.5 Sep 27, 2024 · issue -374

Weaviate v1.26.5 adds backup cancel/list endpoints, Jina V3 and VoyageAI model support, maintenance mode, and async brute-force search limit — but is flagged BROKEN and should not be used.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.26.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.26.5
```
- ›Adds ASYNC_BRUTE_FORCE_SEARCH_LIMIT environment variable to cap brute-force search results in async mode.
- ›Adds MAINTENANCE_NODES environment variable to put specific nodes into maintenance mode.
- ›Adds a backup cancel API endpoint (backported from main).
- ›Adds support for Jina V3 embeddings, including updating the task_type parameter to task for JinaAI V3 embedding models.
- ›Adds support for new VoyageAI embedding models with adjusted max token values.
+6 moreshow less
- ›Adds support for the X-Databricks-User-Agent header in Databricks integrations.
- ›Adds support for OpenAI's x-request-id response header, surfacing it in errors from generative and QnA modules.
- ›Introduces object deletion conflict resolution for distributed setups.
- ›Introduces a limit on nested cross-reference depth in queries.
- ›Introduces metrics for tombstone cycle start, end, and progress.
- ›Adds a backup list API endpoint (note: subsequently disabled in this same release).
└──▷ BREAKING ON UPGRADE
- !This release is marked [BROKEN] / [DO NOT USE]: a bug may cause cluster data deletion in certain setups. Upgrade to v1.26.6 instead. See https://github.com/weaviate/weaviate/issues/5971 for details.
v1.24.25 Sep 26, 2024 · issue -374

Weaviate v1.24.25 adds backup list and cancel endpoints, Jina V3 and new VoyageAI model support, and nested cross-reference depth limits.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.24.25 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.24.25
```
- ›Adds a backup cancel endpoint, allowing in-progress backups to be programmatically stopped.
- ›Adds a backup list endpoint for querying existing backups via the API.
- ›Adds support for Jina V3 embeddings, including the task parameter (replacing task_type) for JinaAI V3 embedding models.
- ›Introduces new VoyageAI models as supported embedding integrations.
- ›Introduces a limit on nested cross-reference depth in queries to bound query complexity.
v1.25.17 Sep 13, 2024 · issue -374

Weaviate v1.25.17 adds backup list and backup cancel API endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.17 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.17
```
- ›Adds a backup list endpoint to retrieve existing backups via the API.
- ›Adds a backup cancel endpoint to abort an in-progress backup via the API.
└──▷ BREAKING ON UPGRADE
- !This release contains a bug that may result in cluster data deletion in certain setups — do not use. Upgrade to v1.25.20 instead.
v1.26.3 Aug 29, 2024 · issue -375

Weaviate v1.26.3 adds hybrid search score cutoffs, Databricks Foundation Model API support for LLM and embeddings, and a FriendliAI generative module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.26.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.26.3
```
- ›Adds cutoff threshold support for hybrid search queries, enabling score-based result filtering.
- ›Adds support for Databricks Foundation Model API as an LLM backend.
- ›Adds support for Databricks Foundation Model API as an embedding backend.
- ›Adds a new generative module for FriendliAI, enabling use of FriendliAI models for RAG workflows.
└──▷ BREAKING ON UPGRADE
- !This release is marked [BROKEN] / [DO NOT USE]: a bug may cause cluster data deletion in certain setups. Weaviate recommends upgrading directly to v1.26.6 instead.
v1.25.13 Aug 22, 2024 · issue -375

Weaviate v1.25.13 adds Mistral text2vec module and concurrent vectorization — but is flagged broken; upgrade to v1.25.20.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.13 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.13
```
- ›Adds Mistral text2vec module, enabling Mistral-backed text vectorization for collections.
- ›Adds concurrent vectorization support, allowing multiple vectors to be computed in parallel during ingestion.
└──▷ BREAKING ON UPGRADE
- !This release contains a bug that may cause cluster data deletion in certain setups. It is marked [DO NOT USE]; upgrade to v1.25.20 instead.
v1.24.23 Aug 20, 2024 · issue -375

Weaviate v1.24.23 adds an experimental repair endpoint for cluster data repair operations.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.24.23 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.24.23
```
- ›Adds an experimental repair endpoint for repairing data in a Weaviate cluster.
v1.26.1 Jul 23, 2024 · issue -376

Weaviate v1.26.1 adds JinaAI reranker API support for improved search result ranking.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.26.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.26.1
```
- ›Adds support for the JinaAI reranker API, enabling JinaAI-powered result reranking in search pipelines.
v1.26.0 Jul 23, 2024 · issue -376

Weaviate v1.26.0 adds tenant offloading to S3, multi-target vector search, scalar quantization, async replication, and improved range filters.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.26.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.26.0
```
└──▷ USE IT
Enable the new range filter index on a numeric property to accelerate large-scale numeric range queries.
json
```
{
  "class": "Product",
  "properties": [
    {
      "name": "price",
      "dataType": ["number"],
      "indexRangeFilters": true
    }
  ]
}
```
Search across multiple named vectors in a single GraphQL query for more comprehensive retrieval.
json
```
{
  Get {
    Article(
      nearText: {
        concepts: ["climate change"],
        targets: { combinationMethod: minimum, targetVectors: ["title", "body"] }
      }
    ) {
      title
      body
    }
  }
}
```
- ›Adds OFFLOAD_S3_ENDPOINT environment variable (renamed from S3_ENDPOINT_URL) to configure S3-compatible object storage for tenant offloading.
- ›Adds FROZEN tenant status via REST and gRPC APIs, enabling inactive tenant data to be offloaded to S3-compatible object storage to reduce compute costs.
- ›Adds IndexRangeFilters property config to enable a new roaring-set range index, drastically improving performance of numeric range queries at scale.
- ›Adds a reindex endpoint to the REST API.
- ›Adds Scalar Quantization (SQ) vector compression, mapping floating-point vector values to integers to reduce storage size while maintaining search accuracy.
+11 moreshow less
- ›Adds async (Merkle tree-based) replication to keep replicas consistent with minimal performance impact.
- ›Adds multi-target vector search, allowing a single query to search across multiple named vectors simultaneously via GraphQL and gRPC.
- ›Adds generative-anthropic as a new generative module (Module Generative Anthropic).
- ›Adds dynamic generative module syntax with GraphQL and gRPC support, enabling runtime selection of generative modules.
- ›Adds an environment variable to disable the Go profiler setup.
- ›Adds API-based modules (including multi2vec-palm) enabled by default.
- ›Enables concurrent batch vectorization requests, improving throughput for bulk ingestion.
- ›Changes HNSW default max connections to 32 for improved index performance.
- ›Makes offload S3 bucket auto-creation configurable.
- ›Enables auto tenant activation/deactivation as part of the offloading workflow.
- ›Supports concurrent tenant update operations.
└──▷ BREAKING ON UPGRADE
- !Tenant activity status update requests are now limited to 100 tenants per request (official client libraries batch automatically).
- !The S3_ENDPOINT_URL environment variable is renamed to OFFLOAD_S3_ENDPOINT.
- !The UNFROZEN tenant status is removed; use the supported active/frozen lifecycle instead.
v1.25.8 Jul 18, 2024 · issue -376

Weaviate v1.25.8 adds opt-in Sentry error reporting and a new flag to force full-replica shard searches.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.8 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.8
```
- ›Adds a new flag to force search to query all replicas of a shard when possible, improving search completeness in replicated deployments.
- ›Integrates Sentry error reporting (opt-in, disabled by default) with automatic reporting of vector search failures and shard initialization errors.
v1.25.6 Jun 28, 2024 · issue -377

Weaviate v1.25.6 adds optional forced compaction for the flat index type.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.6 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.6
```
- ›Adds optional forced compaction for the flat index type, enabling manual compaction control outside of automatic scheduling.
v1.25.0 May 10, 2024 · issue -378

Weaviate v1.25.0 adds RAFT-based schema, batch vectorization, dynamic index switching, implicit tenant creation, and new Ollama/OctoAI modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.25.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.25.0
```
└──▷ TRY IT
Retrieve cluster-wide RAFT and node statistics for operational health checks.
```
$ curl -s http://localhost:8080/v1/cluster/statistics | jq .
```
- ›Adds RAFT_GRPC_MESSAGE_MAX_SIZE environment variable to set the maximum gRPC message size for the RAFT subsystem.
- ›Adds an external gRPC method for getting tenant information, enabling programmatic tenant queries via gRPC.
- ›Adds a GET /cluster/statistics endpoint (cluster-aware) for retrieving cluster-wide statistics.
- ›Adds an endpoint for checking if a tenant exists.
- ›Returns the created tenants in the response body of POST /tenants.
+14 moreshow less
- ›Introduces RAFT-based schema consensus, enabling concurrent schema updates across cluster nodes and eliminating schema-update bottlenecks.
- ›Introduces batch vectorization for OpenAI, Cohere, and VoyageAI integrations, reducing rate-limiting exposure and speeding up bulk inserts.
- ›Introduces dynamic vector index switching to automatically transition between index types for optimal performance and efficiency.
- ›Introduces implicit tenant creation — nonexistent tenants are created on the fly when their name is included in a batch insert (auto-tenant toggling on multi-tenancy-enabled classes).
- ›Adds nearVector and nearText as sub-search options within hybrid search queries.
- ›Adds groupBy support to hybrid search and BM25F, and adds moveTo/moveFrom and similar parameters to aggregate hybrid search.
- ›Adds target-vector cleanup for hybrid queries via gRPC.
- ›Introduces the text2vec-ollama module for local embedding generation via Ollama.
- ›Introduces the generative-ollama module (including Llama 3 support) for local generative AI via Ollama.
- ›Adds OctoAI generative and text2vec modules for embedding and generation via OctoAI.
- ›Adds Command R and Command R+ model support to the generative-cohere module.
- ›Adds tenant activity metrics for observability of per-tenant usage.
- ›Increases put and batch operation timeouts to 60 seconds.
- ›Reserves RAFT (all casing permutations) as a protected class name, preventing naming conflicts with the consensus subsystem.
v1.24.7 Apr 5, 2024 · issue -379

Weaviate v1.24.7 adds the VoyageAI reranker module.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.24.7 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.24.7
```
- ›Introduces the VoyageAI reranker module for result reranking pipelines.
v1.24.2 Mar 12, 2024 · issue -380

Weaviate v1.24.2 adds generative-mistral module, gemini-pro-vision support, and multi-transformer/CLIP module capability.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.24.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.24.2
```
└──▷ TRY IT
Supply the VoyageAI API key using the renamed environment variable when starting Weaviate.
```
$ VOYAGEAI_APIKEY=your-key docker compose up
```
- ›Introduces generative-mistral module for Mistral-backed generative search.
- ›Adds support for VOYAGEAI_APIKEY environment variable for VoyageAI API key configuration.
- ›Adds support for gemini-pro-vision model in the generative-google module.
- ›Adds support for multiple transformers and CLIP modules simultaneously.
└──▷ BREAKING ON UPGRADE
- !The text2vec-voyageai module's truncate setting type has changed from string to bool.
- !The VoyageAI API key environment variable is renamed from the previous name to VOYAGEAI_APIKEY.
v1.24.0 Feb 27, 2024 · issue -381

Weaviate v1.24.0 adds multi-vector per class, HNSW binary quantization, Japanese/Chinese tokenizers, and high-frequency update support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.24.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.24.0
```
- ›Adds binary quantization (BQ) support for the HNSW vector index, enabling vector compression into compact binary formats to drastically reduce memory footprint while maintaining search accuracy; BQ compression can be enabled via class user config updates.
- ›Introduces multiple vectors per class (named vectors), allowing each object to carry several independent vector representations for richer, multifaceted search and ML use cases; includes gRPC Batch API support, aggregate queries with named vectors, and VectorConfig update support.
- ›Adds Japanese and Chinese tokenizer support, with dictionary files bundled directly in the Docker image.
- ›Extends HTTP backup and restore endpoints to accept custom compression configuration, and adds a restore config object.
- ›Changes hybrid search fusion default to relative score fusion.
+3 moreshow less
- ›Supports high-frequency updates at tens of millions per day by skipping vector reindexing when vectors are unchanged and deduplicating identical objects in batch operations.
- ›Improves the NotEqual filter operator for more accurate query results.
- ›Enables setting additional log levels for more granular observability.
v1.23.0 Dec 18, 2023 · issue -383

Weaviate v1.23.0 adds binary quantization, lazy shard loading, auto-compression PQ, Gemini/Anyscale modules, and gRPC TLS.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.23.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.23.0
```
- ›Adds output verbosity option to the Nodes API with a new verbose level that includes per-shard metadata, and a new default of minimal that omits it — reducing cost of cluster-wide status queries at scale.
- ›Adds compressed field to NodeShardStatus in the Nodes API response.
- ›Introduces ReturnAllNonrefProperties bool to the gRPC PropertiesRequest message to control property return in search results.
- ›Adds gRPC TLS credentials support via new config options, enabling encrypted gRPC transport.
- ›Adds metadata filter support to the gRPC search API.
+11 moreshow less
- ›Adds geo-coordinate support to the gRPC search API.
- ›Introduces a custom pb.Properties message in gRPC search results for type-aware property handling.
- ›Adds a Generative Anyscale module for LLM-backed generative search.
- ›Adds support for Google Gemini model via a new generative module.
- ›Adds Mixtral-8x7B-Instruct-v0.1 to available generative models.
- ›Adds support for Google Gecko 002 and 003 embedding models.
- ›Introduces binary quantization (BQ) and a brute-force flat index type that runs searches directly from disk, with choice between original vectors or binary-compressed vectors.
- ›Introduces lazy shard loading: nodes now start almost instantly by loading shards in the background, with on-demand loading when a request targets a not-yet-loaded shard.
- ›Adds Prometheus metrics for shard lazy loading and unloading.
- ›Introduces auto-compression: Product Quantization (PQ) triggers automatically when the in-memory vector index crosses a configured threshold.
- ›Adds resource guardrails that set memory and thread limits to prevent OOM conditions and worker-thread swapping.
└──▷ BREAKING ON UPGRADE
- !The Nodes API (GET /v1/nodes) now defaults to minimal verbosity, omitting per-shard metadata from the response. Callers that relied on shard-level detail must add the verbose verbosity parameter to restore the previous behavior.
v1.22.5 Nov 24, 2023 · issue -384

Weaviate v1.22.5 adds text2vec-aws and generative-aws modules for Amazon-backed vectorization and generation.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.22.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.22.5
```
- ›Adds text2vec-aws module for vectorizing data using AWS-backed embedding models.
- ›Adds generative-aws module for generative AI queries powered by AWS services.
v1.22.3 Nov 7, 2023 · issue -384

Weaviate v1.22.3 adds the text2vec-jinaai module, Cohere v3 model support, and OpenAI GPT-4 128k/GPT-3.5 preview models.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.22.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.22.3
```
- ›Adds support for overriding Cohere's base URL via the X-Cohere-BaseURL HTTP header, enabling routing to custom or proxy endpoints.
- ›Adds support for passing OpenAI base URL via HTTP header, enabling routing to custom or proxy OpenAI-compatible endpoints.
- ›Adds the text2vec-jinaai module, enabling JinaAI embeddings as a vectorization source in Weaviate.
- ›Adds support for Cohere v3 models in the Cohere integration.
- ›Adds support for OpenAI GPT-4 128k and GPT-3.5 preview models in the OpenAI integration.
v1.22.0 Oct 27, 2023 · issue -385

Weaviate v1.22.0 adds async indexing, nested object storage, official gRPC API, OIDC group auth, and module vectorization expansions.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.22.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.22.0
```
└──▷ TRY IT
Check the async vector queue backlog on a shard to know when indexing has caught up after a large import.
```
$ curl -s http://localhost:8080/v1/schema/MyCollection/shards | jq '.[].vectorQueueSize'
```
- ›Adds experimental async indexing via the ASYNC_INDEXING=true environment variable, decoupling vector indexing from object creation to maximize import speed.
- ›Adds vectorQueueSize field to the /schema/{className}/shards REST API response to expose pending async index queue depth.
- ›Adds support for object and object[] data types, enabling full nested objects to be stored directly in Weaviate, including autoschema support for dynamic nested properties.
- ›Adds node_mapping parameter to backup restore operations.
- ›Officially supports gRPC API (with proto packages split into v0 and v1), including gRPC health checks and nested object transport.
+8 moreshow less
- ›Adds OIDC group authentication support.
- ›Adds gpt-3.5-turbo-instruct to the available models for the qna-openai module.
- ›Adds vectorization support for text[] properties in the multi2vec-bind module.
- ›Adds vectorization support for text[] properties in the multi2vec-clip module.
- ›Adds automatic schema repair when cluster nodes fall out of sync.
- ›Adds memory guard rails for batch creation to prevent out-of-memory conditions under heavy load.
- ›Improves startup time by initializing shards in parallel.
- ›Improves shutdown speed by shutting down shards in parallel.
└──▷ BREAKING ON UPGRADE
- !gRPC proto files have been split into v0 and v1 packages; existing gRPC clients must upgrade to the latest gRPC services.
v1.21.3 Sep 13, 2023 · issue -386

Weaviate v1.21.3 expands gRPC support with near-text/image/audio/video search, generative search, sorting, consistency, and vectorizer auth.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.21.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.21.3
```
- ›Adds nearText search to the gRPC protocol, enabling vector similarity queries over gRPC alongside the existing REST/GraphQL path.
- ›Adds near image, audio, and video search operators to the gRPC protocol.
- ›Adds generative search to the gRPC protocol, bringing RAG-style queries to the gRPC surface.
- ›Adds consistency-level control to gRPC requests, matching the consistency options available over REST.
- ›Adds vectorizer authentication support via gRPC, so module-backed vectorizers can be authorized over the gRPC path.
+3 moreshow less
- ›Adds result sorting to the gRPC protocol.
- ›Adds Java options to the gRPC protobuf definition, improving first-class Java client support.
- ›Supports new Google PaLM modules via the generative-palm integration.
v1.21.0 Aug 17, 2023 · issue -387

Weaviate v1.21.0 adds ContainsAny/ContainsAll operators, backup compression, inactive tenants, pread LSM support, and two new vectorizer modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.21.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.21.0
```
└──▷ USE IT
Filter documents where a tokenized text field contains any of several keywords — useful for OR-style keyword matching without multiple nested filters.
graphql
```
{
  Get {
    Article(
      where: {
        path: ["tags"],
        operator: ContainsAny,
        valueText: ["cybersecurity", "threat", "vulnerability"]
      }
    ) {
      title
      tags
    }
  }
}
```
- ›Adds ContainsAny and ContainsAll filter operators for easier filtering on array types and tokenized text fields.
- ›Introduces the text2vec-gpt4all module for local GPT4All-based text vectorization.
- ›Introduces the multi2vec-bind module for multi-modal vectorization via ImageBind.
- ›Adds opt-in pread as an alternative to mmap for LSM store access, improving performance and stability on disk-bound setups.
- ›Backup compression support: backups can now be compressed into pre-configurable chunks, reducing file operations and lowering S3/GCS storage costs.
+8 moreshow less
- ›Adds ability to deactivate tenants (experimental) so inactive tenants consume no resources, enabling denser multi-tenant deployments on the same node.
- ›Enforces a minimum replication factor according to system-wide configuration.
- ›Adds a configurable nested cross-reference query limit.
- ›Adds batch queue congestion info to node status.
- ›Adds gRPC batching support.
- ›Adds batch support in the reranker-transformers module.
- ›Enables creating object references without specifying ToClass.
- ›Adds NEON SIMD acceleration for L2 and dot-product distance calculations on ARM, improving HNSW vector search performance.
v1.20.0 Jul 6, 2023 · issue -388

Weaviate v1.20 adds native multi-tenancy, autocut result filtering, RelativeScore fusion, two reranker modules, and PQ GA.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.20.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.20.0
```
└──▷ TRY IT
Create a new class with multi-tenancy enabled, then add tenants so each gets a strongly isolated shard.
```
$ curl -X POST http://localhost:8080/v1/schema \
  -H 'Content-Type: application/json' \
  -d '{"class": "Document", "multiTenancyConfig": {"enabled": true}}'

curl -X POST http://localhost:8080/v1/schema/Document/tenants \
  -H 'Content-Type: application/json' \
  -d '[{"name": "tenant-acme"}, {"name": "tenant-globex"}]'
```
List all tenants in a class to audit tenant membership in a multi-tenant deployment.
```
$ curl http://localhost:8080/v1/schema/Document/tenants
```
- ›Introduces native multi-tenancy with strong tenant isolation, supporting 50,000+ tenants per node and millions of tenants with billions of objects in a multi-node cluster; enable via class schema configuration.
- ›Adds GET /tenants endpoint to list tenants of a multi-tenant class, plus endpoints to create and delete tenants for a specific class.
- ›Supports full single-tenant object CRUD, batch operations, and batch reference operations, with tenant key immutability enforced.
- ›Extends the nodes API to surface multi-tenant class information.
- ›Adds multi-tenancy support to GQL Get{} and GQL Aggregate{} queries, including nearObject and nearText with tenant context.
+8 moreshow less
- ›Adds replication support for multi-tenant classes.
- ›Enables Prometheus metrics for classes with multi-tenancy enabled.
- ›Introduces autocut for bm25, nearVector, nearObject, and nearXXX queries to automatically cut off unrelated results.
- ›Adds autocut and a RelativeScore fusion algorithm to hybrid search for improved result quality.
- ›Introduces reranker-transformers module for post-retrieval reranking using transformer models.
- ›Introduces reranker-cohere module for post-retrieval reranking using the Cohere API.
- ›Adds status code metrics distinguishing OK, user error, and server error responses for better observability of request success and failure rates.
- ›Product Quantization (PQ) moves to general availability, with dynamic rescoring of results and a configurable training limit.
v1.19.7 Jun 12, 2023 · issue -389

Weaviate v1.19.7 adds PQ rescoring, new Cohere model support, and grouped metrics options.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.19.7 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.19.7
```
- ›Adds an option to group metrics via the metrics configuration, alongside a corrected Vector Add metric.
- ›Adds Product Quantization (PQ) with rescoring support to improve approximate nearest-neighbor search accuracy.
- ›Adds support for new Cohere model names in both the text2vec and generative Cohere modules.
v1.19.1 May 10, 2023 · issue -390

Weaviate v1.19.1 adds Google PaLM support via new text2vec-palm and generative-palm modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.19.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.19.1
```
- ›Adds text2vec-palm module to enable Google PaLM-based text vectorization.
- ›Adds generative-palm module to enable Google PaLM-based generative search.
v1.19.0 May 4, 2023 · issue -390

Weaviate v1.19 adds a gRPC search API, Cohere generative module, tunable consistency, uuid prop types, and group-by queries.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.19.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.19.0
```
- ›Adds a minimal gRPC API (experimental) with support for a Search endpoint, enabling lower-latency programmatic access.
- ›Adds generative-cohere module, enabling Retrieval-Augmented Generation with Cohere's generative models.
- ›Adds tunable consistency to GraphQL Get queries, letting callers control read consistency level per search request.
- ›Adds uuid and uuid[] property types, indexed with roaring bitmaps for efficient UUID-based filtering.
- ›Adds group-by arbitrary property (including reference props) in GraphQL queries, returning top-k results per group.
+2 moreshow less
- ›Enriches text and text[] tokenization with new options via IndexFilterable and IndexSearchable property settings, replacing the deprecated string and string[] data types.
- ›Migrates the IndexInverted property field to separate IndexFilterable and IndexSearchable fields for finer control over inverted index behavior.
└──▷ BREAKING ON UPGRADE
- !Downgrading from v1.19 to v1.18 is not supported after upgrading; a backup must be created before upgrading if a downgrade may be needed.
- !The string and string[] data types are deprecated in favor of text and text[] with explicit tokenization options.
v1.18.4 Apr 24, 2023 · issue -391

Weaviate v1.18.4 adds Azure support across all OpenAI modules.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.18.4 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.18.4
```
- ›Adds Azure support to all OpenAI modules, enabling use of Azure-hosted OpenAI endpoints alongside existing OpenAI integrations.
v1.18.3 Apr 4, 2023 · issue -391

Weaviate v1.18.3 adds GPT-3.5-turbo/GPT-4 support, a properties field for grouped generative results, and disk-space-aware shard assignment.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.18.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.18.3
```
- ›Adds support for GPT-3.5-turbo and GPT-4 models in the Generative OpenAI module.
- ›Adds properties field for groupedResult in the Generative AI (OpenAI) module to limit the number of tokens sent per request.
- ›Assigns shards and replicas to new classes based on available free disk space rather than a fixed strategy.
- ›Allows third-party module API key headers through in CORS preflight configuration.
v1.18.0 Mar 7, 2023 · issue -392

Weaviate v1.18.0 adds bitmap filtering, HNSW-PQ compression, BM25/Hybrid where filters, Cursor API, Azure backups, and full tunable replication consistency.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.18.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.18.0
```
└──▷ USE IT
Combine a BM25 keyword search with a where filter to scope full-text results to a subset of objects — not possible before v1.18.
graphql
```
{
  Get {
    Article(
      bm25: { query: "vector database" }
      where: { path: ["published"], operator: Equal, valueBoolean: true }
    ) {
      title
      _additional { score }
    }
  }
}
```
- ›Adds BACKUP_GCS_USE_AUTH environment variable to the backup-gcs module to allow alternative GCP authentication forms beyond default credentials.
- ›Adds Cursor API to scroll through every object in a class using an ID cursor, bypassing the QUERY_MAXIMUM_RESULTS limit at constant cost per page regardless of scale.
- ›Adds Azure Cloud Storage as a backup destination module, joining existing GCS and AWS S3 backup providers.
- ›Extends BM25 and Hybrid Search to support where filters, enabling combined keyword/vector + filter queries that were not possible in v1.17.
- ›Adds stopword support to BM25 scoring.
+7 moreshow less
- ›Extends all remaining replicated write and read endpoints with tunable consistency levels (including PUT and HEAD for objects, batch object reads, and object existence checks); changes the default consistency level from ALL to QUORUM.
- ›Adds automatic read-repair for replication: when Weaviate detects inconsistencies between replicas it repairs them automatically, including detection of deleted objects and concurrent repairs scaled to the configured consistency level.
- ›Introduces bitmap indexing (RoaringSet) for non-text properties in the LSM store, delivering up to 1,000x faster filtering; existing datasets continue working with the old index and a zero-downtime migration path is available.
- ›Adds optional HNSW-PQ (Product Quantization) vector compression, reducing memory footprint by 25–75% while retaining HNSW recall and performance.
- ›Reworks BM25 scoring to use the Weak-AND (WAND) algorithm with concurrent term evaluation, yielding more than 10x throughput improvement over v1.17.
- ›Adds API key authentication (API_KEY auth) that can be combined with existing OIDC authentication.
- ›Transfers backup files between S3, GCS, and Weaviate in a streaming fashion without loading file contents into memory.
v1.17.0 Dec 20, 2022 · issue -395

Weaviate v1.17 adds leaderless replication with tunable consistency and hybrid BM25F + dense-vector search.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.17.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.17.0
```
- ›Introduces leaderless replication with tunable consistency, enabling high availability and horizontal read-throughput scaling across a Weaviate cluster.
- ›Adds hybrid search combining BM25F keyword scoring and dense vector search with rank fusion, plus standalone pure BM25 and BM25F search modes.
- ›Supports dynamically adding nodes to a running cluster after data has already been imported.
- ›Adds TTLs to cluster-wide transactions covering schema and classification operations.
- ›Adjusts memtable size dynamically based on workload conditions.
v1.16.8 Dec 16, 2022 · issue -395

Weaviate v1.16.8 adds modelVersion support in text2vec-openai to enable the text-embedding-ada-002 model.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.16.8 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.16.8
```
- ›Adds modelVersion setting to the text2vec-openai module, enabling users to select the text-embedding-ada-002 model.
v1.16.0 Oct 31, 2022 · issue -397

Weaviate v1.16 adds distributed multi-node backups, null/length property filtering, ref2vec-centroid, Cohere and HuggingFace text2vec modules, and a cluster nodes status API.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.16.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.16.0
```
- ›Adds the ref2vec-centroid module, enabling vectorization of objects based on the centroid of their referenced objects' vectors.
- ›Adds the text2vec-cohere module for Cohere-powered text vectorization, including support for the experimental multilingual-2210-alpha Cohere model.
- ›Adds the text2vec-huggingface module with support for the HuggingFace Inference API.
- ›Adds an API endpoint to view cluster node status, surfacing per-node health and shard information.
- ›Adds support for OpenID scopes configuration, allowing operators to specify required scopes for OIDC authentication.
+7 moreshow less
- ›Adds a default vector distance metric setting, letting operators define the cluster-wide default metric for new classes.
- ›Extends one-command backups (introduced in v1.15) to distributed multi-node setups; backups from v1.15 single-node setups remain backward-compatible.
- ›Adds null-state property indexing and filtering, enabling efficient queries to find objects where a given property is set or unset — must be activated before importing data.
- ›Adds property-length indexing and filtering, enabling efficient queries to filter objects by the length of a property value — must be activated before importing data.
- ›Marks all shards as read-only automatically when a configurable memory threshold is reached, preventing data corruption under memory pressure.
- ›Allows creating class schemas with self-referential (recursive) references.
- ›Updates the OpenAI text2vec module to use the current OpenAI embeddings API.
v1.15.4 Oct 11, 2022 · issue -397

Weaviate v1.15.4 adds support for all AWS IAM-based authorizations.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.15.4 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.15.4
```
- ›Adds support for all AWS IAM-based authorization methods.
v1.15.0 Sep 7, 2022 · issue -398

Weaviate v1.15 adds cloud-native backups to S3/GCS, Manhattan and Hamming distance metrics, HuggingFace and SUM-Transformers modules, and new monitoring metrics.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.15.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.15.0
```
- ›Adds backup-s3 Weaviate module for backing up and restoring to/from AWS S3; requires the target bucket to already exist.
- ›Adds backup-gcs Weaviate module for backing up and restoring to/from Google Cloud Storage; requires the target bucket to already exist.
- ›Supports backing up and restoring multiple classes in a single request.
- ›Adds monitoring for backup and restore operations via Prometheus.
- ›Enables use of GOMEMLIMIT environment variable (Go 1.19) to cap Weaviate memory usage — a significant operational lever for high-memory deployments.
+8 moreshow less
- ›Adds manhattan distance metric as a new vector index option.
- ›Adds hamming distance metric as a new vector index option.
- ›Adds text2vec-huggingface module for vectorization via the HuggingFace Inference API.
- ›Adds sum-transformers module for summarization use cases.
- ›New Prometheus metrics for LSM memtable vitals (current size, operation durations), concurrent read/write requests, usage dimensions on Get requests, and vector index dimensions.
- ›Introduces a Red-Black Tree in the LSM Store to improve performance of ordered/sequential imports.
- ›Adds thread pooling for batch requests to improve import throughput.
- ›Significantly reduces memory footprint of HNSW index connections.
v1.14.0 Jul 7, 2022 · issue -400

Weaviate v1.14.0 adds Prometheus monitoring, official multi-distance-metric support, and class-namespaced REST endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.14.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.14.0
```
└──▷ TRY IT
Use l2-squared distance instead of cosine when defining a class schema, to unlock Euclidean-space nearest-neighbour search.
```
$ curl -X POST 'http://localhost:8080/v1/schema' \
  -H 'Content-Type: application/json' \
  -d '{"class": "MyClass", "vectorIndexConfig": {"distance": "l2-squared"}}'
```
- ›Adds new REST endpoints that include the class name as a namespace — e.g. object operations scoped to a specific class — eliminating ambiguity when an ID exists in multiple classes; old ID-only endpoints remain but are deprecated and will be removed in a future version.
- ›Officially supports cosine, l2-squared, and dot distance metrics in the vector index, replacing the previous experimental-only status for non-cosine metrics.
- ›Introduces distance as the supported similarity field in the API, replacing certainty (now deprecated) wherever it appears in queries.
- ›Adds Prometheus-compatible monitoring for import metrics, HNSW operations (inserts, deletes, cleanup), LSM store segment and compaction details, startup and crash-recovery metrics, batch-delete operations, and total imported object counts.
- ›Adds support for aggregating date fields in aggregate queries.
v1.13.2 May 20, 2022 · issue -402

Weaviate v1.13.2 previews L2 distance support, with full availability planned for v1.14.0.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.13.2
```
- ›Adds L2 distance metric support (preview/experimental — full support coming in v1.14.0).
v1.13.0 May 3, 2022 · issue -402

Weaviate v1.13.0 adds faceted vector search, result sorting, timestamp filtering, batch delete by filter, and DPR transformer support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.13.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.13.0
```
└──▷ TRY IT
Filter objects by creation timestamp — after enabling timestamp indexing — to scope queries to recently ingested data.
```
$ {
  Get {
    Article(
      where: {
        path: ["_creationTimeUnix"]
        operator: GreaterThan
        valueString: "1672531200000"
      }
    ) {
      title
    }
  }
}
```
Run a faceted vector search by combining nearText with Aggregate to count matching classes within a vector-search radius.
```
$ {
  Aggregate {
    Article(
      nearText: {
        concepts: ["machine learning"]
        certainty: 0.75
      }
    ) {
      meta { count }
      category { groupedBy { value } count }
    }
  }
}
```
- ›Adds path: ["_creationTimeUnix"] and path: ["_lastUpdateTimeUnix"] filter notation after optionally including creationTimeUnix and lastUpdateTimeUnix in the inverted index — enabling timestamp-based filtering for the first time.
- ›Adds a new /v1/batch endpoint supporting delete-by-filter, removing all objects that match a specified filter in one operation.
- ›Enables combining nearVector, nearObject, nearText, and other near<Media> vector searches with Aggregate queries for faceted vector search; requires an explicit limit or a certainty/distance threshold.
- ›Adds sorting of search results (reads affected objects from disk; columnar-storage optimization planned for a future release).
- ›Supports DPR (Dense Passage Retrieval) transformer models in text2vec-transformers, using two separate models to encode queries and passages independently.
v1.12.0 Apr 5, 2022 · issue -403

Weaviate v1.12.0 adds configurable stopword lists, unlimited certainty-based vector search, a Shard API, and disk-pressure auto-protection.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.12.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.12.0
```
- ›Adds Shard API to expose individual shard status and allow marking shards as read-only via the API, blocking writes while permitting reads.
- ›Introduces two configurable disk-pressure thresholds: a warning threshold (e.g. 80%) that logs alerts, and a critical threshold (e.g. 90%) that automatically marks all shards on the affected node as read-only.
- ›Enables unlimited vector search by certainty, returning all results within the desired certainty range regardless of internal limits, with a configurable global maximum to prevent out-of-memory conditions.
- ›Adds support for turning off tokenization on string fields so the entire field — including spaces — is indexed as a single token, preventing unwanted partial-string matches.
- ›Introduces a fully configurable inverted-index stopword list, applicable to exact-match queries now and in anticipation of upcoming BM25 and mixed BM25/dense-vector search support.
v1.11.0 Mar 14, 2022 · issue -404

Weaviate v1.11.0 lets you supply your OpenAI API key at query time instead of storing it server-side.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.11.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.11.0
```
- ›Enables passing the OpenAI API key at query time via the text2vec-openai module, avoiding the need to store third-party credentials on the server.
v1.10.0 Jan 27, 2022 · issue -406

Weaviate v1.10.0 adds OpenAI embeddings, QnA reranking, HNSW EF boundaries, and a HEAD /v1/objects/{id} existence check.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.10.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.10.0
```
└──▷ TRY IT
Check whether an object exists in Weaviate without fetching or deserializing its properties — useful in high-throughput pipelines where you only need a yes/no answer.
```
$ curl -s -o /dev/null -w "%{http_code}" -X HEAD http://localhost:8080/v1/objects/<id>
```
Set HNSW EF boundaries in a class schema to prevent result quality degradation on low-limit queries while capping inference overhead on large ones.
json
```
{
  "class": "Article",
  "vectorIndexConfig": {
    "dynamicEfMin": 100,
    "dynamicEfMax": 500,
    "dynamicEfFactor": 8
  }
}
```
- ›Adds HEAD /v1/objects/{id} endpoint that returns 204 when an object exists or 404 when it does not, without loading or unmarshaling the full object from disk.
- ›Adds ask: { rerank: true } to the QnA module so that multiple answer candidates are drawn from the top-n results and re-ranked by qna-specific score rather than always extracting from the single top semantic result.
- ›Adds dynamicEfMin (default 100), dynamicEfMax (default 500), and dynamicEfFactor (default 8) HNSW config parameters to bound and tune automatic ef derivation at query time.
- ›Adds the text2vec-openai module, enabling OpenAI embeddings as a vectorizer for both import and query inference with a valid OpenAI API key.
- ›Allows importing objects without a vector when vector indexing is enabled, so vectors can be added later via an update.
+1 moreshow less
- ›Allows manually overriding the vector on a class that has a vectorizer module configured, provided the replacement vector has matching dimensions and vector space.
v1.9.0 Dec 10, 2021 · issue -407

Weaviate v1.9.0 introduces the multi2vec-clip module for multi-modal image+text vectorization in a single vector space.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.9.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.9.0
```
└──▷ TRY IT
Create a CLIP-vectorized class that embeds both image and text fields, weighting text at 70% and images at 30%, to enable cross-modal search.
```
$ curl -X POST http://localhost:8080/v1/schema -H 'Content-Type: application/json' -d '{
  "class": "ClipExample",
  "vectorizer": "multi2vec-clip",
  "vectorIndexType": "hnsw",
  "moduleConfig": {
    "multi2vec-clip": {
      "imageFields": ["image"],
      "textFields": ["name"],
      "weights": {
        "textFields": [0.7],
        "imageFields": [0.3]
      }
    }
  },
  "properties": [
    {"dataType": ["string"], "name": "name"},
    {"dataType": ["blob"], "name": "image"}
  ]
}'
```
- ›Adds the multi2vec-clip module (set via vectorizer: multi2vec-clip and moduleConfig.multi2vec-clip) enabling multi-modal vectorization of image (blob) and text/string fields within a single shared vector space, with optional per-field weighting via weights.imageFields and weights.textFields.
- ›Adds nearImage search alongside nearText search in the multi2vec-clip module, supporting cross-modal queries such as text search over image-only content.
- ›Supports base64-encoded image ingestion via blob-typed properties when using the multi2vec-clip module.
v1.8.0 Nov 30, 2021 · issue -408

Weaviate v1.8.0 adds horizontal scaling with multi-shard indices, paginated search via offset, and filtered vector search improvements.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.8.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.8.0
```
└──▷ TRY IT
Page through search results in REST to retrieve results 76-100 without re-fetching from the start.
```
$ curl 'http://localhost:8080/v1/objects?limit=25&offset=75'
```
Pin a stable cluster hostname in docker-compose before upgrading to v1.8.0 so shard ownership survives container restarts.
```
$ CLUSTER_HOSTNAME=node1 docker-compose up -d
```
- ›Adds offset pagination parameter to GET /v1/objects?limit=25&offset=75 and GraphQL Get { Class(limit:25, offset:75) { } } for paging through list, vector, and filter search results.
- ›Adds QUERY_MAXIMUM_RESULTS environment variable to raise the default 10,000-object pagination cap (use with caution — high values can spike memory and slow the cluster).
- ›Adds CLUSTER_HOSTNAME environment variable to assign a stable node hostname, required for correct shard resolution in multi-node or docker-compose deployments.
- ›Introduces horizontal scalability with multi-shard indices, enabling Weaviate to run as a cluster across multiple nodes with configurable sharding per class (shardingConfig in schema).
- ›Introduces a Flat-Search Cutoff for filtered vector search, switching automatically to a flat scan when the filtered candidate set is small enough to make HNSW traversal suboptimal.
+1 moreshow less
- ›Adds cacheable inverted-index filter segments to accelerate repeated filtered vector searches.
└──▷ BREAKING ON UPGRADE
- !Upgrading to v1.8.0 triggers an automatic, irreversible on-disk data migration from the single fixed-name shard layout used in v1.7.x to the new multi-shard layout; downgrading to v1.7.x afterwards requires a pre-upgrade backup.
- !docker-compose deployments without a stable hostname will fail after docker-compose down + restart because the migrated shard is pinned to the container ID hostname; set CLUSTER_HOSTNAME=<stable-name> before first starting v1.8.0 to prevent this.
v1.7.0 Sep 1, 2021 · issue -410

Weaviate v1.7.0 adds array datatypes, a spellcheck module with auto-correct, and transformer-based NER at query time.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.7.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.7.0
```
└──▷ USE IT
Check spelling of a nearText query without altering results — useful when you want to surface correction hints to the end user.
graphql
```
{
  Get {
    Post(nearText: { concepts: "missspelled text" }) {
      content
      _additional {
        spellCheck {
          changes { corrected original }
          didYouMean
          location
          originalText
        }
      }
    }
  }
}
```
Extract named entities from stored object content at query time using the ner-transformers module.
graphql
```
{
  Get {
    Post {
      content
      _additional {
        tokens(
          properties: ["content"],
          limit: 10,
          certainty: 0.8
        ) {
          certainty
          endPosition
          entity
          property
          startPosition
          word
        }
      }
    }
  }
}
```
- ›Adds array primitive datatypes (string[], text[], int[], number[]) to the schema, enabling lists of primitives to be stored, filtered, and aggregated like scalar properties; auto-schema automatically recognizes lists of string/text and number/int.
- ›New text-spellcheck module exposes a spellCheck field under _additional in GraphQL queries, returning per-term corrections (corrected, original), a didYouMean suggestion, location, and originalText at query time without altering results.
- ›New ner-transformers module exposes a tokens field under _additional in GraphQL queries for on-the-fly named-entity extraction from object properties, with optional properties, limit, and certainty parameters returning entity, word, startPosition, endPosition, certainty, and property per token.
v1.6.0 Aug 11, 2021 · issue -411

Weaviate v1.6.0 adds zero-shot classification via "type": "zeroshot" in POST /v1/classficiations
└──▷ GET THIS VERSION
```
$ git clone --branch v1.6.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.6.0
```
└──▷ TRY IT
Run zero-shot classification to automatically label objects by vector proximity, filtering both source and target label objects inline.
```
$ curl -X POST http://localhost:8080/v1/classficiations \
  -H 'Content-Type: application/json' \
  -d '{
    "class": "Article",
    "type": "zeroshot",
    "classifyProperties": ["ofCategory"],
    "sourceWhere": { "operator": "IsNull", "path": ["ofCategory"], "valueBoolean": true },
    "targetWhere": { "operator": "Equal", "path": ["active"], "valueBoolean": true }
  }'
```
- ›Adds "type": "zeroshot" to the POST /v1/classficiations API, enabling zero-shot classification that works with any vectorizer or custom vectors — no training data required; use "classifyProperties", "sourceWhere", and "targetWhere" to control which objects and labels are classified.
v1.5.0 Jul 13, 2021 · issue -412

Weaviate v1.5.0 rewrites storage with a custom LSM-tree engine and adds Auto-Schema for schema-free imports.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.5.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.5.0
```
- ›Adds Auto-Schema feature: import data objects without a pre-defined schema — Weaviate infers property types on first use, is enabled by default, and defaults are configurable via environment variables.
- ›Replaces B+Tree storage with a custom LSM-tree storage engine, delivering import speeds more than 100% faster than previous versions at scale.
└──▷ BREAKING ON UPGRADE
- !The entire storage mechanism has been replaced with an LSM-tree implementation: in-place upgrades from previous versions are not possible. A new Weaviate setup must be created and all data reimported. Prior backups are not compatible with v1.5.0.
v1.4.0 Jun 9, 2021 · issue -413

Weaviate v1.4.0 adds image vectorization via img2vec-neural, a new blob datatype, nearImage search, per-query ef tuning, and full arm64 support.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.4.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.4.0
```
└──▷ USE IT
Configure a class to vectorize images with img2vec-neural using a blob field, then search for similar images at query time using nearImage.
graphql
```
{
  Get {
    MyImage(nearImage: {
      image: "/9j/4AAQSkZJRgABAgE..."
      certainty: 0.7
    }) {
      image
    }
  }
}
```
Override the HNSW ef parameter at schema time to increase recall at the cost of query latency.
json
```
{
  "class": "Article",
  "vectorIndexConfig": {
    "skip": false,
    "ef": 100,
    "efConstruction": 128,
    "maxConnections": 64
  }
}
```
- ›Adds img2vec-neural vectorizer module with imageFields config in moduleConfig to vectorize images using neural networks; resnet50 (pytorch and keras) supported at launch, with pytorch variant supporting amd64, arm64, and CUDA.
- ›Adds nearImage GraphQL search operator to vectorize a query image at search time and retrieve results by image similarity.
- ›Adds "skip": true option in vectorIndexConfig to bypass HNSW vector indexing entirely for classes where vectorization is unnecessary (e.g. reference-only or high-duplicate classes); defaults to false.
- ›Adds ef field to vectorIndexConfig (settable at schema definition and updatable post-creation) to tune HNSW recall/performance trade-off at search time; defaults to -1 (auto).
- ›Introduces new primitive datatype blob for storing arbitrary base64-encoded binary data; blob fields are never indexed in the inverted index, so valueBlob in whereFilters is not supported.
+2 moreshow less
- ›Adds AVX2 hardware-accelerated dot-product calculations for amd64 (Intel/AMD) CPUs, improving vector import and query throughput; falls back to native Go on non-AVX2 or other architectures.
- ›Supports the entire Weaviate stack natively on arm64 (e.g. Apple M1); components include Weaviate Core, text2vec-contextionary, text2vec-transformers, qna-transformers, and img2vec-neural (pytorch only); Docker images are now published as multi-architecture images requiring no configuration changes.
v1.3.0 Apr 23, 2021 · issue -415

Weaviate v1.3.0 adds a BERT-based Q&A module with a new ask{} GraphQL searcher and richer transformer model metadata via /v1/meta.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.3.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.3.0
```
└──▷ USE IT
Ask a natural-language question against a Paragraph class and return the extracted answer with its certainty score.
graphql
```
{
  Get {
    Paragraph(
      ask: {
        question: "what is the population of Berlin?"
        certainty: 0.8
      }
    ) {
      _additional { answer { hasAnswer result certainty property startPosition endPosition } }
      text
    }
  }
}
```
- ›Introduces the qna-transformers module, enabling BERT-style answer extraction via a new ask{} searcher on GraphQL Get { ... } queries, configured with a "question" (required string), optional "certainty" (float 0..1), and optional "properties" ([]string).
- ›Adds a new _additional { answer { } } response field containing hasAnswer (boolean), result (nullable string), certainty (nullable float), property (nullable string), startPosition (int), and endPosition (int) — surfacing extracted answers directly in query results.
- ›Supports custom Hugging Face models for Q&A via the semitechnologies/qna-transformers:custom base image, compatible with transformers.AutoModelForQuestionAnswering.
- ›Expands the GET /v1/meta endpoint to include meta information about transformer models in use across all transformer-based modules.
v1.2.0 Mar 15, 2021 · issue -416

Weaviate v1.2.0 adds out-of-the-box transformer NLP model support via the text2vec-transformers module with GPU-friendly microservice architecture.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.2.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.2.0
```
└──▷ USE IT
Select the pooling strategy for a schema class so sentence vectors use the CLS token rather than masked mean — useful when following BERT fine-tuning conventions.
json
```
{
  "class": "Article",
  "moduleConfig": {
    "text2vec-transformers": {
      "poolingStrategy": "cls"
    }
  }
}
```
- ›Adds ENABLE_MODULES=text2vec-transformers environment variable to enable transformer-based vectorization (BERT, DistilBERT, RoBERTa, etc.) without custom code.
- ›Adds DEFAULT_VECTORIZER_MODULE=text2vec-transformers environment variable to set transformers as the default vectorizer across all schema classes.
- ›Adds TRANSFORMERS_INFERENCE_API environment variable to point Weaviate at a separately hosted inference container, enabling GPU-optimized model serving independent of Weaviate's CPU-optimized core.
- ›Adds poolingStrategy class-level module config for the text2vec-transformers module, accepting masked_mean or cls to control how sentence vectors are derived from word vectors.
- ›Supports vectorizeClassName, vectorizePropertyName, and skip module-configuration fields on classes and properties for the text2vec-transformers module, mirroring the existing text2vec-contextionary API.
+2 moreshow less
- ›Makes ENABLE_MODULES a required environment variable for any module usage (including text2vec-contextionary), enforcing explicit module declaration.
- ›Ships pre-built Docker inference containers for popular transformer models (e.g. semitechnologies/transformers-inference:sentence-transformers-msmarco-distilroberta-base-v2), with support for custom Hugging Face Hub models and local PyTorch/TensorFlow models.
v1.1.0 Feb 10, 2021 · issue -417

Weaviate v1.1.0 adds nearObject GraphQL search and delivers 30–50% faster cross-reference batch imports.
└──▷ GET THIS VERSION
```
$ git clone --branch v1.1.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout v1.1.0
```
└──▷ USE IT
Find objects most similar to a known object ID without having to retrieve its vector first.
graphql
```
{
  Get{
    Publication(
      nearObject: {
        id: "27b5213d-e152-4fea-bd63-2063d529024d",
        certainty: 0.7
      }
    ){
      name
      _additional {
        certainty
      }
    }
  }
}
```
- ›Adds nearObject search parameter to GraphQL Get queries, letting you find the most similar objects to a given id or beacon in a single step — no need to first retrieve the vector and run a separate nearVector search; supports a certainty threshold.
- ›Supports combining nearObject with movement operations in the text2vec-contextionary module.
- ›Cross-reference batch imports are now 30–50% faster on cross-reference-heavy datasets by recognising that reference updates do not change vector positions and skipping a full re-index of affected objects.
0.23.0 Dec 18, 2020 · issue -419

Weaviate 0.23.0 goes standalone: drops Elasticsearch and etcd for a custom vector-first storage engine with HNSW indexing.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.23.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.23.0
```
- ›Replaces Elasticsearch and etcd runtime dependencies with Weaviate's own vector-first storage system, making the service fully standalone.
- ›Introduces a custom HNSW vector index implementation with full CRUD support, Write-Ahead-Commit-Log persistence, and ongoing maintenance tasks — enabling sub-50ms 20NN-vector queries on datasets of 1–100M objects.
- ›Adds a pluggable vector index architecture (HNSW is the first supported plugin) backed by bolt/bbolt for inverted index and object storage disk operations.
- ›Supports running with available memory smaller than total vector size via a cache-based mem/disk strategy — no requirement to keep all vectors in RAM.
- ›Explicitly defines the behavior of the Like operator (wildcard semantics, modelled after Elasticsearch wildcards).
+1 moreshow less
- ›Explicitly defines multi-word query behavior for the Equal operator on string and text properties: words are segmented and all segments must match; string splits on spaces only, text splits on all non-alphanumeric characters.
└──▷ BREAKING ON UPGRADE
- !Upgrading from 0.22.x requires a full data reimport — live upgrade is not possible because the storage mechanism has completely changed.
- !The /v1/c11y/words endpoint is removed; use /v1/c11y/concepts instead.
- !The ?meta=true query parameter on GET requests is removed; use ?include=... instead.
- !The meta property in object bodies is removed; use underscore fields directly (e.g. _classification).
- !The meta field in cross-references is removed; use the _classification field directly.
- !The cardinality field on properties is removed.
- !The keywords field on classes and properties is removed.
- !The Like operator now has explicitly defined wildcard semantics instead of delegating to a third-party dependency; existing queries may behave differently.
- !The Equal operator on multi-word string and text properties now has explicitly defined segmentation behavior instead of delegating to a third-party dependency.
0.22.20 Nov 27, 2020 · issue -420

Weaviate 0.22.20 adds kNN classification distance fields and brings standalone mode to feature parity with ES-based mode.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.20 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.20
```
- ›Adds eight new distance fields to the _classification underscore prop's ref meta for kNN-classified objects: overallCount, winningCount, losingCount, meanWinningDistance, meanLosingDistance, closestOverallDistance, closestWinningDistance, and closestLosingDistance.
- ›Standalone mode reaches feature parity with the Elasticsearch-based mode, with a production-ready release (removing all ES features) targeted for v0.23.0.
0.22.19 Oct 19, 2020 · issue -421

Weaviate 0.22.19 adds _certainty underscore prop to Get {} queries with explore set.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.19 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.19
```
- ›Adds _certainty underscore prop to Get {} queries when the explore parameter is set, enabling certainty scores (proximity to the search query) that were previously only available on Explore {}.
0.22.16 Sep 15, 2020 · issue -422

Weaviate 0.22.16 adds full environment-variable config support, eliminating the need for a separate config file.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.16 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.16
```
└──▷ TRY IT
Enable OIDC authentication with AdminList authorization entirely via environment variables in a docker-compose deployment, replacing a separate config file.
```
$ AUTHENTICATION_OIDC_ENABLED=true
AUTHENTICATION_OIDC_ISSUER=https://myissuer.com
AUTHENTICATION_OIDC_CLIENT_ID=my-client-id
AUTHENTICATION_OIDC_USERNAME_CLAIM=email
AUTHENTICATION_OIDC_GROUPS_CLAIM=groups
AUTHORIZATION_ADMINLIST_ENABLED=true
[email protected],[email protected]
[email protected],[email protected]
ORIGIN=https://my-weaviate-deployment.com
CONFIGURATION_STORAGE_URL=http://etcd:2379
CONTEXTIONARY_URL=http://contextionary
ESVECTOR_URL=http://esvector:9200
```
- ›Adds ORIGIN, CONFIGURATION_STORAGE_URL, CONTEXTIONARY_URL, ESVECTOR_URL, ESVECTOR_NUMBER_OF_SHARDS, ESVECTOR_AUTO_EXPAND_REPLICAS, STANDALONE_MODE, PERSISTENCE_DATA_PATH, AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED, AUTHENTICATION_OIDC_ENABLED, AUTHENTICATION_OIDC_ISSUER, AUTHENTICATION_OIDC_CLIENT_ID, AUTHENTICATION_OIDC_USERNAME_CLAIM, AUTHENTICATION_OIDC_GROUPS_CLAIM, AUTHORIZATION_ADMINLIST_ENABLED, AUTHORIZATION_ADMINLIST_USERS, and AUTHORIZATION_ADMINLIST_READONLY_USERS environment variables, allowing full configuration of Weaviate without a separate config file.
- ›Expands CRUD capabilities in experimental STANDALONE_MODE=true standalone mode, a preview of features planned for 1.0.0.
0.22.15 Aug 28, 2020 · issue -423

Weaviate 0.22.15 adds optional compound-word splitting in the Contextionary and multi-threaded classification.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.15 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.15
```
└──▷ USE IT
Enable compound splitting for a German-language deployment where arbitrary compound nouns would otherwise be missed during vectorization.
yaml
```
ENABLE_COMPOUND_SPLITTING=true
```
- ›Adds ENABLE_COMPOUND_SPLITTING environment variable on the Contextionary container to split otherwise-unrecognized compound words (e.g. 'thunderstormcloud' → 'thunderstorm + cloud') during vectorization; disabled by default due to up-to-100% import-time overhead, but especially valuable for compounding languages like Dutch and German.
- ›Both kNN and contextual classification types now run multi-threaded, using one thread per available CPU core, significantly speeding up classification on larger machines.
0.22.13 Jul 10, 2020 · issue -424

Weaviate 0.22.13 adds _semanticPath GraphQL property to trace concept paths between search terms and results.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.13 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.13
```
- ›Adds _semanticPath underscore property to Get{} GraphQL queries with explore: {} set, returning the concept chain (e.g. ['iphone', 'apple', 'company', 'microsoft']) between the search term and each result; maximum limit for requests including _semanticPath is 25; requires contextionary v0.4.14 or later.
0.22.12 Jun 26, 2020 · issue -425

Weaviate 0.22.12 adds _featureProjection to reduce vector dimensionality for 2D/3D visualization via REST and GraphQL.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.12 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.12
```
└──▷ USE IT
Retrieve objects with 3D t-SNE projections in GraphQL to feed a scatter-plot visualization of a large corpus.
graphql
```
{
  Get {
    Article(limit: 100) {
      title
      _featureProjection(dimensions: 3, algorithm: "tsne", perplexity: 5, learningRate: 25, iterations: 100) {
        vector
      }
    }
  }
}
```
Quickly fetch objects with default 2D projections via REST without writing a GraphQL query.
```
$ curl -X GET 'http://localhost:8080/v1/things?include=_featureProjection&limit=100'
```
- ›Adds _featureProjection underscore prop to REST GET /v1/{kinds}/?include=_featureProjection and GraphQL Get {} queries, reducing object vectors to lower-dimensional representations (default 2D) for visualization.
- ›Supports GraphQL parameters for _featureProjection: dimensions (int, default 2), algorithm (string, default tsne), perplexity (int, default min(5, len(results)-1)), learningRate (int, default 25), and iterations (int, default 100).
- ›Ships t-SNE as the first supported dimensionality-reduction algorithm under _featureProjection, with the underlying algorithm designed to be exchangeable in future releases.
0.22.11 Jun 24, 2020 · issue -425

Weaviate 0.22.11 adds _nearestNeighbors underscore prop to REST and GraphQL APIs for neighbor concept discovery.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.11 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.11
```
└──▷ TRY IT
Retrieve an object's nearest neighboring concepts inline with a single REST call — useful when investigating semantic similarity without a separate query.
```
$ curl 'https://<weaviate-host>/v1/things/<id>?include=_nearestNeighbors'
```
- ›Adds _nearestNeighbors underscore prop to the single-object REST endpoint (GET /v1/{kind}/{id}) and list endpoint (GET /v1/{kinds}) via ?include=_nearestNeighbors query parameter, surfacing neighboring concept data alongside standard responses.
- ›Adds _nearestNeighbors{} prop support to GraphQL Get {} queries, allowing nearest-neighbor data to be requested alongside schema-defined props.
0.22.8 Jun 17, 2020 · issue -425

Weaviate 0.22.8 adds _classification and _interpretation underscore props to REST and GraphQL (use 0.22.9 instead — this release has a known regression).
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.8 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.8
```
- ›Adds _classification underscore prop to REST (?include=_classification) and GraphQL, exposing classification metadata for objects that were subject to a classification — previously only available via the now-deprecated ?meta=true REST parameter, and not available in GraphQL at all.
- ›Adds _interpretation underscore prop to REST (?include=_interpretation) and GraphQL, exposing vectorization metadata including which words were usable, their weights, and per-concept occurrence frequency from the contextionary; requires contextionary version ...-v0.4.12 or later.
- ›Deprecates meta?=true/false REST query parameter in favor of explicit ?include=_classification and ?include=_vector underscore props; estimated removal in 0.23.0.
0.22.7 Apr 29, 2020 · issue -427

Weaviate 0.22.7 rewrites contextual classification with Information Gain and tf-idf weighting, lifting accuracy from 18% to 58% on main categories.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.7 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.7
```
└──▷ USE IT
Tune contextual classification to reduce stop-word noise on a long-text corpus by setting Information Gain and tf-idf cutoffs.
yaml
```
type: contextual
informationGainCutoffPercentile: 10
informationGainMaximumBoost: 3
tfidfCutoffPercentile: 80
```
- ›Rewrites the contextual classification algorithm using two new user-configurable metrics — Information Gain and tf-idf — to down-weight stop words and filler words; benchmark on the 20 Newsgroups dataset shows main-category success rate rising from 18% to 58% and granular-category (20 classes) from 10% to 42%.
- ›Adds informationGainCutoffPercentile, informationGainMaximumBoost, and tfidfCutoffPercentile configuration parameters to the contextual classification to let practitioners tune word-weighting and removal thresholds for their dataset.
0.22.6 Apr 6, 2020 · issue -427

Weaviate 0.22.6 adds reference-count filtering so you can query objects by how many linked references they have.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.6 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.6
```
- ›Enables filtering objects by the count of their references using existing compare operators (Equal, LessThan, LessThanEqual, GreaterThan, GreaterThanEqual) directly on a reference path in GraphQL where filters — supporting queries like 'find all authors who wrote at least 2 articles' or 'show all cities with no country association'.
0.22.5 Apr 1, 2020 · issue -427

Weaviate 0.22.5 adds navigable API root with hypertext links and cross-reference href fields across REST endpoints.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.5
```
- ›The / path now redirects (301 Moved Permanently) to /v1, and /v1 returns a JSON list of main API categories with documentation links instead of 404 Not Found.
- ›Adds an origin config option: when set, all root and cross-reference hyperlinks are rendered as absolute URIs, enabling correct link generation behind a reverse proxy; when unset, relative links are used.
- ›All REST endpoints that return cross-references now include a read-only href field alongside the existing beacon field, providing an HTTP hypertext reference to the respective resource.
0.22.4 Mar 5, 2020 · issue -428

Weaviate 0.22.4 adds contextionary language support for German, Dutch, Italian, and Czech.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.4 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.4
```
- ›Adds contextionary language support for German, Dutch, Italian, and Czech in contextionary version xx0.13.0-v0.4.7, with example Docker Compose files provided for each language.
0.22.3 Mar 3, 2020 · issue -428

Weaviate 0.22.3 exposes object vector positions via meta=true on both single-object and list queries.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.3
```
└──▷ TRY IT
Retrieve a list of things with their 600-dimensional vector positions included for downstream similarity analysis.
```
$ curl 'http://localhost:8080/v1/things?meta=true'
```
- ›Adds vector position data to the meta object returned by GET /v1/things and GET /v1/actions when the meta=true query parameter is set — regardless of whether the object was part of a classification. Note: each vector is ~5 KB when JSON-encoded, so use only when necessary.
0.22.2 Feb 28, 2020 · issue -429

Weaviate 0.22.2 adds a phoneNumber primitive data type with automatic international parsing and normalization.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.2
```
- ›Adds phoneNumber primitive data type with two user-settable sub-fields — input (required, type string) and defaultCountry (optional, ISO 3166-1 alpha-2 string) — for storing and normalizing phone numbers.
- ›Returns seven read-only parsed sub-fields on phoneNumber objects: internationalFormatted (string), national (unsigned integer), nationalFormatted (string), countryCode (unsigned integer), valid (boolean), input (string), and defaultCountry (string).
- ›Full phoneNumber type definition available in the openapi-specs/schema.json Swagger specification.
0.22.1 Feb 4, 2020 · issue -429

Weaviate 0.22.1 adds vectorWeights field to Thing and Action objects for per-word vector weight control.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.22.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.22.1
```
└──▷ TRY IT
Boost domain-critical words ('far', 'near') when indexing optometry content so they carry more weight in the resulting vector.
```
$ curl -X POST http://localhost:8080/v1/things \
  -H 'Content-Type: application/json' \
  -d '{
    "class": "Glasses",
    "schema": {
      "description": "These glasses are meant for far-sighted people"
    },
    "vectorWeights": {
      "far": "5 * w",
      "near": "5 * w"
    }
  }'
```
- ›Adds vectorWeights field to Thing and Action objects in POST /v1/things (and actions) requests — a string-to-string key-value map where keys are words and values are math expressions (using w for the original weight) that override contextionary-assigned weights at vector-creation time.
0.21.11 Jan 16, 2020 · issue -430

Weaviate 0.21.11 adds Entity Merging to deduplicate vector search results using closest or merge grouping strategies.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.11 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.11
```
- ›Adds Entity Merging capability with closest and merge grouping strategies, letting Weaviate deduplicate results by grouping objects that describe the same real-world entity based on vector distance, controlled by a force parameter (0.0–1.0).
- ›The closest strategy surfaces only the result closest to the query per group, while the merge strategy preserves original field values — string fields show all original values, numerical fields show a mean, and reference fields aggregate all references from merged objects.
0.21.10 Jan 16, 2020 · issue -430

Weaviate 0.21.10 adds per-class and per-property vectorization control via vectorizeClassName and vectorizePropertyName schema fields.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.10 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.10
```
└──▷ USE IT
Exclude the class name and property names from vectorization so only property values determine an object's vector position — useful for deduplication or classification tasks where class/property names add noise.
yaml
```
class: Fruit
vectorizeClassName: false
properties:
- name: name
  dataType: ["string"]
  vectorizePropertyName: false
```
- ›Adds vectorizeClassName boolean field at the schema/{things,actions} class level to control whether the class name is included in vectorization (defaults to true).
- ›Adds vectorizePropertyName boolean field at the property level in schema/{things,actions} to control whether property names are included in vectorization (defaults to false).
- ›Relaxes contextionary-validity requirement for class names when vectorizeClassName: false is set, and for property names when vectorizePropertyName: false is set, enabling use of arbitrary identifiers without causing import failures.
- ›Updates contextionary dependency to version v0.4.5 to provide more precise error messages when vectorization fails due to invalid input.
0.21.6 Dec 18, 2019 · issue -431

Weaviate 0.21.6 adds configurable sharding, replication, and supernode threshold controls for the vector index.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.6 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.6
```
- ›Adds vectorIndex.numberOfShards (integer) and vectorIndex.autoExpandReplicas (string) config keys to control Elasticsearch shard and replica defaults per class, mirroring Elasticsearch index-module settings.
- ›Adds vectorIndex.supernodeThreshold (integer) config key to override the default threshold (100 outgoing references) at which a class is treated as a supernode.
0.21.5 Dec 6, 2019 · issue -431

Weaviate 0.21.5 adds sourceWhere, trainingSetWhere, and targetWhere filters to narrow classification runs.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.5
```
- ›Adds sourceWhere filter to classification API to limit which unclassified objects are processed during a classification run.
- ›Adds trainingSetWhere filter to classification API to restrict the training set, usable with training-set-based types such as 'type': 'knn'.
- ›Adds targetWhere filter to classification API to restrict potential label targets, usable with direct-relationship types such as 'type': 'contextual'.
0.21.4 Dec 6, 2019 · issue -431

Weaviate 0.21.4 adds contextual classification — no training data required, targets chosen by vector distance.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.4 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.4
```
- ›Adds type: contextual classification to the classification API payload, enabling vector-distance-based classification without training data; omit the k field (which is knn-only) when using this type.
0.21.2 Nov 28, 2019 · issue -432

Weaviate 0.21.2 adds dedicated /v1/.well-known/live and /v1/.well-known/ready health endpoints that bypass auth.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.2
```
└──▷ TRY IT
Use the dedicated liveness endpoint in a Kubernetes liveness probe so auth (e.g. OIDC) never blocks the health check.
```
$ curl -sf http://weaviate:8080/v1/.well-known/live && echo 'alive'
```
Use the readiness endpoint in a load-balancer or Kubernetes readiness probe to gate traffic until Weaviate is fully up.
```
$ curl -sf http://weaviate:8080/v1/.well-known/ready && echo 'ready'
```
- ›Adds unauthenticated liveness endpoint GET /v1/.well-known/live returning 204 No Content when the Weaviate instance is alive, bypassing OIDC and other auth schemes.
- ›Adds unauthenticated readiness endpoint GET /v1/.well-known/ready returning 204 No Content when the instance is ready to serve traffic, decoupled from auth-protected endpoints like /v1/meta.
0.21.1 Nov 15, 2019 · issue -432

Weaviate 0.21.1 adds wildcard string matching via the Like operator in where filters.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.1
```
- ›Adds Like operator to where filters, enabling wildcard partial-match searches on string fields using * glob syntax (e.g. valueString: "Ap*e" matches "Apple" and "Apache").
0.21.0 Nov 13, 2019 · issue -432

Weaviate 0.21.0 adds RFC 7396 merge-patch support for PATCH endpoints and reintroduces batch reference adding.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.21.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.21.0
```
└──▷ TRY IT
Partially update a Thing's properties without replacing the whole object — useful for updating a single field in CI/CD pipelines or event-driven workflows.
```
$ curl -X PATCH 'http://localhost:8080/v1/things/<id>' \
  -H 'Content-Type: application/json' \
  -d '{"class": "Article", "schema": {"title": "Updated Title"}}'
```
- ›Adds RFC 7396 (application/merge-patch+json) merge-style patching to PATCH /v1/things/{id} and PATCH /v1/actions/{id}, replacing the previous RFC 6902 patch semantics; successful merges return 204 No Content.
- ›Reintroduces batch-adding of references via POST /v1/batching/references, restoring a capability removed in 0.20.0.
└──▷ BREAKING ON UPGRADE
- !PATCH /v1/things/ and PATCH /v1/actions/ now use merge-style (RFC 7396) patch semantics instead of RFC 6902 patch semantics; clients sending RFC 6902 JSON Patch bodies will no longer work correctly.
0.20.4 Nov 6, 2019 · issue -432

Weaviate 0.20.4 lets you extend the contextionary with custom concepts via a new /v1/c11y/extensions API endpoint.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.20.4 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.20.4
```
- ›Adds a new API (see /v1/c11y/extensions in the swagger spec) to extend the contextionary with custom concepts — overwrite existing concept meanings or add entirely new ones; requires contextionary service version xxxxx-v0.4.0 or later.
- ›Introduces the /v1/c11y/concepts/... endpoint family as the replacement for /v1/c11y/words/..., with identical behavior but a cleaner path.
0.20.3 Oct 11, 2019 · issue -433

Weaviate 0.20.3 lets you disable vectorization and search indexing per property via index: false in the schema.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.20.3 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.20.3
```
- ›Adds index: false to property schema definitions, allowing specific properties to be excluded from both vectorization and Elasticsearch text-based indexing; properties default to indexed when index: true or omitted.
0.20.2 Oct 10, 2019 · issue -433

Weaviate 0.20.2 adds kNN-based classification via /v1/classifications/ and a new meta=true option on thing retrieval.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.20.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.20.2
```
└──▷ TRY IT
Inspect whether a retrieved object's cross-reference was set by a user or assigned automatically by classification.
```
$ curl 'http://localhost:8080/v1/things/Dish/<id>?meta=true'
```
- ›Adds POST /v1/classifications/ endpoint to trigger kNN-based classification of data objects using cross-referenced schema classes as training data.
- ›Adds ?meta=true query parameter on GET /things/{kinds}/{id} to expose additional fields, including classification provenance (whether a reference was set by user input or by classification).
0.20.0 Sep 27, 2019 · issue -434

Weaviate 0.20.0 replaces Janusgraph/Cassandra with an esvector-only backend, merges the GraphQL Meta and Aggregate APIs, and adds forced index refresh on missing cross-references.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.20.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.20.0
```
└──▷ USE IT
Tune how many cross-reference levels Weaviate caches to balance query depth against storage cost — increase for deep, narrow schemas; decrease for shallow, wide ones.
yaml
```
vector_index:
  denormalizationDepth: 4
```
- ›Replaces the Janusgraph + Elasticsearch + Cassandra stack with a single vector-optimized Elasticsearch ('esvector') backend, delivering faster listing queries, lower infrastructure footprint, and fully integrated native vector search.
- ›Configures cross-reference denormalization depth via vector_index.denormalizationDepth in config.yaml (default: 3), controlling how many reference levels are cached in the background for efficient traversal and filtering.
- ›Forces an Elasticsearch index refresh when a cross-referenced object is not yet visible on the index, then retries immediately — eliminating the need for client-side retry logic when adding objects with cross-references in rapid succession.
- ›GraphQL Meta API is merged into the Aggregate API, with grouping now an optional parameter rather than always on or always off.
- ›Distinguishes text properties (mapped as Elasticsearch text, for full-text fields) from string properties (mapped as Elasticsearch keyword, for exact values like emails and IDs), with aggregations now supported only on string props.
└──▷ BREAKING ON UPGRADE
- !The GraphQL Meta API is merged into the Aggregate API; any queries targeting the separate Meta API will break.
- !The base unit for geoCoordinates search distance changed from kilometer to meter; existing query values must be multiplied by 1000.
- !Aggregations (e.g. top-N value counts) on text properties are no longer supported; only string properties support aggregations from 0.20.0 onward.
0.19.2 Aug 8, 2019 · issue -435

Weaviate 0.19.2 routes GraphQL Get() queries with explore arguments entirely through the esvector backend for major performance gains.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.19.2 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.19.2
```
- ›GraphQL Get() queries that include an explore: { ... } argument are now served entirely through the esvector backend, delivering significant performance improvements for result sets larger than 20 items.
0.19.0 Aug 6, 2019 · issue -435

Weaviate 0.19.0 overhauls the REST API base path, GraphQL naming, and cross-reference representation with a stable-API milestone.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.19.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.19.0
```
└──▷ TRY IT
Check the running Weaviate version and contextionary word count after upgrading — useful for validating a fresh 0.19.0 deployment.
```
$ curl http://localhost:8080/v1/meta
```
Add a Thing with a cross-reference using the new beacon field and mandatory array format, replacing the old $cref single-object pattern.
```
$ curl -X POST http://localhost:8080/v1/things \
  -H 'Content-Type: application/json' \
  -d '{"class": "City", "schema": {"inCountry": [{"beacon": "weaviate://localhost/things/<uuid>"}]}}'
```
- ›Adds additional fields to GET /v1/meta response: running Weaviate version, connected contextionary version, and the number of words in the contextionary.
- ›Adds group: {type: 'closest|merge', force: <float>} argument to GraphQL Get -> Things/Actions -> ClassName fields (implementation reserved for a future release; accepted without error in 0.19.0).
- ›Adds ...on Beacon { beacon } inline fragment support to Cross-Refs in the GraphQL Get API for retrieving reference URIs (accepted in schema; errors in 0.19.0 pending implementation).
└──▷ BREAKING ON UPGRADE
- !API base path changed from /weaviate/v1 to /v1 — all existing clients and integrations must update their base URL.
- !GET /meta no longer returns schema information; schema must now be retrieved via GET /v1/schema.
- !GraphQL root-level field GetMeta is renamed to Meta.
- !Cross-reference field $cref is renamed to beacon in all request payloads (e.g. POST /things, POST /actions, PUT /things/<id>, PUT /actions/<id>, PATCH /things, PATCH /actions).
- !Cross-references are now always represented as an array regardless of cardinality — payloads that previously sent a single object for atMostOne cardinality must now send an array (e.g. {"inCountry": [{"beacon": "..."}]}).
- !No clean upgrade path from 0.18.x: internal database fields were renamed, requiring a fresh 0.19.0 instance and full data re-import rather than an in-place upgrade.
0.18.1 Jul 30, 2019 · issue -436

Weaviate 0.18.1 lets you combine vector explore and structured where filters in a single Get query.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.18.1 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.18.1
```
- ›Enables combining the explore argument with a where argument inside a Get retrieval query, allowing vector-based ranking alongside exact string, keyword, or geo-spatial filtering in a single request.
0.17.0 Jul 22, 2019 · issue -436

Weaviate 0.17.0 adds vector indexing at import time and two new GQL vector-search surfaces: { Local { Explore }} and explore() in { Local { Get }}.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.17.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.17.0
```
- ›Adds new GQL field { Local { Explore }} for concept (vector-based) search across Weaviate's vector search backend.
- ›Extends { Local { Get }} with a new explore() argument enabling vector-based concept search alongside the existing where() structured search.
- ›Imports through non-batch paths now generate and store a vector representation in Weaviate's vector database at import time.
└──▷ BREAKING ON UPGRADE
- !Vector-based concept search requires a new esvector backend — see docker-compose/runtime/docker-compose.yml for a reference configuration.
- !Vectors are only created at import time with no reindex capability, so upgrading to 0.17.x requires setting up a fresh Weaviate installation and reimporting all concepts.
0.16.0 Jul 9, 2019 · issue -436

Weaviate 0.16.0 lets users supply their own UUIDs on POST and batch endpoints, simplifying cross-reference imports.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.16.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.16.0
```
└──▷ TRY IT
Pre-assign a UUID when creating a thing so you can wire up cross-references without waiting for a server-generated ID.
```
$ curl -X POST http://localhost:8080/things \
  -H 'Content-Type: application/json' \
  -d '{"id": "a7e10b51-1f3e-4f5a-8d2e-000000000001", "class": "Article", "schema": {"title": "Example"}}'
```
- ›Adds user-specified UUID support: set the id field on POST /things, POST /actions, POST /batching/things, and POST /batching/actions to assign your own UUIDs instead of letting Weaviate generate them, making cross-reference preparation possible without round-tripping for server-assigned IDs.
0.15.0 Jun 24, 2019 · issue -437

Weaviate 0.15.0 adds read-only user support to the AdminList authorization plugin.
└──▷ GET THIS VERSION
```
$ git clone --branch 0.15.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.15.0
```
- ›Extends the AdminList authorization plugin with a read_only_users list, enabling three permission tiers: Admins (full CRUD), read-only users, and authenticated-but-unauthorized users.
0.14.5 Jun 5, 2019 · issue -437

Weaviate 0.14.5 adds OIDC discovery redirect at GET /weaviate/v1/.well-known/openid-configuration
└──▷ GET THIS VERSION
```
$ git clone --branch 0.14.5 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.14.5
```
- ›Adds GET /weaviate/v1/.well-known/openid-configuration endpoint that redirects (302 Found) to the configured token issuer's OIDC discovery page when OIDC auth is enabled, or returns 404 Not Found when no OIDC issuer is configured.
0.13.0 May 21, 2019 · issue -438

Weaviate 0.13.0: initial stable release with GraphQL traversal, pluggable backends, and OIDC auth support
└──▷ GET THIS VERSION
```
$ git clone --branch 0.13.0 https://github.com/weaviate/weaviate.git
# already have the repo? check out this version:
$ git checkout 0.13.0
```
- ›Supports pluggable database backends ('connectors'), defaulting to janusgraph with cassandra for storage and elasticsearch as the indexing backend
- ›Pluggable authentication and authorization providers, defaulting to anonymous_access with optional OIDC (Open ID Connect) configuration
- ›Full REST API for CRUD operations on schema and concepts (Things and Actions)
- ›Dynamic graph traversal via GraphQL, including context-based search through 'Fetch' GQL APIs
- ›Optional asynchronous analytics jobs via Spark integration
+3 moreshow less
- ›Horizontal scaling (HA) support and 12-factor compatible configuration management
- ›Production-quality Helm charts available (separate release lifecycle) and Docker Compose 'Try Out' setups
- ›Ships as Docker image semitechnologies/weaviate:0.13.0

Weaviate

Summary

What Weaviate answers

Examples

Command line

Release history